# -*- coding: utf-8 -*-
'''
The core behaviors used by minion and master
'''
# pylint: disable=W0232
# pylint: disable=3rd-party-module-not-gated

# Import python libs
from __future__ import absolute_import, print_function, unicode_literals
import os
import time
import random
import logging
import itertools
from collections import deque
from _socket import gaierror

# Import salt libs
import salt.daemons.masterapi
import salt.utils.args
import salt.utils.kinds as kinds
import salt.utils.process
import salt.utils.stringutils
import salt.transport
import salt.engines

# pylint: disable=import-error
from raet import raeting
from raet.road.stacking import RoadStack
from raet.road.estating import RemoteEstate
from raet.lane.stacking import LaneStack
# pylint: enable=import-error

from salt import daemons
from salt.daemons import salting
from salt.exceptions import SaltException
from salt.utils.platform import is_windows
from salt.utils.event import tagify

# Import ioflo libs
# pylint: disable=import-error
from ioflo.aid.odicting import odict  # pylint: disable=E0611,F0401
import ioflo.base.deeding
from ioflo.base.consoling import getConsole
# pylint: enable=import-error
console = getConsole()

# Import Third Party Libs
# pylint: disable=import-error
HAS_PSUTIL = False
try:
    import salt.utils.psutil_compat as psutil
    HAS_PSUTIL = True
except ImportError:
    pass

HAS_RESOURCE = False
try:
    import resource
    HAS_RESOURCE = True
except ImportError:
    pass
# pylint: disable=no-name-in-module,redefined-builtin
from salt.ext import six
from salt.ext.six.moves import range
# pylint: enable=import-error,no-name-in-module,redefined-builtin

log = logging.getLogger(__name__)


class SaltRaetCleanup(ioflo.base.deeding.Deed):
    '''
    Cleanup stray lane keep directories not reaped

    FloScript:

    do salt raet cleanup at enter

    '''
    Ioinits = {
                'opts': salt.utils.stringutils.to_str('.salt.opts'),
            }

    def action(self):
        '''
        Should only run once to cleanup stale lane uxd files.
        '''
        if not is_windows() and self.opts.value.get('sock_dir'):
            sockdirpath = os.path.abspath(self.opts.value['sock_dir'])
            console.concise("Cleaning up uxd files in {0}\n".format(sockdirpath))
            protecteds = self.opts.value.get('raet_cleanup_protecteds', [])
            for name in os.listdir(sockdirpath):
                path = os.path.join(sockdirpath, name)
                if os.path.isdir(path):
                    continue
                root, ext = os.path.splitext(name)
                if ext != '.uxd':
                    continue
                if not all(root.partition('.')):
                    continue
                if path in protecteds:
                    continue
                try:
                    os.unlink(path)
                    console.concise("Removed {0}\n".format(path))
                except OSError:
                    console.concise("Failed removing {0}\n".format(path))
                    raise


class SaltRaetRoadClustered(ioflo.base.deeding.Deed):
    '''
    Updates value of share .salt.road.manor.cluster.clustered
    Twith opts['cluster_mode']

    FloScript:

    do salt raet road clustered
    go next if .salt.road.manor.cluster.clustered

    '''
    Ioinits = odict(inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
                    clustered=odict(ipath=salt.utils.stringutils.to_str('cluster.clustered'),
                                    ival=False),
                    opts=salt.utils.stringutils.to_str('.salt.opts'),)

    def action(self, **kwa):
        '''
        Update .cluster.clustered share from opts
        '''
        self.clustered.update(value=self.opts.value.get('cluster_mode', False))


class SaltRaetProcessManagerSetup(ioflo.base.deeding.Deed):
    '''
    Set up the process manager object
    '''
    Ioinits = {'proc_mgr': salt.utils.stringutils.to_str('.salt.usr.proc_mgr')}

    def action(self):
        '''
        Create the process manager
        '''
        self.proc_mgr.value = salt.utils.process.ProcessManager()


class SaltRaetRoadUsherMinionSetup(ioflo.base.deeding.Deed):
    '''
    Set up .ushers which is initial list of masters to bootstrap
    into road

    FloScript:

    do salt raet road usher minion setup at enter

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        ushers=salt.utils.stringutils.to_str('ushers'),
        opts=salt.utils.stringutils.to_str('.salt.opts'))

    def action(self):
        '''
        Assign .ushers by parsing opts
        '''
        masters = 'master'
        port = None
        if self.opts.value.get('cluster_mode', False):
            masters = 'cluster_masters'

        self.ushers.value = daemons.extract_masters(self.opts.value,
                                                    masters=masters,
                                                    port=port)


class SaltRaetRoadUsherMasterSetup(ioflo.base.deeding.Deed):
    '''
    Set up .ushers which is initial list of masters to bootstrap
    into road

    FloScript:

    do salt raet road usher master setup at enter

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        ushers=salt.utils.stringutils.to_str('ushers'),
        opts=salt.utils.stringutils.to_str('.salt.opts'))

    def action(self):
        '''
        Assign .ushers by parsing opts
        '''
        masters = 'cluster_masters'
        port = 'raet_port'

        self.ushers.value = daemons.extract_masters(self.opts.value,
                                                    masters=masters,
                                                    port=port,
                                                    raise_if_empty=False)


