start = subparsers.add_parser('start', help="Start service")

        start.set_defaults(subcommand='start')

        stop = subparsers.add_parser('stop', help="Stop service")

        stop.set_defaults(subcommand='stop')

            parser.add_argument('-p', '--pidfile',

                                help="Path to PID file.", metavar='PATH')

            parser.add_argument('--daemonize', action='store_true', default=True, # TODO: should default to False

                                help="Daemonize when starting.")

            parser.add_argument('--no-daemonize',

                                '-D', '--do-not-daemonize', # TODO: (re)move these?

            remove.set_defaults(subcommand='remove')

            uninstall = subparsers.add_parser('uninstall', help="Uninstall (remove) service")

            uninstall.set_defaults(subcommand='remove')

    def run(self, args):

            from rattail.filemon import linux as filemon

            if args.subcommand == 'start':

                filemon.start_daemon(self.config, args.pidfile, args.daemonize)

            elif args.subcommand == 'stop':

from __future__ import unicode_literals, absolute_import

import os

import sys

import time

import socket

import logging

from traceback import format_exception

from rattail.mail import send_email

        # Suspend execution briefly, to avoid consuming so much CPU...

        time.sleep(0.01)

        try:

            path = profile.queue.get_nowait()

            pass

        except StopProcessing:

            stop = True

        else:

            log.debug(u"queue contained a file: {0}".format(repr(path)))

            action.spec = class_

            action.action = load_object(action.spec)(self.config)

        action.args = self._config_list(u'action.{0}.args'.format(name))

        action.kwargs = {}

        for option in self.config.options(u'rattail.filemon'):

            match = pattern.match(option)

            if match:

                action.kwargs[match.group(u'keyword')] = self.config.get(u'rattail.filemon', option)

        action.retry_attempts = self._config_int(u'action.{0}.retry_attempts'.format(name), minimum=1)

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

#  Rattail is free software: you can redistribute it and/or modify it under the

#  terms of the GNU General Public License as published by the Free Software

#  Foundation, either version 3 of the License, or (at your option) any later

#

################################################################################

"""

File Monitor for Linux

"""

import logging

import pyinotify

from rattail.daemon import Daemon

from rattail.threads import Thread

                | pyinotify.IN_MOVED_TO)

        monitored = load_profiles(self.config)

        for key, profile in monitored.items():

            # Create a file queue for the profile.

            # Perform setup for each of the watched folders.

            for path in profile.dirs:

                # Maybe put all pre-existing files in the queue.

                if profile.process_existing:

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

#  Rattail is free software: you can redistribute it and/or modify it under the

#  terms of the GNU General Public License as published by the Free Software

#  Foundation, either version 3 of the License, or (at your option) any later

#

################################################################################

"""

File Monitor for Windows

"""

import os

import time

import datetime

import logging

from rattail.win32.service import Service

from rattail.threads import Thread

from rattail.filemon.config import load_profiles

from rattail.filemon.actions import perform_actions

            return False

        # Create monitor and action threads for each profile.

        for key, profile in self.monitored.items():

            # Create a file queue for the profile.

            # Perform setup for each of the watched folders.

            for i, path in enumerate(profile.dirs, 1):

                # Maybe put all pre-existing files in the queue.

                if profile.process_existing:

        if path is None:

            path = self.temp_path(suffix='.sil')

        self.sil_path = path

        self.fileobj = self.get_fileobj()

    def get_fileobj(self):

    def close(self):

        self.fileobj.close()

    @classmethod

    def temp_path(cls, **kwargs):

import os

import time

from unittest import TestCase

from mock import Mock, patch, call

from fixture import TempIO

from rattail.config import make_config, RattailConfig

    def get_profile(self, stop_on_error=False):

        profile = Profile(self.config, u'foo')

        profile.stop_on_error = stop_on_error

        profile.queue = Mock()

        profile.queue.get_nowait.side_effect = [

            self.tmp.putfile(u'file1', u''),

            self.tmp.putfile(u'file2', u''),

            self.tmp.putfile(u'file3', u''),

            actions.StopProcessing,

            ]

        return profile

from unittest import TestCase

from mock import Mock

from fixture import TempIO

from rattail.config import make_config

        self.config = make_config([])

        self.config.set(u'rattail.filemon', u'monitor', u'foo')

        self.config.set(u'rattail.filemon', u'foo.dirs', self.tmp)

        self.config.set(u'rattail.filemon', u'foo.actions', u'noop')

        self.config.set(u'rattail.filemon', u'foo.action.noop.func', u'rattail.filemon.actions:noop')

        self.profile = Profile(self.config, u'foo')

        self.handler = linux.EventHandler()

        self.handler.my_init(self.profile)

    def test_in_access_event_does_nothing(self):

        event = Mock(pathname=self.tmp.putfile(u'file', u''))

        self.handler.process_IN_ACCESS(event)

from unittest import TestCase

from fixture import TempIO

from rattail.config import make_config

from rattail.filemon import util

        self.config = make_config([])

        self.config.set(u'rattail.filemon', u'monitor', u'foo')

        self.config.set(u'rattail.filemon', u'foo.dirs', self.tmp)

        self.config.set(u'rattail.filemon', u'foo.actions', u'noop')

        self.config.set(u'rattail.filemon', u'foo.action.noop.func', u'rattail.filemon.actions:noop')

        self.profile = Profile(self.config, u'foo')

    def test_nothing_queued_if_no_files_exist(self):

        util.queue_existing(self.profile, self.tmp)

        self.assertTrue(self.profile.queue.empty())

    def test_normal_files_are_queued_but_not_folders(self):

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

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

#  Rattail is free software: you can redistribute it and/or modify it under the

#  terms of the GNU General Public License as published by the Free Software

#  Foundation, either version 3 of the License, or (at your option) any later

        Convert a value to a decimal, unless it's ``None``.

        """

        if value is None:

            return None

        # No reason to convert integers, really.

            return value

        if isinstance(value, float):

            value = "{{0:0.{0}f}}".format(scale).format(value)

        else:

            value = value.strip()

        return Decimal(value)