webserver-service

doc:
  short_help: Ensures a webserver is installed and running.
  help: |
    This frecklet helps you set up a webserver.

    Currently the 'nginx' and 'apache' webservers are supported. This does not configure the webserver, except for some
    basic stuff. It does, however, setup dependencies like letsencrypt certificates, htpasswd files, etc.

    More features are planned, like setting up php and configure it to work with the webserver, for example.

    To do webserver configuration, use one of the templig frecklets, like 'apache-vhost-exists'. More of those will be
    coming in the future.

  references:
    freckfrackery.webserver Ansible role: https://gitlab.com/freckfrackery/freckfrackery.webserver
    geerlingguy.apache Ansible role: https://github.com/geerlingguy/ansible-role-apache
    geerlingguy.apache Nginx role: https://github.com/geerlingguy/ansible-role-nginx
  examples:
  - title: Install Apache webserver, incl. letsencrypt and PHP
    vars:
      webserver: apache
      letsencrypt_webroot: /var/www/html
      use_https: true
      letsencrypt_email: [email protected]
      letsencrypt_domains:
      - dev.frkl.io
      use_php: true
      php_packages:
        debian:
        - php-zip
        - php-curl
        - php-gd
        - php-mbstring
        - php-mcrypt
        - php-xml
        - php-xmlrpc
        - php-mysql
  - title: Install Nginx webserver, incl. letsencrypt.
    vars:
      webserver: nginx
      letsencrypt_webroot: /var/ww/html
      use_https: true
      letsencrypt_email: [email protected]
      letsencrypt_domains:
      - dev.frkl.io