class SaltRaetRoadClusterLoadSetup(ioflo.base.deeding.Deed):
    '''
    Sets up cluster.masters for load balancing

    FloScript:

    do salt raet road cluster load setup at enter

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        masters={'ipath': salt.utils.stringutils.to_str('cluster.masters'), 'ival': odict()},
        stack=salt.utils.stringutils.to_str('stack'),
        opts=salt.utils.stringutils.to_str('.salt.opts'),)

    def action(self, **kwa):
        '''
        Populate loads from masters in stack.remotes
        '''
        if self.opts.value.get('cluster_mode'):
            for remote in list(self.stack.value.remotes.values()):
                if remote.kind == kinds.applKinds.master:
                    self.masters.value[remote.name] = odict(load=0.0, expire=self.store.stamp)


class SaltRaetRoadStackSetup(ioflo.base.deeding.Deed):
    '''
    Initialize and run raet udp stack for Salt
    FloScript:

    do salt raet road stack setup at enter

    '''
    Ioinits = {
            'inode': salt.utils.stringutils.to_str('salt.road.manor.'),
            'stack': salt.utils.stringutils.to_str('stack'),
            'opts': salt.utils.stringutils.to_str('.salt.opts'),
            'txmsgs': {'ipath': salt.utils.stringutils.to_str('txmsgs'),
                       'ival': deque()},
            'rxmsgs': {'ipath': salt.utils.stringutils.to_str('rxmsgs'),
                       'ival': deque()},
            'local': {'ipath': salt.utils.stringutils.to_str('local'),
                      'ival': {'main': False,
                               'mutable': False,
                               'uid': None,
                               'role': 'master',
                               'sighex': None,
                               'prihex': None,
                               'bufcnt': 2}},
            }

    def _prepare(self):
        '''
        Assign class defaults
        '''
        RoadStack.Bk = raeting.BodyKind.msgpack.value
        RoadStack.JoinentTimeout = 0.0

    def action(self):
        '''
        enter action
        should only run once to setup road stack.
        moved from _prepare so can do clean up before stack is initialized

        do salt raet road stack setup at enter
        '''
        kind = self.opts.value['__role']  # application kind
        if kind not in kinds.APPL_KINDS:
            emsg = ("Invalid application kind = '{0}'.".format(kind))
            log.error(emsg + '\n')
            raise ValueError(emsg)
        role = self.opts.value.get('id', '')
        if not role:
            emsg = ("Missing role required to setup RoadStack.")
            log.error(emsg + "\n")
            raise ValueError(emsg)

        name = "{0}_{1}".format(role, kind)
        main = self.opts.value.get('raet_main', self.local.data.main)
        mutable = self.opts.value.get('raet_mutable', self.local.data.mutable)
        always = self.opts.value.get('open_mode', False)
        mutable = mutable or always  # open_made when True takes precedence
        uid = self.local.data.uid

        if kind == kinds.APPL_KIND_NAMES[kinds.applKinds.caller]:
            ha = (self.opts.value['interface'], self.opts.value['raet_alt_port'])
        else:
            ha = (self.opts.value['interface'], self.opts.value['raet_port'])

        basedirpath = os.path.abspath(os.path.join(self.opts.value['cachedir'], 'raet'))

        txMsgs = self.txmsgs.value
        rxMsgs = self.rxmsgs.value

        keep = salting.SaltKeep(opts=self.opts.value,
                                basedirpath=basedirpath,
                                stackname=name)

        roledata = keep.loadLocalRoleData()
        sighex = roledata['sighex'] or self.local.data.sighex
        prihex = roledata['prihex'] or self.local.data.prihex

        bufcnt = self.opts.value.get('raet_road_bufcnt', self.local.data.bufcnt)

        self.stack.value = RoadStack(store=self.store,
                                     keep=keep,
                                     name=name,
                                     uid=uid,
                                     ha=ha,
                                     role=role,
                                     sigkey=sighex,
                                     prikey=prihex,
                                     main=main,
                                     kind=kinds.APPL_KINDS[kind],
                                     mutable=mutable,
                                     txMsgs=txMsgs,
                                     rxMsgs=rxMsgs,
                                     period=3.0,
                                     offset=0.5,
                                     bufcnt=bufcnt)

        if self.opts.value.get('raet_clear_remotes'):
            for remote in list(self.stack.value.remotes.values()):
                self.stack.value.removeRemote(remote, clear=True)
            self.stack.puid = self.stack.value.Uid  # reset puid


class SaltRaetRoadStackCloser(ioflo.base.deeding.Deed):
    '''
    Closes stack server socket connection
    FloScript:

    do salt raet road stack closer at exit

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        stack=salt.utils.stringutils.to_str('stack'), )

    def action(self, **kwa):
        '''
        Close udp socket
        '''
        if self.stack.value and isinstance(self.stack.value, RoadStack):
            self.stack.value.server.close()


class SaltRaetRoadStackJoiner(ioflo.base.deeding.Deed):
    '''
    Initiates join transaction with master(s)
    FloScript:

    do salt raet road stack joiner at enter

    assumes that prior the following has been run to setup .masters

    do salt raet road usher minion setup

    '''
    Ioinits = odict(
                    inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
                    stack=salt.utils.stringutils.to_str('stack'),
                    ushers=salt.utils.stringutils.to_str('ushers'),
                    opts=salt.utils.stringutils.to_str('.salt.opts'))

    def action(self, **kwa):
        '''
        Join with all masters
        '''
        stack = self.stack.value
        if stack and isinstance(stack, RoadStack):
            refresh_masters = (self.opts.value.get('raet_clear_remote_masters',
                                       True) or not stack.remotes)

            refresh_all = (self.opts.value.get('raet_clear_remotes', True) or
                       not stack.remotes)

            if refresh_masters:  # clear all remote masters
                for remote in list(stack.remotes.values()):
                    if remote.kind == kinds.applKinds.master:
                        stack.removeRemote(remote, clear=True)

            if refresh_all:  # clear all remotes
                for remote in list(stack.remotes.values()):
                    stack.removeRemote(remote, clear=True)

            if refresh_all or refresh_masters:
                stack.puid = stack.Uid  # reset puid so reuse same uid each time

                ex = SaltException('Unable to connect to any master')
                for master in self.ushers.value:
                    try:
                        mha = master['external']
                        stack.addRemote(RemoteEstate(stack=stack,
                                                     fuid=0,  # vacuous join
                                                     sid=0,  # always 0 for join
                                                     ha=mha,
                                                     kind=kinds.applKinds.master))
                    except gaierror as ex:
                        log.warning("Unable to connect to master %s: %s", mha, ex)
                        if self.opts.value.get('master_type') not in ('failover', 'distributed'):
                            raise ex
                if not stack.remotes:
                    raise ex

            for remote in list(stack.remotes.values()):
                if remote.kind == kinds.applKinds.master:
                    stack.join(uid=remote.uid, timeout=0.0)


class SaltRaetRoadStackJoined(ioflo.base.deeding.Deed):
    '''
    Updates status with .joined of zeroth remote estate (master)
    FloScript:

    do salt raet road stack joined
    go next if joined in .salt.road.manor.status

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        stack=salt.utils.stringutils.to_str('stack'),
        status=odict(ipath=salt.utils.stringutils.to_str('status'),
                     ival=odict(joined=False,
                                allowed=False,
                                alived=False,
                                rejected=False,
                                idle=False, )))

    def action(self, **kwa):
        '''
        Update .status share
        '''
        stack = self.stack.value
        joined = False
        if stack and isinstance(stack, RoadStack):
            if stack.remotes:
                joined = any([remote.joined for remote in list(stack.remotes.values())
                              if remote.kind == kinds.applKinds.master])
        self.status.update(joined=joined)


class SaltRaetRoadStackRejected(ioflo.base.deeding.Deed):
    '''
    Updates status with rejected of .acceptance of zeroth remote estate (master)
    FloScript:

    do salt raet road stack rejected
    go next if rejected in .salt.road.manor.status

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        stack=salt.utils.stringutils.to_str('stack'),
        status=odict(ipath=salt.utils.stringutils.to_str('status'),
                     ival=odict(joined=False,
                                allowed=False,
                                alived=False,
                                rejected=False,
                                idle=False, )))

    def action(self, **kwa):
        '''
        Update .status share
        '''
        stack = self.stack.value
        rejected = False
        if stack and isinstance(stack, RoadStack):
            if stack.remotes:
                rejected = all([remote.acceptance == raeting.Acceptance.rejected.value
                                for remote in stack.remotes.values()
                                if remote.kind == kinds.applKinds.master])
            else:  # no remotes so assume rejected
                rejected = True
        self.status.update(rejected=rejected)


