Developer Interface

def cli():
    """Main cli entry point."""
    try:
        run()

    except SpoolError as ex:
        logging.critical(ex)
        sys.exit(1)

    except Exception:
        logging.critical('Unexpected error occured.', exc_info=True)
        sys.exit(1)

def parse_args(args):
    """Parse command line arguments."""

    parser = argparse.ArgumentParser(description='Send mails with YAML.')

    parser.add_argument(
        '-r', '--relay',
        help='smtp relay smtp server',
    )

    parser.add_argument(
        '-p', '--port',
        type=int, default=25,
        help='port on remote server, default: 25',
    )

    parser.add_argument(
        '-n', '--nameservers',
        help='nameservers for lookup of MX records'
    )

    parser.add_argument(
        '-d', '--delay',
        type=float,
        help='delay delivery by a given number of seconds after each mail'
    )

    parser.add_argument(
        '-D', '--debug',
        action='store_true',
        help='enable debugging on smtp conversation',
    )

    parser.add_argument(
        '-P', '--print-only',
        action='store_true',
        help='print, but do not send messages',
    )

    parser.add_argument(
        '-H', '--helo',
        help='helo name used when connecting to the smtp server',
    )

    parser.add_argument(
        '-c', '--check',
        action='store_true',
        help='check config files and quit',
    )

    parser.add_argument(
        '-t', '--tags',
        help='tags to execute',
    )

    parser.add_argument(
        '--starttls',
        action='store_true',
        help=''
    )

    parser.add_argument(
        'path',
        nargs='+', metavar='config', type=Path,
        help='path of spool config',
    )

    output_group = parser.add_mutually_exclusive_group()

    output_group.add_argument(
        '-v', '--verbose',
        action='count', default=0, dest='verbosity',
        help='verbose output (repeat for increased verbosity)',
    )

    output_group.add_argument(
        '-s', '--silent',
        action='store_const', const=-1, default=0, dest='verbosity',
        help='quiet output (show errors only)',
    )

    return parser.parse_args(args)

def run():
    """Main method."""

    args = parse_args(sys.argv[1:])
    config_logger(args.verbosity)

    first = True

    for path in args.path:

        if not path.is_file():
            LOG.warning('No such file, skipping. [path=%s]', path)
            continue

        try:
            config = Config.load(path)

            if args.check:
                continue

        except ConfigError as ex:
            LOG.error('Error while parsing config: %s [path=%s]', ex, path)
            continue

        with Mailer(relay=args.relay, port=args.port, helo=args.helo,
                    debug=args.debug, nameservers=args.nameservers,
                    starttls=args.starttls) as mailer:

            for mail in config.mails:

                if not tags_matches_mail(args.tags, mail.pop('tags', [])):
                    LOG.debug('Skipping message "%s", does not match tags: %s',
                              mail['name'], args.tags)
                    continue

                if not first and args.delay:
                    LOG.debug('Delay sending of next message by %.2f seconds.',
                              args.delay)
                    time.sleep(args.delay)
                else:
                    first = False

                mail.pop('description', None)
                mail = parse_files(path, mail)
                attachments = mail.pop('attachments', [])

                msg = Message(**mail)

                if isinstance(attachments, str):
                    attachments = [attachments]

                for attachment in attachments:
                    file_path = path.parent / attachment
                    msg.attach(file_path)

                try:
                    mailer.send(msg, args.print_only)

                except MessageError as ex:
                    LOG.error(
                        'Failed to create message: %s. [name=%s, path=%s]',
                        ex, mail['name'], path
                    )

def tags_matches_mail(tags, mail):
    """Returns True if mail has a matching tag."""

    if not tags:
        return True

    tags = [tag.strip() for tag in tags.split(',')]

    return any(tag in mail for tag in tags)

def parse_addrs(addrs):
    """Parses a comma separated string to list of email addresses.

    Wrapper arround pythons `email.utils.parseaddr` function to parse a
    comma separated list of email addresses.

    Args:
        addrs: Comma separated string or list of email addresses to parse

    Returns:
        list: A list of tuples consiting of *realname* and *email address*
            parts

    Examples:
        >>> parse_addrs('john doe <john@example.com>, jane.doe@example.com')
        [('john doe', 'john@example.com'), ('', 'jane.doe@example.com')]
        >>> parse_addrs(', john doe <john.doe@example.com>')
        [('john doe', 'john.doe@example.com')]
    """

    if isinstance(addrs, str):
        addrs = addrs.split(',')

    if isinstance(addrs, list):
        return [parseaddr(item) for item in addrs if item]

    return [parseaddr(addrs)]

def to_list(string):
    """Returns a list of values from a comma separated string"""

    if isinstance(string, list):
        return string

    return [item.strip() for item in string.split(',')]

def encode_cms(mime_part):
    """Encodes a cms structure"""

    mime_part['Content-Transfer-Encoding'] = 'base64'

    if mime_part.get_payload() is None:
        return mime_part

    cms = mime_part.get_payload().pem()

    match = PEM_RE.search(cms)
    if not match:
        raise ValueError('Failed to retrive cms')

    mime_part.set_payload(match.group(2))

    return mime_part

def encrypt(message, certs, algorithm='des3'):
    """Encrypt a given message."""

    certs, cipher = parse_pem(certs), CipherType(algorithm)

    cms = EnvelopedData.create(certs, message.as_bytes(), cipher, flags=0)

    encrypted = MIMEApplication(cms, 'pkcs7-mime', encode_cms,
                                smime_type='enveloped-data', name='smime.p7m')

    return encrypted

def parse_pem(certstack):
    """Extract PEM strings from *certstack*."""

    certs = [
        X509(match.group(0)) for match
        in PEM_RE.finditer(certstack)
    ]

    return certs

def sign(message, key, cert, detached=True):
    """Sign a a given message."""

    # FIXME
    if not detached:
        raise NotImplementedError()

    signed = MIMEMultipart(
        'signed', micalg='sha-256', protocol='application/pkcs7-signature')
    signed.preamble = SIGNED_PREAMBLE

    signed.attach(message)

    cann = message.as_bytes().replace(b'\n', b'\r\n')

    key, certstack = PKey(privkey=key.encode()), parse_pem(cert)

    flags = Flags.DETACHED+Flags.BINARY

    cms = SignedData.create(cann, certstack[-1], key, flags=flags,
                            certs=certstack[0:-1])

    signature = MIMEApplication(
        cms, 'pkcs7-signature', encode_cms, name='smime.p7s')
    signature.add_header(
        'Content-Disposition', 'attachment', filename='smime.p7s')

    signed.attach(signature)

    return signed