1
0
mirror of https://github.com/Mailu/Mailu.git synced 2024-12-14 10:53:30 +02:00
Mailu/core/admin/mailu/manage.py

487 lines
15 KiB
Python
Raw Normal View History

2021-01-14 02:11:04 +02:00
""" Mailu command line interface
"""
2021-01-14 02:11:04 +02:00
import sys
import os
import socket
import uuid
2021-01-14 02:11:04 +02:00
2018-10-18 16:20:56 +02:00
import click
import yaml
2021-01-14 02:11:04 +02:00
from flask import current_app as app
from flask.cli import FlaskGroup, with_appcontext
from marshmallow.exceptions import ValidationError
from . import models
from .schemas import MailuSchema
db = models.db
2021-01-14 02:11:04 +02:00
@click.group(cls=FlaskGroup, context_settings={'help_option_names': ['-?', '-h', '--help']})
def mailu():
2018-11-08 22:29:30 +02:00
""" Mailu command line
2018-10-18 16:20:56 +02:00
"""
2018-11-08 22:29:30 +02:00
@mailu.command()
@with_appcontext
def advertise():
""" Advertise this server against statistic services.
"""
2021-01-14 02:11:04 +02:00
if os.path.isfile(app.config['INSTANCE_ID_PATH']):
with open(app.config['INSTANCE_ID_PATH'], 'r') as handle:
instance_id = handle.read()
else:
instance_id = str(uuid.uuid4())
2021-01-14 02:11:04 +02:00
with open(app.config['INSTANCE_ID_PATH'], 'w') as handle:
handle.write(instance_id)
2021-01-14 02:11:04 +02:00
if not app.config['DISABLE_STATISTICS']:
try:
2021-01-14 02:11:04 +02:00
socket.gethostbyname(app.config['STATS_ENDPOINT'].format(instance_id))
except OSError:
pass
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('localpart')
@click.argument('domain_name')
@click.argument('password')
@click.option('-m', '--mode')
@with_appcontext
2019-08-21 15:35:41 +02:00
def admin(localpart, domain_name, password, mode='create'):
""" Create an admin user
'mode' can be:
- 'create' (default) Will try to create user and will raise an exception if present
- 'ifmissing': if user exists, nothing happens, else it will be created
- 'update': user is created or, if it exists, its password gets updated
"""
domain = models.Domain.query.get(domain_name)
if not domain:
domain = models.Domain(name=domain_name)
db.session.add(domain)
user = None
if mode == 'ifmissing' or mode == 'update':
email = f'{localpart}@{domain_name}'
user = models.User.query.get(email)
if user and mode == 'ifmissing':
print('user %s exists, not updating' % email)
return
if not user:
user = models.User(
localpart=localpart,
domain=domain,
global_admin=True
)
user.set_password(password)
db.session.add(user)
db.session.commit()
print("created admin user")
elif mode == 'update':
user.set_password(password)
db.session.commit()
print("updated admin password")
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('localpart')
@click.argument('domain_name')
@click.argument('password')
2019-02-13 11:53:40 +02:00
@click.argument('hash_scheme', required=False)
@with_appcontext
2018-10-18 17:55:07 +02:00
def user(localpart, domain_name, password, hash_scheme=None):
""" Create a user
"""
2018-10-18 17:55:07 +02:00
if hash_scheme is None:
hash_scheme = app.config['PASSWORD_SCHEME']
domain = models.Domain.query.get(domain_name)
if not domain:
domain = models.Domain(name=domain_name)
db.session.add(domain)
user = models.User(
localpart=localpart,
domain=domain,
global_admin=False
)
user.set_password(password, hash_scheme=hash_scheme)
db.session.add(user)
db.session.commit()
2019-07-08 10:35:59 +02:00
@mailu.command()
@click.argument('localpart')
@click.argument('domain_name')
@click.argument('password')
@click.argument('hash_scheme', required=False)
@with_appcontext
2019-07-08 10:35:59 +02:00
def password(localpart, domain_name, password, hash_scheme=None):
""" Change the password of an user
"""
email = f'{localpart}@{domain_name}'
user = models.User.query.get(email)
2019-07-08 10:35:59 +02:00
if hash_scheme is None:
hash_scheme = app.config['PASSWORD_SCHEME']
if user:
user.set_password(password, hash_scheme=hash_scheme)
else:
print(f'User {email} not found.')
2019-07-08 10:35:59 +02:00
db.session.commit()
2018-11-08 22:29:30 +02:00
@mailu.command()
2019-02-13 11:53:40 +02:00
@click.argument('domain_name')
2019-02-13 11:30:08 +02:00
@click.option('-u', '--max-users')
@click.option('-a', '--max-aliases')
@click.option('-q', '--max-quota-bytes')
@with_appcontext
def domain(domain_name, max_users=-1, max_aliases=-1, max_quota_bytes=0):
2019-02-13 11:53:40 +02:00
""" Create a domain
"""
domain = models.Domain.query.get(domain_name)
if not domain:
2019-02-13 16:43:45 +02:00
domain = models.Domain(name=domain_name, max_users=max_users,
max_aliases=max_aliases, max_quota_bytes=max_quota_bytes)
db.session.add(domain)
db.session.commit()
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('localpart')
@click.argument('domain_name')
@click.argument('password_hash')
@click.argument('hash_scheme')
@with_appcontext
2018-10-18 17:55:07 +02:00
def user_import(localpart, domain_name, password_hash, hash_scheme = None):
""" Import a user along with password hash
"""
2018-10-18 17:55:07 +02:00
if hash_scheme is None:
hash_scheme = app.config['PASSWORD_SCHEME']
domain = models.Domain.query.get(domain_name)
if not domain:
domain = models.Domain(name=domain_name)
db.session.add(domain)
user = models.User(
localpart=localpart,
domain=domain,
global_admin=False
)
user.set_password(password_hash, hash_scheme=hash_scheme, raw=True)
db.session.add(user)
db.session.commit()
# TODO: remove this deprecated function
@mailu.command()
@click.option('-v', '--verbose')
@click.option('-d', '--delete-objects')
@with_appcontext
def config_update(verbose=False, delete_objects=False):
""" Sync configuration with data from YAML (deprecated)
"""
new_config = yaml.safe_load(sys.stdin)
# print new_config
domains = new_config.get('domains', [])
tracked_domains = set()
for domain_config in domains:
if verbose:
print(str(domain_config))
domain_name = domain_config['name']
max_users = domain_config.get('max_users', -1)
max_aliases = domain_config.get('max_aliases', -1)
max_quota_bytes = domain_config.get('max_quota_bytes', 0)
tracked_domains.add(domain_name)
domain = models.Domain.query.get(domain_name)
if not domain:
domain = models.Domain(name=domain_name,
max_users=max_users,
max_aliases=max_aliases,
max_quota_bytes=max_quota_bytes)
db.session.add(domain)
print(f'Added {domain_config}')
else:
domain.max_users = max_users
domain.max_aliases = max_aliases
domain.max_quota_bytes = max_quota_bytes
db.session.add(domain)
print(f'Updated {domain_config}')
users = new_config.get('users', [])
tracked_users = set()
user_optional_params = ('comment', 'quota_bytes', 'global_admin',
'enable_imap', 'enable_pop', 'forward_enabled',
'forward_destination', 'reply_enabled',
'reply_subject', 'reply_body', 'displayed_name',
'spam_enabled', 'email', 'spam_threshold')
for user_config in users:
if verbose:
print(str(user_config))
localpart = user_config['localpart']
domain_name = user_config['domain']
password_hash = user_config.get('password_hash', None)
hash_scheme = user_config.get('hash_scheme', None)
domain = models.Domain.query.get(domain_name)
email = f'{localpart}@{domain_name}'
optional_params = {}
for k in user_optional_params:
if k in user_config:
optional_params[k] = user_config[k]
if not domain:
domain = models.Domain(name=domain_name)
db.session.add(domain)
user = models.User.query.get(email)
tracked_users.add(email)
tracked_domains.add(domain_name)
if not user:
user = models.User(
localpart=localpart,
domain=domain,
**optional_params
)
else:
for k in optional_params:
setattr(user, k, optional_params[k])
user.set_password(password_hash, hash_scheme=hash_scheme, raw=True)
db.session.add(user)
aliases = new_config.get('aliases', [])
tracked_aliases = set()
for alias_config in aliases:
if verbose:
print(str(alias_config))
localpart = alias_config['localpart']
domain_name = alias_config['domain']
if isinstance(alias_config['destination'], str):
destination = alias_config['destination'].split(',')
else:
destination = alias_config['destination']
wildcard = alias_config.get('wildcard', False)
domain = models.Domain.query.get(domain_name)
email = f'{localpart}@{domain_name}'
if not domain:
domain = models.Domain(name=domain_name)
db.session.add(domain)
alias = models.Alias.query.get(email)
tracked_aliases.add(email)
tracked_domains.add(domain_name)
if not alias:
alias = models.Alias(
localpart=localpart,
domain=domain,
wildcard=wildcard,
destination=destination,
email=email
)
else:
alias.destination = destination
alias.wildcard = wildcard
db.session.add(alias)
db.session.commit()
managers = new_config.get('managers', [])
# tracked_managers=set()
for manager_config in managers:
if verbose:
print(str(manager_config))
domain_name = manager_config['domain']
user_name = manager_config['user']
domain = models.Domain.query.get(domain_name)
manageruser = models.User.query.get(f'{user_name}@{domain_name}')
if manageruser not in domain.managers:
domain.managers.append(manageruser)
db.session.add(domain)
db.session.commit()
if delete_objects:
for user in db.session.query(models.User).all():
if not user.email in tracked_users:
if verbose:
print(f'Deleting user: {user.email}')
db.session.delete(user)
for alias in db.session.query(models.Alias).all():
if not alias.email in tracked_aliases:
if verbose:
print(f'Deleting alias: {alias.email}')
db.session.delete(alias)
for domain in db.session.query(models.Domain).all():
if not domain.name in tracked_domains:
if verbose:
print(f'Deleting domain: {domain.name}')
db.session.delete(domain)
db.session.commit()
2021-01-14 02:11:04 +02:00
SECTIONS = {'domains', 'relays', 'users', 'aliases'}
2018-11-08 22:29:30 +02:00
@mailu.command()
2020-09-04 12:57:40 +02:00
@click.option('-v', '--verbose', is_flag=True, help='Increase verbosity')
@click.option('-n', '--dry-run', is_flag=True, help='Perform a trial run with no changes made')
2021-01-14 02:11:04 +02:00
@click.argument('source', metavar='[FILENAME|-]', type=click.File(mode='r'), default=sys.stdin)
@with_appcontext
2021-01-14 02:11:04 +02:00
def config_import(verbose=False, dry_run=False, source=None):
""" Import configuration from YAML
2021-01-14 02:11:04 +02:00
"""
def log(**data):
caller = sys._getframe(1).f_code.co_name # pylint: disable=protected-access
if caller == '_track_import':
print(f'Handling {data["self"].opts.model.__table__} data: {data["data"]!r}')
def format_errors(store, path=None):
if path is None:
path = []
for key in sorted(store):
location = path + [str(key)]
value = store[key]
if isinstance(value, dict):
format_errors(value, location)
else:
for message in value:
print(f'[ERROR] {".".join(location)}: {message}')
2021-01-14 02:11:04 +02:00
context = {
'callback': log if verbose else None,
2021-01-14 02:11:04 +02:00
'import': True,
}
error = False
try:
2021-01-14 02:11:04 +02:00
config = MailuSchema(context=context).loads(source)
except ValidationError as exc:
error = True
format_errors(exc.messages)
else:
2021-01-14 02:11:04 +02:00
print(config)
print(MailuSchema().dumps(config))
# TODO: need to delete other entries
# TODO: enable commit
error = True
# don't commit when running dry or validation errors occured
if error:
print('An error occured. Not committing changes.')
db.session.rollback()
sys.exit(2)
elif dry_run:
2021-01-14 02:11:04 +02:00
print('Dry run. Not commiting changes.')
db.session.rollback()
else:
db.session.commit()
@mailu.command()
2021-01-14 02:11:04 +02:00
@click.option('-f', '--full', is_flag=True, help='Include attributes with default value')
@click.option('-s', '--secrets', is_flag=True,
help='Include secret attributes (dkim-key, passwords)')
@click.option('-d', '--dns', is_flag=True, help='Include dns records')
2021-01-14 02:11:04 +02:00
@click.option('-o', '--output-file', 'output', default=sys.stdout, type=click.File(mode='w'),
help='save yaml to file')
2020-10-24 22:31:31 +02:00
@click.argument('sections', nargs=-1)
@with_appcontext
def config_export(full=False, secrets=False, dns=False, output=None, sections=None):
""" Export configuration as YAML to stdout or file
2020-10-24 22:31:31 +02:00
"""
2021-01-14 02:11:04 +02:00
if sections:
for section in sections:
if section not in SECTIONS:
print(f'[ERROR] Unknown section: {section!r}')
sys.exit(1)
sections = set(sections)
else:
sections = SECTIONS
2021-01-13 01:05:43 +02:00
2021-01-14 02:11:04 +02:00
context={
2021-01-13 01:05:43 +02:00
'full': full,
'secrets': secrets,
'dns': dns,
2021-01-14 02:11:04 +02:00
}
MailuSchema(only=sections, context=context).dumps(models.MailuConfig(), output)
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('email')
@with_appcontext
def user_delete(email):
"""delete user"""
user = models.User.query.get(email)
if user:
db.session.delete(user)
db.session.commit()
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('email')
@with_appcontext
def alias_delete(email):
"""delete alias"""
alias = models.Alias.query.get(email)
if alias:
db.session.delete(alias)
db.session.commit()
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('localpart')
@click.argument('domain_name')
@click.argument('destination')
2019-01-24 22:32:22 +02:00
@click.option('-w', '--wildcard', is_flag=True)
@with_appcontext
2019-01-24 22:32:22 +02:00
def alias(localpart, domain_name, destination, wildcard=False):
""" Create an alias
"""
domain = models.Domain.query.get(domain_name)
if not domain:
domain = models.Domain(name=domain_name)
db.session.add(domain)
alias = models.Alias(
localpart=localpart,
domain=domain,
2019-01-24 22:32:22 +02:00
wildcard=wildcard,
destination=destination.split(','),
email=f'{localpart}@{domain_name}'
)
db.session.add(alias)
db.session.commit()
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('domain_name')
@click.argument('max_users')
@click.argument('max_aliases')
@click.argument('max_quota_bytes')
@with_appcontext
def setlimits(domain_name, max_users, max_aliases, max_quota_bytes):
2018-10-18 16:20:56 +02:00
""" Set domain limits
"""
domain = models.Domain.query.get(domain_name)
domain.max_users = max_users
domain.max_aliases = max_aliases
domain.max_quota_bytes = max_quota_bytes
db.session.add(domain)
db.session.commit()
2018-11-08 22:29:30 +02:00
@mailu.command()
2018-10-18 17:55:07 +02:00
@click.argument('domain_name')
@click.argument('user_name')
@with_appcontext
def setmanager(domain_name, user_name='manager'):
2018-10-18 16:20:56 +02:00
""" Make a user manager of a domain
"""
domain = models.Domain.query.get(domain_name)
manageruser = models.User.query.get(f'{user_name}@{domain_name}')
domain.managers.append(manageruser)
db.session.add(domain)
db.session.commit()