class SaltRaetRoadStackAllower(ioflo.base.deeding.Deed):
    '''
    Initiates allow (CurveCP handshake) transaction with master
    FloScript:

    do salt raet road stack allower at enter

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        stack=salt.utils.stringutils.to_str('stack'), )

    def action(self, **kwa):
        '''
        Receive any udp packets on server socket and put in rxes
        Send any packets in txes
        '''
        stack = self.stack.value
        if stack and isinstance(stack, RoadStack):
            for remote in stack.remotes.values():
                if remote.kind == kinds.applKinds.master:
                    stack.allow(uid=remote.uid, timeout=0.0)


class SaltRaetRoadStackAllowed(ioflo.base.deeding.Deed):
    '''
    Updates status with .allowed of zeroth remote estate (master)
    FloScript:

    do salt raet road stack allowed
    go next if allowed in .salt.road.manor.status

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        stack=salt.utils.stringutils.to_str('stack'),
        status=odict(ipath=salt.utils.stringutils.to_str('status'),
                     ival=odict(joined=False,
                                allowed=False,
                                alived=False,
                                rejected=False,
                                idle=False, )))

    def action(self, **kwa):
        '''
        Update .status share
        '''
        stack = self.stack.value
        allowed = False
        if stack and isinstance(stack, RoadStack):
            if stack.remotes:
                allowed = any([remote.allowed for remote in list(stack.remotes.values())
                               if remote.kind == kinds.applKinds.master])
        self.status.update(allowed=allowed)


class SaltRaetRoadStackManager(ioflo.base.deeding.Deed):
    '''
    Runs the manage method of RoadStack
    FloScript:
        do salt raet road stack manager

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        stack=salt.utils.stringutils.to_str('stack'),
        alloweds={'ipath': salt.utils.stringutils.to_str('.salt.var.presence.alloweds'),
                  'ival': odict()},
        aliveds={'ipath': salt.utils.stringutils.to_str('.salt.var.presence.aliveds'),
                 'ival': odict()},
        reapeds={'ipath': salt.utils.stringutils.to_str('.salt.var.presence.reapeds'),
                         'ival': odict()},
        availables={'ipath': salt.utils.stringutils.to_str('.salt.var.presence.availables'),
                    'ival': set()},
        changeds={'ipath': salt.utils.stringutils.to_str('.salt.var.presence.changeds'),
                  'ival': odict(plus=set(), minus=set())},
        event=salt.utils.stringutils.to_str('.salt.event.events'),)

    def _fire_events(self):
        stack = self.stack.value
        if self.changeds.data.plus or self.changeds.data.minus:
            # fire presence change event
            data = {'new': list(self.changeds.data.plus),
                    'lost': list(self.changeds.data.minus)}
            tag = tagify('change', 'presence')
            route = {'dst': (None, None, 'event_fire'),
                     'src': (None, stack.local.name, None)}
            msg = {'route': route, 'tag': tag, 'data': data}
            self.event.value.append(msg)
        # fire presence present event
        data = {'present': list(self.aliveds.value)}
        tag = tagify('present', 'presence')
        route = {'dst': (None, None, 'event_fire'),
                 'src': (None, stack.local.name, None)}
        msg = {'route': route, 'tag': tag, 'data': data}
        self.event.value.append(msg)

    def action(self, **kwa):
        '''
        Manage the presence of any remotes

        availables is set of names of alive remotes which are also allowed
        changeds is is share with two fields:
            plus is set of names of newly available remotes
            minus is set of names of newly unavailable remotes
        alloweds is dict of allowed remotes keyed by name
        aliveds is dict of alived remotes keyed by name
        reapeds is dict of reaped remotes keyed by name
        '''
        stack = self.stack.value
        if stack and isinstance(stack, RoadStack):
            stack.manage(cascade=True)
            # make copies
            self.availables.value = set(self.stack.value.availables)
            self.changeds.update(plus=set(self.stack.value.changeds['plus']))
            self.changeds.update(minus=set(self.stack.value.changeds['minus']))
            self.alloweds.value = odict(self.stack.value.alloweds)
            self.aliveds.value = odict(self.stack.value.aliveds)
            self.reapeds.value = odict(self.stack.value.reapeds)

            console.concise(" Manage {0}.\nAvailables: {1}\nChangeds:\nPlus: {2}\n"
                            "Minus: {3}\nAlloweds: {4}\nAliveds: {5}\nReapeds: {6}\n".format(
                    stack.name,
                    self.availables.value,
                    self.changeds.data.plus,
                    self.changeds.data.minus,
                    self.alloweds.value,
                    self.aliveds.value,
                    self.reapeds.value))

            self._fire_events()


class SaltRaetRoadStackPrinter(ioflo.base.deeding.Deed):
    '''
    Prints out messages on rxMsgs queue for associated stack
    FloScript:

    do raet road stack printer

    '''
    Ioinits = odict(
        inode=salt.utils.stringutils.to_str('.salt.road.manor.'),
        rxmsgs=odict(ipath=salt.utils.stringutils.to_str('rxmsgs'), ival=deque()),)

    def action(self, **kwa):
        '''
        Queue up message
        '''
        rxMsgs = self.rxmsgs.value
        while rxMsgs:
            msg, name = rxMsgs.popleft()
            console.terse("\nReceived....\n{0}\n".format(msg))


class SaltLoadModules(ioflo.base.deeding.Deed):
    '''
    Reload the minion modules
    FloScript:

    do salt load modules at enter

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'grains': salt.utils.stringutils.to_str('.salt.grains'),
               'utils': salt.utils.stringutils.to_str('.salt.loader.utils'),
               'modules': salt.utils.stringutils.to_str('.salt.loader.modules'),
               'grain_time': salt.utils.stringutils.to_str('.salt.var.grain_time'),
               'module_refresh': salt.utils.stringutils.to_str('.salt.var.module_refresh'),
               'returners': salt.utils.stringutils.to_str('.salt.loader.returners'),
               'module_executors': salt.utils.stringutils.to_str('.salt.loader.executors')}

    def _prepare(self):
        self._load_modules()

    def action(self):
        self._load_modules()

    def _load_modules(self):
        '''
        Return the functions and the returners loaded up from the loader
        module
        '''
        if self.grain_time.value is None:
            self.grain_time.value = 0.0
        # if this is a *nix system AND modules_max_memory is set, lets enforce
        # a memory limit on module imports
        # this feature ONLY works on *nix like OSs (resource module doesn't work on windows)
        modules_max_memory = False
        if self.opts.value.get('modules_max_memory', -1) > 0 and HAS_PSUTIL and HAS_RESOURCE:
            log.debug('modules_max_memory set, enforcing a maximum of %s',
                      self.opts.value['modules_max_memory'])
            modules_max_memory = True
            old_mem_limit = resource.getrlimit(resource.RLIMIT_AS)
            rss, vms = psutil.Process(os.getpid()).memory_info()[:2]
            mem_limit = rss + vms + self.opts.value['modules_max_memory']
            resource.setrlimit(resource.RLIMIT_AS, (mem_limit, mem_limit))
        elif self.opts.value.get('modules_max_memory', -1) > 0:
            if not HAS_PSUTIL:
                log.error('Unable to enforce modules_max_memory because psutil is missing')
            if not HAS_RESOURCE:
                log.error('Unable to enforce modules_max_memory because resource is missing')

        if time.time() - self.grain_time.value > 300.0 or self.module_refresh.value:
            self.opts.value['grains'] = salt.loader.grains(self.opts.value)
            self.grain_time.value = time.time()
            self.grains.value = self.opts.value['grains']
        self.utils.value = salt.loader.utils(self.opts.value)
        self.modules.value = salt.loader.minion_mods(self.opts.value, utils=self.utils.value)
        self.returners.value = salt.loader.returners(self.opts.value, self.modules.value)
        self.module_executors.value = salt.loader.executors(self.opts.value, self.modules.value)

        self.utils.value.clear()
        self.modules.value.clear()
        self.returners.value.clear()
        self.module_executors.value.clear()

        # we're done, reset the limits!
        if modules_max_memory is True:
            resource.setrlimit(resource.RLIMIT_AS, old_mem_limit)
        self.module_refresh.value = False