args:
  webserver:
    doc:
      short_help: The webserver to install, either 'nginx' (default) or 'apache'.
    type: string
    default: nginx
    required: false
    cli:
      metavar: WEBSERVER
  skip_cert_request:
    doc:
      short_help: Whether to skip letsencrypt certificate request.
    type: boolean
    default: false
    required: false
  letsencrypt_domains:
    doc:
      short_help: The domains (for requesting https certificates).
    type: list
    schema:
      type: string
    required: false
    empty: true
    cli:
      metavar: DOMAIN
  letsencrypt_webroot:
    doc:
      short_help: The document root, needed for letsencrypt certificate requests.
    required: false
    type: string
    cli:
      metavar: PATH
  use_https:
    doc:
      short_help: Whether to use https and request a letsencrypt certificate.
    type: boolean
    required: false
    default: false
    cli:
      is_flag: true
  letsencrypt_email:
    doc:
      short_help: The email to use when requesting a letsencrypt certificate.
    type: string
    required: false
    cli:
      metavar: EMAIL
  letsencrypt_staging:
    doc:
      short_help: Whether to use the letsencrypt staging server (for developing --
        production only allows a few requests per day).
    type: boolean
    required: false
    default: false
    cli:
      is_flag: true
  use_basic_auth:
    doc:
      short_help: Whether to setup basic auth.
    type: boolean
    default: false
    required: false
    cli:
      enabled: false
  basic_auth_users:
    doc:
      short_help: A dict with username as key, password as value.
    type: dict
    required: false
    cli:
      enabled: false
  basic_auth_user_file:
    doc:
      short_help: The file to store htpasswd information.
    type: string
    required: false
    default: /etc/htpasswd
    cli:
      show_default: true
  webserver_user:
    doc:
      short_help: The user to run the webserver as.
    type: string
    required: false
    cli:
      metavar: USERNAME
  webserver_group:
    doc:
      short_help: The group to run the webserver as (if applicable).
    type: string
    required: false
    cli:
      metavar: GROUP
  webserver_apache_config:
    doc:
      short_help: Extra, Apache-specific vars.
      references:
      - '[geerlingguy.nginx Ansible role](https://github.com/geerlingguy/ansible-role-apache)'
    type: dict
    required: false
    cli:
      enabled: false
      help: |
        Key/Value pairs in this variable will be forwared to the [geerligguy.nginx Ansible role](https://github.com/geerlingguy/ansible-role-apache), check its documentation for details.
  webserver_nginx_config:
    doc:
      short_help: Extra, Nginx-specific vars.
      help: |
        Key/Value pairs in this variable will be forwared to the [geerligguy.nginx Nginx role](https://github.com/geerlingguy/ansible-role-nginx), check its documentation for details.
      references:
      - '[geerlingguy.nginx Ansible role](https://github.com/geerlingguy/ansible-role-nginx)'
    type: dict
    required: false
    cli:
      enabled: false
  webserver_use_pagespeed:
    doc:
      short_help: Whether to install the pagespeed module.
      help: |
        Whether to install and use the pagespeed module.

        Only Nginx currently supported, when using this with Apache it will be ignored.
        Nginx will be built from source if set to true.
    type: boolean
    default: false
    cli:
      param_decls:
      - --use-pagespeed/--no-use-pagespeed
  listen_port:
    doc:
      short_help: The port the webserver is listening on by default.
    type: integer
    default: 80
    required: false
    cli:
      metavar: PORT
  listen_port_https:
    doc:
      short_help: The port the webserver is listening on by default (for https).
    type: integer
    required: false
    default: 443
    cli:
      metavar: PORT
  use_php:
    doc:
      short_help: Whether to install & enable PHP (fpm).
    required: false
    type: boolean
    default: false
    cli:
      is_flag: true
  php_packages:
    doc:
      short_help: Platform-dependent php-package names.
      help: |
        A map of platform-dependent php packages to install.

        Specified in the form:

        ```
        php_packages:
          <platform_matcher>:
            - <pkg1>
            - ...
        ```

        For example:
        ```
        php_packages:
          debian:
            - php-zip
          ubuntu:
            - php-zip
            - php-gd
          redhat:
            - <whatever, no idea how those are named>
        ```
    type: dict
    required: false
    default: {}
    empty: true
    cli:
      enabled: false
  php_config:
    doc:
      short_help: PHP config
      help: |
        PHP config.

        This forwards 'fpm'-related configuration key/values to the [geerlingguy.php Ansible role](https://github.com/geerlingguy/ansible-role-php)". For a list of available vars refer to its README file.
    type: dict
    required: false
    default: {}
    empty: true
    cli:
      enabled: false
  php_fpm_user:
    doc:
      short_help: The user to run the php-fpm daemon.
    type: string
    required: false
    cli:
      metavar: USER
  php_fpm_group:
    doc:
      short_help: The group to run the php-fpm daemon.
    type: string
    required: false
    cli:
      metavar: GROUP
  php_fpm_config:
    doc:
      short_help: PHP fpm config
      help: |
        PHP fpm config.

        This forwards 'fpm'-related configuration key/values to the [geerlingguy.php Ansible role](https://github.com/geerlingguy/ansible-role-php)". Available vars:

          - php_fpm_listen: "127.0.0.1:9000"
          - php_fpm_listen_allowed_clients: "127.0.0.1"
          - php_fpm_pm_max_children: 50
          - php_fpm_pm_start_servers: 5
          - php_fpm_pm_min_spare_servers: 5
          - php_fpm_pm_max_spare_servers: 5

      references:
      - '[geerlingguy.php Ansible role](https://github.com/geerlingguy/ansible-role-php)'
    type: dict
    required: false
    default: {}
    empty: true
    schema:
      php_fpm_listen:
        required: false
        type: string
      php_fpm_listen_allowed_clients:
        required: false
        type: string
      php_fpm_max_children:
        required: false
        type: integer
      php_fpm_start_servers:
        required: false
        type: integer
      php_fpm_min_spare_servers:
        required: false
        type: integer
      php_fpm_max_spare_servers:
        required: false
        type: integer
    cli:
      enabled: false
  restart_webserver:
    doc:
      short_help: Whether to restart the webserver afterwards.
    type: boolean
    required: false
    default: false
    cli:
      is_flag: true

meta:
  tags:
  - webserver
  - nginx
  - apache
  - setup
  - web
  - service
  - featured-frecklecutable

frecklets:
#  - user-exists:
#      name: "{{:: webserver_user ::}}"
#      group: "{{:: webserver_group ::}}"
- frecklet:
    name: freckfrackery.webserver
    type: ansible-role
    resources:
      ansible-role:
      - freckfrackery.webserver
      - geerlingguy.apache
      - geerlingguy.nginx
      - geerlingguy.php
      - thefinn93.letsencrypt
      - nickhammond.logrotate
      - ncg.nginx
    desc:
      short: 'install the {{:: webserver ::}} webserver'
      references:
        "'freckfrackery.webserver' Ansible role": https://gitlab.com/freckfrackery/freckfrackery.webserver
    properties:
      idempotent: true
      elevated: true
      internet: true
  vars:
    webserver_name: '{{:: webserver ::}}'
    webserver_letsencrypt_webroot: '{{:: letsencrypt_webroot ::}}'
    webserver_use_https: '{{:: use_https ::}}'
    webserver_letsencrypt_email: '{{:: letsencrypt_email ::}}'
    webserver_letsencrypt_staging: '{{:: letsencrypt_staging ::}}'
    webserver_use_basic_auth: '{{:: use_basic_auth ::}}'
    webserver_basic_auth_users: '{{:: basic_auth_users ::}}'
    webserver_basic_auth_user_file: '{{:: basic_auth_user_file ::}}'
    webserver_user: '{{:: webserver_user ::}}'
    webserver_group: '{{:: webserver_group ::}}'
    webserver_apache_config: '{{:: webserver_apache_config ::}}'
    webserver_nginx_config: '{{:: webserver_nginx_config ::}}'
    webserver_listen_port: '{{:: listen_port ::}}'
    webserver_listen_port_ssl: '{{:: listen_port_https ::}}'
    webserver_use_php: '{{:: use_php ::}}'
    webserver_php_packages: '{{:: php_packages ::}}'
    webserver_php_config: '{{:: php_config ::}}'
    webserver_php_fpm_user: '{{:: php_fpm_user ::}}'
    webserver_php_fpm_group: '{{:: php_fpm_group ::}}'
    webserver_php_fpm_config: '{{:: php_fpm_config ::}}'
    webserver_letsencrypt_domains: '{{:: letsencrypt_domains ::}}'
    webserver_skip_cert_request: '{{:: skip_cert_request ::}}'
    webserver_use_pagespeed: '{{:: webserver_use_pagespeed ::}}'
- init-service-restarted:
    frecklet::skip: '{{:: restart_webserver | negate ::}}'
    name: '{{:: webserver ::}}'

frecklecute webserver-service --help

Usage: frecklecute webserver-service [OPTIONS]

  This frecklet helps you set up a webserver.

  Currently the 'nginx' and 'apache' webservers are supported. This does not
  configure the webserver, except for some basic stuff. It does, however,
  setup dependencies like letsencrypt certificates, htpasswd files, etc.

  More features are planned, like setting up php and configure it to work
  with the webserver, for example.

  To do webserver configuration, use one of the templig frecklets, like
  'apache-vhost-exists'. More of those will be coming in the future.

Options:
  --basic-auth-user-file BASIC_AUTH_USER_FILE
                                  The file to store htpasswd information.
  --letsencrypt-domains DOMAIN    The domains (for requesting https
                                  certificates).
  --letsencrypt-email EMAIL       The email to use when requesting a
                                  letsencrypt certificate.
  --letsencrypt-staging / --no-letsencrypt-staging
                                  Whether to use the letsencrypt staging
                                  server (for developing -- production only
                                  allows a few requests per day).
  --letsencrypt-webroot PATH      The document root, needed for letsencrypt
                                  certificate requests.
  --listen-port PORT              The port the webserver is listening on by
                                  default.
  --listen-port-https PORT        The port the webserver is listening on by
                                  default (for https).
  --php-fpm-group GROUP           The group to run the php-fpm daemon.
  --php-fpm-user USER             The user to run the php-fpm daemon.
  --restart-webserver / --no-restart-webserver
                                  Whether to restart the webserver afterwards.
  --skip-cert-request / --no-skip-cert-request
                                  Whether to skip letsencrypt certificate
                                  request.
  --use-https / --no-use-https    Whether to use https and request a
                                  letsencrypt certificate.
  --use-php / --no-use-php        Whether to install & enable PHP (fpm).
  --webserver WEBSERVER           The webserver to install, either 'nginx'
                                  (default) or 'apache'.
  --webserver-group GROUP         The group to run the webserver as (if
                                  applicable).
  --use-pagespeed / --no-use-pagespeed
                                  Whether to install the pagespeed module.
  --webserver-user USERNAME       The user to run the webserver as.
  --help                          Show this message and exit.

# -*- coding: utf-8 -*-


#
# module path: pycklets.webserver_service.WebserverService
#


from dataclasses import dataclass
from pyckles import AutoPycklet
from typing import *    # noqa

@dataclass
class WebserverService(AutoPycklet):
    """This frecklet helps you set up a webserver.

     Currently the 'nginx' and 'apache' webservers are supported. This does not configure the webserver, except for some
     basic stuff. It does, however, setup dependencies like letsencrypt certificates, htpasswd files, etc.

     More features are planned, like setting up php and configure it to work with the webserver, for example.

     To do webserver configuration, use one of the templig frecklets, like 'apache-vhost-exists'. More of those will be
     coming in the future.

       Args:
         basic_auth_user_file: The file to store htpasswd information.
         basic_auth_users: A dict with username as key, password as value.
         letsencrypt_domains: The domains (for requesting https certificates).
         letsencrypt_email: The email to use when requesting a letsencrypt certificate.
         letsencrypt_staging: Whether to use the letsencrypt staging server (for developing -- production only allows a few requests per day).
         letsencrypt_webroot: The document root, needed for letsencrypt certificate requests.
         listen_port: The port the webserver is listening on by default.
         listen_port_https: The port the webserver is listening on by default (for https).
         php_config: PHP config
         php_fpm_config: PHP fpm config
         php_fpm_group: The group to run the php-fpm daemon.
         php_fpm_user: The user to run the php-fpm daemon.
         php_packages: Platform-dependent php-package names.
         restart_webserver: Whether to restart the webserver afterwards.
         skip_cert_request: Whether to skip letsencrypt certificate request.
         use_basic_auth: Whether to setup basic auth.
         use_https: Whether to use https and request a letsencrypt certificate.
         use_php: Whether to install & enable PHP (fpm).
         webserver: The webserver to install, either 'nginx' (default) or 'apache'.
         webserver_apache_config: Extra, Apache-specific vars.
         webserver_group: The group to run the webserver as (if applicable).
         webserver_nginx_config: Extra, Nginx-specific vars.
         webserver_use_pagespeed: Whether to install the pagespeed module.
         webserver_user: The user to run the webserver as.

    """

    FRECKLET_ID = "webserver-service"

    basic_auth_user_file: str = None
    basic_auth_users: Dict = None
    letsencrypt_domains: List = None
    letsencrypt_email: str = None
    letsencrypt_staging: bool = None
    letsencrypt_webroot: str = None
    listen_port: int = None
    listen_port_https: int = None
    php_config: Dict = None
    php_fpm_config: Dict = None
    php_fpm_group: str = None
    php_fpm_user: str = None
    php_packages: Dict = None
    restart_webserver: bool = None
    skip_cert_request: bool = None
    use_basic_auth: bool = None
    use_https: bool = None
    use_php: bool = None
    webserver: str = None
    webserver_apache_config: Dict = None
    webserver_group: str = None
    webserver_nginx_config: Dict = None
    webserver_use_pagespeed: bool = None
    webserver_user: str = None


    def __post_init__(self):
        super(WebserverService, self).__init__(var_names=["basic_auth_user_file", "basic_auth_users", "letsencrypt_domains", "letsencrypt_email", "letsencrypt_staging", "letsencrypt_webroot", "listen_port", "listen_port_https", "php_config", "php_fpm_config", "php_fpm_group", "php_fpm_user", "php_packages", "restart_webserver", "skip_cert_request", "use_basic_auth", "use_https", "use_php", "webserver", "webserver_apache_config", "webserver_group", "webserver_nginx_config", "webserver_use_pagespeed", "webserver_user"])


frecklet_class = WebserverService

# -*- coding: utf-8 -*-


#
# module path: pycklets.webserver_service.WebserverService
#


from pyckles import AutoPycklet

class WebserverService(AutoPycklet):
    """This frecklet helps you set up a webserver.

     Currently the 'nginx' and 'apache' webservers are supported. This does not configure the webserver, except for some
     basic stuff. It does, however, setup dependencies like letsencrypt certificates, htpasswd files, etc.

     More features are planned, like setting up php and configure it to work with the webserver, for example.

     To do webserver configuration, use one of the templig frecklets, like 'apache-vhost-exists'. More of those will be
     coming in the future.

       Args:
         basic_auth_user_file: The file to store htpasswd information.
         basic_auth_users: A dict with username as key, password as value.
         letsencrypt_domains: The domains (for requesting https certificates).
         letsencrypt_email: The email to use when requesting a letsencrypt certificate.
         letsencrypt_staging: Whether to use the letsencrypt staging server (for developing -- production only allows a few requests per day).
         letsencrypt_webroot: The document root, needed for letsencrypt certificate requests.
         listen_port: The port the webserver is listening on by default.
         listen_port_https: The port the webserver is listening on by default (for https).
         php_config: PHP config
         php_fpm_config: PHP fpm config
         php_fpm_group: The group to run the php-fpm daemon.
         php_fpm_user: The user to run the php-fpm daemon.
         php_packages: Platform-dependent php-package names.
         restart_webserver: Whether to restart the webserver afterwards.
         skip_cert_request: Whether to skip letsencrypt certificate request.
         use_basic_auth: Whether to setup basic auth.
         use_https: Whether to use https and request a letsencrypt certificate.
         use_php: Whether to install & enable PHP (fpm).
         webserver: The webserver to install, either 'nginx' (default) or 'apache'.
         webserver_apache_config: Extra, Apache-specific vars.
         webserver_group: The group to run the webserver as (if applicable).
         webserver_nginx_config: Extra, Nginx-specific vars.
         webserver_use_pagespeed: Whether to install the pagespeed module.
         webserver_user: The user to run the webserver as.

    """

    FRECKLET_ID = "webserver-service"

    def __init__(self, basic_auth_user_file="/etc/htpasswd", basic_auth_users=None, letsencrypt_domains=None, letsencrypt_email=None, letsencrypt_staging=None, letsencrypt_webroot=None, listen_port=80, listen_port_https=443, php_config=None, php_fpm_config=None, php_fpm_group=None, php_fpm_user=None, php_packages=None, restart_webserver=None, skip_cert_request=None, use_basic_auth=None, use_https=None, use_php=None, webserver="nginx", webserver_apache_config=None, webserver_group=None, webserver_nginx_config=None, webserver_use_pagespeed=None, webserver_user=None):

        super(WebserverService, self).__init__(var_names=["basic_auth_user_file", "basic_auth_users", "letsencrypt_domains", "letsencrypt_email", "letsencrypt_staging", "letsencrypt_webroot", "listen_port", "listen_port_https", "php_config", "php_fpm_config", "php_fpm_group", "php_fpm_user", "php_packages", "restart_webserver", "skip_cert_request", "use_basic_auth", "use_https", "use_php", "webserver", "webserver_apache_config", "webserver_group", "webserver_nginx_config", "webserver_use_pagespeed", "webserver_user"])
        self._basic_auth_user_file = basic_auth_user_file
        self._basic_auth_users = basic_auth_users
        self._letsencrypt_domains = letsencrypt_domains
        self._letsencrypt_email = letsencrypt_email
        self._letsencrypt_staging = letsencrypt_staging
        self._letsencrypt_webroot = letsencrypt_webroot
        self._listen_port = listen_port
        self._listen_port_https = listen_port_https
        self._php_config = php_config
        self._php_fpm_config = php_fpm_config
        self._php_fpm_group = php_fpm_group
        self._php_fpm_user = php_fpm_user
        self._php_packages = php_packages
        self._restart_webserver = restart_webserver
        self._skip_cert_request = skip_cert_request
        self._use_basic_auth = use_basic_auth
        self._use_https = use_https
        self._use_php = use_php
        self._webserver = webserver
        self._webserver_apache_config = webserver_apache_config
        self._webserver_group = webserver_group
        self._webserver_nginx_config = webserver_nginx_config
        self._webserver_use_pagespeed = webserver_use_pagespeed
        self._webserver_user = webserver_user

    @property
    def basic_auth_user_file(self):
        return self._basic_auth_user_file

    @basic_auth_user_file.setter
    def basic_auth_user_file(self, basic_auth_user_file):
        self._basic_auth_user_file = basic_auth_user_file

    @property
    def basic_auth_users(self):
        return self._basic_auth_users

    @basic_auth_users.setter
    def basic_auth_users(self, basic_auth_users):
        self._basic_auth_users = basic_auth_users

    @property
    def letsencrypt_domains(self):
        return self._letsencrypt_domains

    @letsencrypt_domains.setter
    def letsencrypt_domains(self, letsencrypt_domains):
        self._letsencrypt_domains = letsencrypt_domains

    @property
    def letsencrypt_email(self):
        return self._letsencrypt_email

    @letsencrypt_email.setter
    def letsencrypt_email(self, letsencrypt_email):
        self._letsencrypt_email = letsencrypt_email

    @property
    def letsencrypt_staging(self):
        return self._letsencrypt_staging

    @letsencrypt_staging.setter
    def letsencrypt_staging(self, letsencrypt_staging):
        self._letsencrypt_staging = letsencrypt_staging

    @property
    def letsencrypt_webroot(self):
        return self._letsencrypt_webroot

    @letsencrypt_webroot.setter
    def letsencrypt_webroot(self, letsencrypt_webroot):
        self._letsencrypt_webroot = letsencrypt_webroot

    @property
    def listen_port(self):
        return self._listen_port

    @listen_port.setter
    def listen_port(self, listen_port):
        self._listen_port = listen_port

    @property
    def listen_port_https(self):
        return self._listen_port_https

    @listen_port_https.setter
    def listen_port_https(self, listen_port_https):
        self._listen_port_https = listen_port_https

    @property
    def php_config(self):
        return self._php_config

    @php_config.setter
    def php_config(self, php_config):
        self._php_config = php_config

    @property
    def php_fpm_config(self):
        return self._php_fpm_config

    @php_fpm_config.setter
    def php_fpm_config(self, php_fpm_config):
        self._php_fpm_config = php_fpm_config

    @property
    def php_fpm_group(self):
        return self._php_fpm_group

    @php_fpm_group.setter
    def php_fpm_group(self, php_fpm_group):
        self._php_fpm_group = php_fpm_group

    @property
    def php_fpm_user(self):
        return self._php_fpm_user

    @php_fpm_user.setter
    def php_fpm_user(self, php_fpm_user):
        self._php_fpm_user = php_fpm_user

    @property
    def php_packages(self):
        return self._php_packages

    @php_packages.setter
    def php_packages(self, php_packages):
        self._php_packages = php_packages

    @property
    def restart_webserver(self):
        return self._restart_webserver

    @restart_webserver.setter
    def restart_webserver(self, restart_webserver):
        self._restart_webserver = restart_webserver

    @property
    def skip_cert_request(self):
        return self._skip_cert_request

    @skip_cert_request.setter
    def skip_cert_request(self, skip_cert_request):
        self._skip_cert_request = skip_cert_request

    @property
    def use_basic_auth(self):
        return self._use_basic_auth

    @use_basic_auth.setter
    def use_basic_auth(self, use_basic_auth):
        self._use_basic_auth = use_basic_auth

    @property
    def use_https(self):
        return self._use_https

    @use_https.setter
    def use_https(self, use_https):
        self._use_https = use_https

    @property
    def use_php(self):
        return self._use_php

    @use_php.setter
    def use_php(self, use_php):
        self._use_php = use_php

    @property
    def webserver(self):
        return self._webserver

    @webserver.setter
    def webserver(self, webserver):
        self._webserver = webserver

    @property
    def webserver_apache_config(self):
        return self._webserver_apache_config

    @webserver_apache_config.setter
    def webserver_apache_config(self, webserver_apache_config):
        self._webserver_apache_config = webserver_apache_config

    @property
    def webserver_group(self):
        return self._webserver_group

    @webserver_group.setter
    def webserver_group(self, webserver_group):
        self._webserver_group = webserver_group

    @property
    def webserver_nginx_config(self):
        return self._webserver_nginx_config

    @webserver_nginx_config.setter
    def webserver_nginx_config(self, webserver_nginx_config):
        self._webserver_nginx_config = webserver_nginx_config

    @property
    def webserver_use_pagespeed(self):
        return self._webserver_use_pagespeed

    @webserver_use_pagespeed.setter
    def webserver_use_pagespeed(self, webserver_use_pagespeed):
        self._webserver_use_pagespeed = webserver_use_pagespeed

    @property
    def webserver_user(self):
        return self._webserver_user

    @webserver_user.setter
    def webserver_user(self, webserver_user):
        self._webserver_user = webserver_user



frecklet_class = WebserverService