class SaltLoadPillar(ioflo.base.deeding.Deed):
    '''
    Load up the initial pillar for the minion

    do salt load pillar
    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'pillar': salt.utils.stringutils.to_str('.salt.pillar'),
               'grains': salt.utils.stringutils.to_str('.salt.grains'),
               'modules': salt.utils.stringutils.to_str('.salt.loader.modules'),
               'pillar_refresh': salt.utils.stringutils.to_str('.salt.var.pillar_refresh'),
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               'master_estate_name': salt.utils.stringutils.to_str('.salt.track.master_estate_name')
               }

    def action(self):
        '''
        Initial pillar
        '''
        # default master is the first remote that is allowed
        available_masters = [remote for remote in list(self.road_stack.value.remotes.values())
                                               if remote.allowed]
        while not available_masters:
            available_masters = [remote for remote in self.road_stack.value.remotes.values()
                                                           if remote.allowed]
            time.sleep(0.1)

        random_master = self.opts.value.get('random_master')
        if random_master:
            master = available_masters[random.randint(0, len(available_masters) - 1)]
        else:
            master = available_masters[0]

        self.master_estate_name.value = master.name

        route = {'src': (self.road_stack.value.local.name, None, None),
                 'dst': (master.name, None, 'remote_cmd')}
        load = {'id': self.opts.value['id'],
                'grains': self.grains.value,
                'saltenv': self.opts.value['saltenv'],
                'ver': '2',
                'cmd': '_pillar'}
        self.road_stack.value.transmit({'route': route, 'load': load},
                                       uid=master.uid)
        self.road_stack.value.serviceAll()
        while True:
            time.sleep(0.1)
            while self.road_stack.value.rxMsgs:
                msg, sender = self.road_stack.value.rxMsgs.popleft()
                self.pillar.value = msg.get('return', {})
                if self.pillar.value is None:
                    continue
                self.opts.value['pillar'] = self.pillar.value
                self.pillar_refresh.value = False
                return
            self.road_stack.value.serviceAll()


class SaltSchedule(ioflo.base.deeding.Deed):
    '''
    Evaluates the schedule
    FloScript:

    do salt schedule

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'grains': salt.utils.stringutils.to_str('.salt.grains'),
               'utils': salt.utils.stringutils.to_str('.salt.loader.utils'),
               'modules': salt.utils.stringutils.to_str('.salt.loader.modules'),
               'returners': salt.utils.stringutils.to_str('.salt.loader.returners')}

    def _prepare(self):
        '''
        Map opts and make the schedule object
        '''
        self.utils.value = salt.loader.utils(self.opts.value)
        self.modules.value = salt.loader.minion_mods(self.opts.value, utils=self.utils.value)
        self.returners.value = salt.loader.returners(self.opts.value, self.modules.value)
        self.schedule = salt.utils.schedule.Schedule(
                self.opts.value,
                self.modules.value,
                self.returners.value)

    def action(self):
        '''
        Eval the schedule
        '''
        self.schedule.eval()


class SaltRaetManorLaneSetup(ioflo.base.deeding.Deed):
    '''
    Only intended to be called once at the top of the manor house
    Sets up the LaneStack for the main yard
    FloScript:

    do salt raet manor lane setup at enter

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'event_yards': salt.utils.stringutils.to_str('.salt.event.yards'),
               'local_cmd': salt.utils.stringutils.to_str('.salt.var.local_cmd'),
               'remote_cmd': salt.utils.stringutils.to_str('.salt.var.remote_cmd'),
               'publish': salt.utils.stringutils.to_str('.salt.var.publish'),
               'fun': salt.utils.stringutils.to_str('.salt.var.fun'),
               'worker_verify': salt.utils.stringutils.to_str('.salt.var.worker_verify'),
               'event': salt.utils.stringutils.to_str('.salt.event.events'),
               'event_req': salt.utils.stringutils.to_str('.salt.event.event_req'),
               'presence_req': salt.utils.stringutils.to_str('.salt.presence.event_req'),
               'stats_req': salt.utils.stringutils.to_str('.salt.stats.event_req'),
               'workers': salt.utils.stringutils.to_str('.salt.track.workers'),
               'inode': salt.utils.stringutils.to_str('.salt.lane.manor.'),
               'stack': salt.utils.stringutils.to_str('stack'),
               'local': {'ipath': salt.utils.stringutils.to_str('local'),
                          'ival': {'lanename': 'master',
                                   'bufcnt': 100}},
            }

    def _prepare(self):
        '''
        Set up required objects and queues
        '''
        pass

    def action(self):
        '''
        Run once at enter
        '''
        kind = self.opts.value['__role']
        if kind not in kinds.APPL_KINDS:
            emsg = ("Invalid application kind = '{0}' for manor lane.".format(kind))
            log.error(emsg + "\n")
            raise ValueError(emsg)

        if kind in [kinds.APPL_KIND_NAMES[kinds.applKinds.master],
                    kinds.APPL_KIND_NAMES[kinds.applKinds.syndic]]:
            lanename = 'master'
        elif kind in [kinds.APPL_KIND_NAMES[kinds.applKinds.minion],
                      kinds.APPL_KIND_NAMES[kinds.applKinds.caller], ]:
            role = self.opts.value.get('id', '')
            if not role:
                emsg = ("Missing role required to setup manor Lane.")
                log.error(emsg + "\n")
                raise ValueError(emsg)
            lanename = "{0}_{1}".format(role, kind)
        else:
            emsg = ("Unsupported application kind = '{0}' for manor Lane.".format(kind))
            log.error(emsg + '\n')
            raise ValueError(emsg)

        bufcnt = self.opts.value.get('raet_lane_bufcnt', self.local.data.bufcnt)

        name = 'manor'
        self.stack.value = LaneStack(
                                    name=name,
                                    lanename=lanename,
                                    sockdirpath=self.opts.value['sock_dir'],
                                    bufcnt=bufcnt)
        self.stack.value.Pk = raeting.PackKind.pack.value
        self.event_yards.value = set()
        self.local_cmd.value = deque()
        self.remote_cmd.value = deque()
        self.fun.value = deque()
        self.event.value = deque()
        self.event_req.value = deque()
        self.presence_req.value = deque()
        self.stats_req.value = deque()
        self.publish.value = deque()
        self.worker_verify.value = salt.utils.stringutils.random()
        if self.opts.value.get('worker_threads'):
            worker_seed = []
            for index in range(self.opts.value['worker_threads']):
                worker_seed.append('worker{0}'.format(index + 1))
            self.workers.value = itertools.cycle(worker_seed)


class SaltRaetLaneStackCloser(ioflo.base.deeding.Deed):  # pylint: disable=W0232
    '''
    Closes lane stack server socket connection
    FloScript:

    do raet lane stack closer at exit

    '''
    Ioinits = odict(
        inode='.salt.lane.manor',
        stack='stack',)

    def action(self, **kwa):
        '''
        Close uxd socket
        '''
        if self.stack.value and isinstance(self.stack.value, LaneStack):
            self.stack.value.server.close()


class SaltRaetRoadStackService(ioflo.base.deeding.Deed):
    '''
    Process the udp traffic
    FloScript:

    do rx

    '''
    Ioinits = {
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               }

    def action(self):
        '''
        Process inboud queues
        '''
        self.road_stack.value.serviceAll()


class SaltRaetRoadStackServiceRx(ioflo.base.deeding.Deed):
    '''
    Process the inbound Road traffic
    FloScript:

    do salt raet road stack service rx

    '''
    Ioinits = {
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               }

    def action(self):
        '''
        Process inboud queues
        '''
        self.road_stack.value.serviceAllRx()


class SaltRaetRoadStackServiceTx(ioflo.base.deeding.Deed):
    '''
    Process the outbound Road traffic
    FloScript:

    do salt raet road stack service tx

    '''
    # Yes, this class is identical to RX, this is because we still need to
    # separate out rx and tx in raet itself
    Ioinits = {
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               }

    def action(self):
        '''
        Process inbound queues
        '''
        self.road_stack.value.serviceAllTx()


class SaltRaetLaneStackServiceRx(ioflo.base.deeding.Deed):
    '''
    Process the inbound Lane traffic
    FloScript:

    do salt raet lane stack service rx

    '''
    Ioinits = {
               'lane_stack': salt.utils.stringutils.to_str('.salt.lane.manor.stack'),
               }

    def action(self):
        '''
        Process inboud queues
        '''
        self.lane_stack.value.serviceAllRx()


class SaltRaetLaneStackServiceTx(ioflo.base.deeding.Deed):
    '''
    Process the outbound Lane traffic
    FloScript:

    do salt raet lane stack service tx

    '''
    # Yes, this class is identical to RX, this is because we still need to
    # separate out rx and tx in raet itself
    Ioinits = {
               'lane_stack': salt.utils.stringutils.to_str('.salt.lane.manor.stack'),
               }

    def action(self):
        '''
        Process outbound queues
        '''
        self.lane_stack.value.serviceAllTx()


class SaltRaetRouter(ioflo.base.deeding.Deed):
    '''
    Routes the communication in and out of Road and Lane connections

    This is a base class

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'local_cmd': salt.utils.stringutils.to_str('.salt.var.local_cmd'),
               'remote_cmd': salt.utils.stringutils.to_str('.salt.var.remote_cmd'),
               'publish': salt.utils.stringutils.to_str('.salt.var.publish'),
               'fun': salt.utils.stringutils.to_str('.salt.var.fun'),
               'event': salt.utils.stringutils.to_str('.salt.event.events'),
               'event_req': salt.utils.stringutils.to_str('.salt.event.event_req'),  # deque
               'presence_req': salt.utils.stringutils.to_str('.salt.presence.event_req'),  # deque
               'stats_req': salt.utils.stringutils.to_str('.salt.stats.event_req'),  # deque
               'availables': salt.utils.stringutils.to_str('.salt.var.presence.availables'),  # set()
               'workers': salt.utils.stringutils.to_str('.salt.track.workers'),
               'worker_verify': salt.utils.stringutils.to_str('.salt.var.worker_verify'),
               'lane_stack': salt.utils.stringutils.to_str('.salt.lane.manor.stack'),
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               'master_estate_name': salt.utils.stringutils.to_str('.salt.track.master_estate_name'),
               # requeuing when not yet routable
               'laters': {'ipath': salt.utils.stringutils.to_str('.salt.lane.manor.laters'),
                          'ival': deque()}}

    def _process_road_rxmsg(self, msg, sender):
        '''
        Send to the right queue
        msg is the message body dict
        sender is the unique name of the remote estate that sent the message
        '''
        pass

    def _process_lane_rxmsg(self, msg, sender):
        '''
        Send uxd messages tot he right queue or forward them to the correct
        yard etc.

        msg is message body dict
        sender is unique name  of remote that sent the message
        '''
        pass

    def _get_master_estate_name(self, clustered=False):
        '''
        Assign and return the name of the estate for the default master or empty if none
        If the default master is no longer available then selects one of the available
        masters

        If clustered is True then use load balancing algorithm to select master
        '''
        opts = self.opts.value
        master = self.road_stack.value.nameRemotes.get(self.master_estate_name.value)
        if not master or not master.alived:  # select a different master
            available_masters = [remote for remote in
                                 six.Iterator(self.road_stack.value.remotes)
                                                       if remote.alived]
            if available_masters:
                random_master = opts.get('random_master')
                if random_master:
                    master = available_masters[random.randint(0, len(available_masters) - 1)]
                else:
                    master = available_masters[0]
            else:
                master = None

        self.master_estate_name.value = master.name if master else ''

        return self.master_estate_name.value

    def _availablize(self, minions):
        '''
        Return set that is intersection of associated minion estates for
        roles in minions and the set of available minion estates.
        '''
        suffix = '_{0}'.format(kinds.APPL_KIND_NAMES[kinds.applKinds.minion])
        return list(set(minions) &
                    set((name.rstrip(suffix) for name in self.availables.value)))

    def action(self):
        '''
        Process the messages!
        '''
        while self.road_stack.value.rxMsgs:
            msg, sender = self.road_stack.value.rxMsgs.popleft()
            self._process_road_rxmsg(msg=msg, sender=sender)
        while self.laters.value:  # process requeued LaneMsgs
            msg, sender = self.laters.value.popleft()
            self.lane_stack.value.rxMsgs.append((msg, sender))
        while self.lane_stack.value.rxMsgs:
            msg, sender = self.lane_stack.value.rxMsgs.popleft()
            self._process_lane_rxmsg(msg=msg, sender=sender)


class SaltRaetRouterMaster(SaltRaetRouter):
    '''
    Routes the communication in and out of Road and Lane connections
    Specific to Master

    do salt raet router master

    '''
    def _process_road_rxmsg(self, msg, sender):
        '''
        Send to the right queue
        msg is the message body dict
        sender is the unique name of the remote estate that sent the message
        '''
        try:
            s_estate, s_yard, s_share = msg['route']['src']
            d_estate, d_yard, d_share = msg['route']['dst']
        except (ValueError, IndexError):
            log.error('Received invalid message: %s', msg)
            return

        if s_estate is None:  # drop
            return

        log.debug(
            '**** Road Router rxMsg **** id=%s estate=%s yard=%s\nmsg=%s',
            self.opts.value['id'],
            self.road_stack.value.local.name,
            self.lane_stack.value.local.name,
            msg
        )

        if d_estate is not None and d_estate != self.road_stack.value.local.name:
            log.error('Road Router Received message for wrong estate: %s', d_estate)
            return

        if d_yard is not None:
            # Meant for another yard, send it off!
            if d_yard in self.lane_stack.value.nameRemotes:
                self.lane_stack.value.transmit(msg,
                                               self.lane_stack.value.nameRemotes[d_yard].uid)
            return
        if d_share is None:
            # No queue destination!
            log.error('Received message without share: %s', msg)
            return
        elif d_share == 'event_fire':  # rebroadcast events from other masters
            self.event.value.append(msg)
            #log.debug("\n**** Event Fire \n %s\n", msg)
            return
        elif d_share == 'local_cmd':
            # Refuse local commands over the wire
            log.error('Received local command remotely! Ignoring: %s', msg)
            return
        elif d_share == 'remote_cmd':
            # Send it to a remote worker
            if 'load' in msg:
                role = self.road_stack.value.nameRemotes[sender].role
                msg['load']['id'] = role  # sender # should this be role XXXX
                self.lane_stack.value.transmit(msg,
                                               self.lane_stack.value.fetchUidByName(next(self.workers.value)))

    def _process_lane_rxmsg(self, msg, sender):
        '''
        Send uxd messages tot he right queue or forward them to the correct
        yard etc.

        msg is message body dict
        sender is unique name  of remote that sent the message
        '''
        try:
            s_estate, s_yard, s_share = msg['route']['src']
            d_estate, d_yard, d_share = msg['route']['dst']
        except (ValueError, IndexError):
            log.error('Lane Router Received invalid message: %s', msg)
            return

        if s_yard is None:
            return  # drop message

        if s_estate is None:  # substitute local estate
            s_estate = self.road_stack.value.local.name
            msg['route']['src'] = (s_estate, s_yard, s_share)

        log.debug(
            '**** Lane Router rxMsg **** id=%s estate=%s yard=%s\nmsg=%s',
            self.opts.value['id'],
            self.road_stack.value.local.name,
            self.lane_stack.value.local.name,
            msg
        )

        if d_estate is None:
            pass
        elif d_estate != self.road_stack.value.local.name:
            # Forward to the correct estate
            if d_estate in self.road_stack.value.nameRemotes:
                self.road_stack.value.message(msg,
                                              self.road_stack.value.nameRemotes[d_estate].uid)
            return

        if d_share == 'pub_ret':
            # only publish to available minions
            msg['return']['ret']['minions'] = self._availablize(msg['return']['ret']['minions'])
            if msg.get('__worker_verify') == self.worker_verify.value:
                self.publish.value.append(msg)

        if d_yard is None:
            pass
        elif d_yard != self.lane_stack.value.local.name:
            # Meant for another yard, send it off!
            if d_yard in self.lane_stack.value.nameRemotes:
                self.lane_stack.value.transmit(msg,
                                               self.lane_stack.value.nameRemotes[d_yard].uid)
            return
        if d_share is None:
            # No queue destination!
            log.error('Lane Router Received message without share: %s', msg)
            return
        elif d_share == 'local_cmd':
            self.lane_stack.value.transmit(msg,
                                           self.lane_stack.value.fetchUidByName(next(self.workers.value)))
        elif d_share == 'event_req':
            self.event_req.value.append(msg)
            #log.debug("\n**** Event Subscribe \n %s\n", msg)
        elif d_share == 'event_fire':
            self.event.value.append(msg)
            #log.debug("\n**** Event Fire \n %s\n", msg)
        elif d_share == 'presence_req':
            self.presence_req.value.append(msg)
            #log.debug("\n**** Presence Request \n %s\n", msg)
        elif d_share == 'stats_req':
            self.stats_req.value.append(msg)
            #log.debug("\n**** Stats Request \n %s\n", msg)


class SaltRaetRouterMinion(SaltRaetRouter):
    '''
    Routes the communication in and out of Road and Lane connections
    Specific to Minions

    do salt raet router minion

    '''
    def _process_road_rxmsg(self, msg, sender):
        '''
        Send to the right queue
        msg is the message body dict
        sender is the unique name of the remote estate that sent the message
        '''
        try:
            s_estate, s_yard, s_share = msg['route']['src']
            d_estate, d_yard, d_share = msg['route']['dst']
        except (ValueError, IndexError):
            log.error('Received invalid message: %s', msg)
            return

        if s_estate is None:  # drop
            return

        log.debug(
            '**** Road Router rxMsg **** id=%s estate=%s yard=%s\nmsg=%s',
            self.opts.value['id'],
            self.road_stack.value.local.name,
            self.lane_stack.value.local.name,
            msg
        )

        if d_estate is not None and d_estate != self.road_stack.value.local.name:
            log.error('Road Router Received message for wrong estate: %s', d_estate)
            return

        if d_yard is not None:
            # Meant for another yard, send it off!
            if d_yard in self.lane_stack.value.nameRemotes:
                self.lane_stack.value.transmit(msg,
                                               self.lane_stack.value.nameRemotes[d_yard].uid)
                return
            return
        if d_share is None:
            # No queue destination!
            log.error('Received message without share: %s', msg)
            return

        elif d_share == 'fun':
            if self.road_stack.value.kind == kinds.applKinds.minion:
                self.fun.value.append(msg)
        elif d_share == 'stats_req':
            self.stats_req.value.append(msg)
            #log.debug("\n**** Stats Request \n %s\n", msg)

    def _process_lane_rxmsg(self, msg, sender):
        '''
        Send uxd messages tot he right queue or forward them to the correct
        yard etc.

        msg is message body dict
        sender is unique name  of remote that sent the message
        '''
        try:
            s_estate, s_yard, s_share = msg['route']['src']
            d_estate, d_yard, d_share = msg['route']['dst']
        except (ValueError, IndexError):
            log.error('Lane Router Received invalid message: %s', msg)
            return

        if s_yard is None:
            return  # drop message

        if s_estate is None:  # substitute local estate
            s_estate = self.road_stack.value.local.name
            msg['route']['src'] = (s_estate, s_yard, s_share)

        log.debug(
            '**** Lane Router rxMsg **** id=%s estate=%s yard=%s\nmsg=%s',
            self.opts.value['id'],
            self.road_stack.value.local.name,
            self.lane_stack.value.local.name,
            msg
        )

        if d_estate is None:
            pass
        elif d_estate != self.road_stack.value.local.name:
            # Forward to the correct estate
            if d_estate in self.road_stack.value.nameRemotes:
                self.road_stack.value.message(msg,
                                              self.road_stack.value.nameRemotes[d_estate].uid)
            return

        if d_yard is None:
            pass
        elif d_yard != self.lane_stack.value.local.name:
            # Meant for another yard, send it off!
            if d_yard in self.lane_stack.value.nameRemotes:
                self.lane_stack.value.transmit(msg,
                                               self.lane_stack.value.nameRemotes[d_yard].uid)
                return
            return
        if d_share is None:
            # No queue destination!
            log.error('Lane Router Received message without share: %s', msg)
            return

        elif d_share == 'event_req':
            self.event_req.value.append(msg)
            #log.debug("\n**** Event Subscribe \n %s\n", msg)
        elif d_share == 'event_fire':
            self.event.value.append(msg)
            #log.debug("\n**** Event Fire \n %s\n", msg)

        elif d_share == 'remote_cmd':  # assume  minion to master or salt-call
            if not self.road_stack.value.remotes:
                log.error("**** Lane Router: Missing joined master. Unable to route "
                          "remote_cmd. Requeuing")
                self.laters.value.append((msg, sender))
                return
            d_estate = self._get_master_estate_name(clustered=self.opts.get('cluster_mode', False))
            if not d_estate:
                log.error("**** Lane Router: No available destination estate for 'remote_cmd'."
                          "Unable to route. Requeuing")
                self.laters.value.append((msg, sender))
                return
            msg['route']['dst'] = (d_estate, d_yard, d_share)
            log.debug("**** Lane Router: Missing destination estate for 'remote_cmd'. "
                      "Using default route=%s.", msg['route']['dst'])
            self.road_stack.value.message(msg,
                                          self.road_stack.value.nameRemotes[d_estate].uid)

    def _get_master_estate_name(self, clustered=False):
        '''
        Assign and return the name of the estate for the default master or empty if none
        If the default master is no longer available then selects one of the available
        masters
        '''
        opts = self.opts.value
        master = self.road_stack.value.nameRemotes.get(self.master_estate_name.value)
        if not master or not master.alived:  # select a different master
            available_masters = [remote for remote in
                                 list(self.road_stack.value.remotes.values())
                                                       if remote.alived]
            if available_masters:
                random_master = opts.get('random_master')
                if random_master:
                    master = available_masters[random.randint(0, len(available_masters) - 1)]
                else:
                    master = available_masters[0]
            else:
                master = None

        self.master_estate_name.value = master.name if master else ''

        return self.master_estate_name.value

    def _availablize(self, minions):
        '''
        Return set that is intersection of associated minion estates for
        roles in minions and the set of available minion estates.
        '''
        suffix = '_{0}'.format(kinds.APPL_KIND_NAMES[kinds.applKinds.minion])
        return list(set(minions) &
                    set((name.rstrip(suffix) for name in self.availables.value)))


class SaltRaetEventer(ioflo.base.deeding.Deed):
    '''
    Fire events!
    FloScript:

    do salt raet eventer

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'event_yards': salt.utils.stringutils.to_str('.salt.event.yards'),
               'event': salt.utils.stringutils.to_str('.salt.event.events'),
               'event_req': salt.utils.stringutils.to_str('.salt.event.event_req'),
               'module_refresh': salt.utils.stringutils.to_str('.salt.var.module_refresh'),
               'pillar_refresh': salt.utils.stringutils.to_str('.salt.var.pillar_refresh'),
               'lane_stack': salt.utils.stringutils.to_str('.salt.lane.manor.stack'),
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               'availables': salt.utils.stringutils.to_str('.salt.var.presence.availables'), }

    def _register_event_yard(self, msg):
        '''
        register an incoming event request with the requesting yard id
        '''
        self.event_yards.value.add(msg['route']['src'][1])

    def _forward_event(self, msg):
        '''
        Forward an event message to all subscribed yards
        Event message has a route
        '''
        rm_ = []
        if msg.get('tag') == 'pillar_refresh':
            self.pillar_refresh.value = True
        if msg.get('tag') == 'module_refresh':
            self.module_refresh.value = True
        for y_name in self.event_yards.value:
            if y_name not in self.lane_stack.value.nameRemotes:  # subscriber not a remote
                rm_.append(y_name)
                continue  # drop msg don't publish
            self.lane_stack.value.transmit(msg,
                    self.lane_stack.value.fetchUidByName(y_name))
            self.lane_stack.value.serviceAll()
        for y_name in rm_:  # remove missing subscribers
            self.event_yards.value.remove(y_name)

    def action(self):
        '''
        Register event requests
        Iterate over the registered event yards and fire!
        '''
        while self.event_req.value:  # event subscription requests are msg with routes
            self._register_event_yard(
                    self.event_req.value.popleft()
                    )

        while self.event.value:  # events are msgs with routes
            self._forward_event(
                    self.event.value.popleft()
                    )


class SaltRaetEventerMaster(SaltRaetEventer):
    '''
    Fire events!
    FloScript:

    do salt raet eventer master

    '''
    def _forward_event(self, msg):
        '''
        Forward an event message to all subscribed yards
        Event message has a route
        Also rebroadcast to all masters in cluster
        '''
        super(SaltRaetEventerMaster, self)._forward_event(msg)
        if self.opts.value.get('cluster_mode'):
            if msg.get('origin') is None:
                masters = (self.availables.value &
                           set((remote.name for remote in list(self.road_stack.value.remotes.values())
                                if remote.kind == kinds.applKinds.master)))
                for name in masters:
                    remote = self.road_stack.value.nameRemotes[name]
                    msg['origin'] = self.road_stack.value.name
                    s_estate, s_yard, s_share = msg['route']['src']
                    msg['route']['src'] = (self.road_stack.value.name, s_yard, s_share)
                    msg['route']['dst'] = (remote.name, None, 'event_fire')
                    self.road_stack.value.message(msg, remote.uid)


class SaltRaetPresenter(ioflo.base.deeding.Deed):
    '''
    Fire presence events!
    FloScript:

    do salt raet presenter

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'presence_req': salt.utils.stringutils.to_str('.salt.presence.event_req'),
               'lane_stack': salt.utils.stringutils.to_str('.salt.lane.manor.stack'),
               'alloweds': salt.utils.stringutils.to_str('.salt.var.presence.alloweds'),  # odict
               'aliveds': salt.utils.stringutils.to_str('.salt.var.presence.aliveds'),  # odict
               'reapeds': salt.utils.stringutils.to_str('.salt.var.presence.reapeds'),  # odict
               'availables': salt.utils.stringutils.to_str('.salt.var.presence.availables'),  # set
              }

    def _send_presence(self, msg):
        '''
        Forward an presence message to all subscribed yards
        Presence message has a route
        '''
        y_name = msg['route']['src'][1]
        if y_name not in self.lane_stack.value.nameRemotes:  # subscriber not a remote
            pass  # drop msg don't answer
        else:
            if 'data' in msg and 'state' in msg['data']:
                state = msg['data']['state']
            else:
                state = None

            # create answer message
            if state in [None, 'available', 'present']:
                present = odict()
                for name in self.availables.value:
                    minion = self.aliveds.value.get(name, None)
                    present[name] = minion.ha[0] if minion else None
                data = {'present': present}
            else:
                # TODO: update to really return joineds
                states = {'joined': self.alloweds,
                          'allowed': self.alloweds,
                          'alived': self.aliveds,
                          'reaped': self.reapeds}
                try:
                    minions = states[state].value
                except KeyError:
                    # error: wrong/unknown state requested
                    log.error('Lane Router Received invalid message: %s', msg)
                    return

                result = odict()
                for name in minions:
                    result[name] = minions[name].ha[0]
                data = {state: result}

            tag = tagify('present', 'presence')
            route = {'dst': (None, None, 'event_fire'),
                     'src': (None, self.lane_stack.value.local.name, None)}
            msg = {'route': route, 'tag': tag, 'data': data}
            self.lane_stack.value.transmit(msg,
                                           self.lane_stack.value.fetchUidByName(y_name))
            self.lane_stack.value.serviceAll()

    def action(self):
        '''
        Register presence requests
        Iterate over the registered presence yards and fire!
        '''
        while self.presence_req.value:  # presence are msgs with routes
            self._send_presence(
                self.presence_req.value.popleft()
            )


class SaltRaetStatsEventer(ioflo.base.deeding.Deed):
    '''
    Fire stats events
    FloScript:

    do salt raet state eventer

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'stats_req': salt.utils.stringutils.to_str('.salt.stats.event_req'),
               'lane_stack': salt.utils.stringutils.to_str('.salt.lane.manor.stack'),
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
    }

    def _send_stats(self, msg):
        '''
        Forward a stats message to all subscribed yards
        Stats message has a route
        '''
        pass

    def _get_stats(self, tag):
        if tag == tagify('road', 'stats'):
            return self.road_stack.value.stats
        elif tag == tagify('lane', 'stats'):
            return self.lane_stack.value.stats
        else:
            log.error('Missing or invalid tag: %s', tag)
            return None

    def action(self):
        '''
        Iterate over the registered stats requests and fire!
        '''
        while self.stats_req.value:  # stats are msgs with routes
            self._send_stats(
                self.stats_req.value.popleft()
            )


class SaltRaetStatsEventerMaster(SaltRaetStatsEventer):

    def _send_stats(self, msg):
        '''
        Forward a stats message to all subscribed yards
        Stats message has a route
        '''
        y_name = msg['route']['src'][1]
        if y_name not in self.lane_stack.value.nameRemotes:  # subscriber not a remote
            return  # drop msg don't answer

        stats = self._get_stats(msg.get('tag'))
        if stats is None:
            return

        route = {'dst': (None, None, 'event_fire'),
                 'src': (None, self.lane_stack.value.local.name, None)}
        repl = {'route': route, 'tag': msg.get('tag'), 'data': stats}
        self.lane_stack.value.transmit(repl,
                                       self.lane_stack.value.fetchUidByName(y_name))
        self.lane_stack.value.serviceAll()


class SaltRaetStatsEventerMinion(SaltRaetStatsEventer):

    def _send_stats(self, msg):
        '''
        Forward a stats message to all subscribed yards
        Stats message has a route
        '''
        s_estate, s_yard, s_share = msg['route']['src']
        if s_estate not in self.road_stack.value.nameRemotes:  # subscriber not a remote
            return  # drop msg don't answer

        stats = self._get_stats(msg.get('tag'))
        if stats is None:
            return

        route = {'dst': (s_estate, s_yard, 'event_fire'),
                 'src': (self.road_stack.value.name, self.lane_stack.value.name, None)}
        repl = {'route': route, 'tag': msg.get('tag'), 'data': stats}
        self.road_stack.value.transmit(repl,
                                       self.road_stack.value.fetchUidByName(s_estate))
        self.road_stack.value.serviceAll()


class SaltRaetPublisher(ioflo.base.deeding.Deed):
    '''
    Publish to the minions
    FloScript:

    do salt raet publisher

    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'publish': salt.utils.stringutils.to_str('.salt.var.publish'),
               'stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               'availables': salt.utils.stringutils.to_str('.salt.var.presence.availables'),
            }

    def _publish(self, pub_msg):
        '''
        Publish the message out to the targeted minions
        '''
        stack = self.stack.value
        pub_data = pub_msg['return']
        # only publish to available minions by intersecting sets

        minions = (self.availables.value &
                   set((remote.name for remote in list(stack.remotes.values())
                            if remote.kind in [kinds.applKinds.minion,
                                               kinds.applKinds.syndic])))
        for minion in minions:
            uid = self.stack.value.fetchUidByName(minion)
            if uid:
                route = {
                        'dst': (minion, None, 'fun'),
                        'src': (self.stack.value.local.name, None, None)}
                msg = {'route': route, 'pub': pub_data['pub']}
                self.stack.value.message(msg, uid)

    def action(self):
        '''
        Pop the publish queue and publish the requests!
        '''
        while self.publish.value:
            self._publish(
                    self.publish.value.popleft()
                    )


class SaltRaetSetupEngines(ioflo.base.deeding.Deed):
    '''
    Start the engines!
    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'proc_mgr': salt.utils.stringutils.to_str('.salt.usr.proc_mgr')}

    def action(self):
        '''
        Only call once, this will start the engine processes
        '''
        salt.engines.start_engines(self.opts.value, self.proc_mgr.value)


class SaltRaetSetupBeacon(ioflo.base.deeding.Deed):
    '''
    Create the Beacon subsystem
    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'beacon': salt.utils.stringutils.to_str('.salt.beacon'),
               'modules': salt.utils.stringutils.to_str('.salt.loader.modules')}

    def action(self):
        '''
        Run the beacons
        '''
        self.beacon.value = salt.beacons.Beacon(
                self.opts.value,
                self.modules.value)


class SaltRaetBeacon(ioflo.base.deeding.Deed):
    '''
    Run the beacons
    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'modules': salt.utils.stringutils.to_str('.salt.loader.modules'),
               'master_events': salt.utils.stringutils.to_str('.salt.var.master_events'),
               'event': salt.utils.stringutils.to_str('.salt.event.events'),
               'beacon': salt.utils.stringutils.to_str('.salt.beacon')}

    def action(self):
        '''
        Run the beacons
        '''
        if 'config.merge' in self.modules.value:
            b_conf = self.modules.value['config.merge']('beacons')
            if b_conf:
                try:
                    events = self.beacon.value.process(b_conf)
                    self.master_events.value.extend(events)
                    self.event.value.extend(events)
                except Exception:
                    log.error('Error in the beacon system: ', exc_info=True)
        return []


class SaltRaetMasterEvents(ioflo.base.deeding.Deed):
    '''
    Take the events off the master event que and send them to the master to
    be fired
    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'road_stack': salt.utils.stringutils.to_str('.salt.road.manor.stack'),
               'master_events': salt.utils.stringutils.to_str('.salt.var.master_events')}

    def _prepare(self):
        self.master_events.value = deque()

    def action(self):
        if not self.master_events.value:
            return
        events = []
        for master in self.road_stack.value.remotes:
            master_uid = master
        while self.master_events.value:
            events.append(self.master_events.value.popleft())
        route = {'src': (self.road_stack.value.local.name, None, None),
                 'dst': (next(list(self.road_stack.value.remotes.values())).name, None, 'remote_cmd')}
        load = {'id': self.opts.value['id'],
                'events': events,
                'cmd': '_minion_event'}
        self.road_stack.value.transmit({'route': route, 'load': load},
                                       uid=master_uid)


class SaltRaetSetupMatcher(ioflo.base.deeding.Deed):
    '''
    Make the matcher object
    '''
    Ioinits = {'opts': salt.utils.stringutils.to_str('.salt.opts'),
               'modules': salt.utils.stringutils.to_str('.salt.loader.modules'),
               'matcher': salt.utils.stringutils.to_str('.salt.matcher')}

    def action(self):
        self.matcher.value = salt.minion.Matcher(
                self.opts.value,
                self.modules.value)
