Mercurial > libervia-backend

comparison src/plugins/plugin_exp_pubsub_hook.py @ 2307:8fa7edd0da24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
plugin Pubsub Hook: first draft: This new plugin allow to attach an external action to a Pubsub event (i.e. notification). Hook can be persitent accross restarts, or temporary (will be deleted on profile disconnection). Only Python files are handled for now. In the future, it may make sense to move hooks in a generic plugin which could be used by ad-hoc commands, messages, pubsub, etc.
author Goffi <goffi@goffi.org>
date Wed, 05 Jul 2017 15:05:47 +0200
parents
children 30278ea1ca7c
comparison
equal deleted inserted replaced
2306:07deebea71f3 2307:8fa7edd0da24
1 #!/usr/bin/env python2
2 # -*- coding: utf-8 -*-
3
4 # SAT plugin for Pubsub Hooks
5 # Copyright (C) 2009-2017 Jérôme Poisson (goffi@goffi.org)
6
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU Affero General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU Affero General Public License for more details.
16
17 # You should have received a copy of the GNU Affero General Public License
18 # along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20 from sat.core.i18n import _
21 from sat.core.constants import Const as C
22 from sat.core import exceptions
23 from sat.core.log import getLogger
24 from sat.memory import persistent
25 from twisted.words.protocols.jabber import jid
26 from twisted.internet import defer
27 log = getLogger(__name__)
28
29 NS_PUBSUB_HOOK = 'PUBSUB_HOOK'
30
31 PLUGIN_INFO = {
32 C.PI_NAME: "PubSub Hook",
33 C.PI_IMPORT_NAME: NS_PUBSUB_HOOK,
34 C.PI_TYPE: "EXP",
35 C.PI_PROTOCOLS: [],
36 C.PI_DEPENDENCIES: ["XEP-0060"],
37 C.PI_MAIN: "PubsubHook",
38 C.PI_HANDLER: "no",
39 C.PI_DESCRIPTION: _("""Experimental plugin to launch on action on Pubsub notifications""")
40 }
41
42 # python module
43 HOOK_TYPE_PYTHON = u'python'
44 # python file path
45 HOOK_TYPE_PYTHON_FILE = u'python_file'
46 # python code directly
47 HOOK_TYPE_PYTHON_CODE = u'python_code'
48 HOOK_TYPES = (HOOK_TYPE_PYTHON, HOOK_TYPE_PYTHON_FILE, HOOK_TYPE_PYTHON_CODE)
49
50
51 class PubsubHook(object):
52
53 def __init__(self, host):
54 log.info(_(u"PubSub Hook initialization"))
55 self.host = host
56 self.node_hooks = {} # keep track of the number of hooks per node (for all profiles)
57 host.bridge.addMethod("psHookAdd", ".plugin",
58 in_sign='ssssbs', out_sign='',
59 method=self._addHook
60 )
61 host.bridge.addMethod("psHookRemove", ".plugin",
62 in_sign='sssss', out_sign='i',
63 method=self._removeHook
64 )
65 host.bridge.addMethod("psHookList", ".plugin",
66 in_sign='s', out_sign='aa{ss}',
67 method=self._listHooks
68 )
69
70 @defer.inlineCallbacks
71 def profileConnected(self, client):
72 hooks = client._hooks = persistent.PersistentBinaryDict(NS_PUBSUB_HOOK, client.profile)
73 client._hooks_temporary = {}
74 yield hooks.load()
75 for node in hooks:
76 self._installNodeManager(client, node)
77
78 def profileDisconnected(self, client):
79 for node in client._hooks:
80 self._removeNodeManager(client, node)
81
82 def _installNodeManager(self, client, node):
83 if node in self.node_hooks:
84 log.debug(_(u"node manager already set for {node}").format(node=node))
85 self.node_hooks[node] += 1
86 else:
87 # first hook on this node
88 self.host.plugins['XEP-0060'].addManagedNode(node, items_cb=self._itemsReceived)
89 self.node_hooks[node] = 0
90 log.info(_(u"node manager installed on {node}").format(
91 node = node))
92
93 def _removeNodeManager(self, client, node):
94 try:
95 self.node_hooks[node] -= 1
96 except KeyError:
97 log.error(_(u"trying to remove a {node} without hook").format(node=node))
98 else:
99 if self.node_hooks[node] == 0:
100 del self.node_hooks[node]
101 self.host.plugins['XEP-0060'].removeManagedNode(node, self._itemsReceived)
102 log.debug(_(u"hook removed"))
103 else:
104 log.debug(_(u"node still needed for an other hook"))
105
106 def installHook(self, client, service, node, hook_type, hook_arg, persistent):
107 if hook_type not in HOOK_TYPES:
108 raise exceptions.DataError(_(u'{hook_type} is not handled').format(hook_type=hook_type))
109 if hook_type != HOOK_TYPE_PYTHON_FILE:
110 raise NotImplementedError(_(u'{hook_type} hook type not implemented yet').format(hook_type=hook_type))
111 self._installNodeManager(client, node)
112 hook_data = {'service': service,
113 'type': hook_type,
114 'arg': hook_arg
115 }
116
117 if persistent:
118 hooks_list = client._hooks.setdefault(node,[])
119 hooks_list.append(hook_data)
120 client._hooks.force(node)
121 else:
122 hooks_list = client._hooks_temporary.setdefault(node,[])
123 hooks_list.append(hook_data)
124
125 log.info(_(u"{persistent} hook installed on {node} for {profile}").format(
126 persistent = _(u'persistent') if persistent else _(u'temporary'),
127 node = node,
128 profile = client.profile))
129
130 def _itemsReceived(self, client, itemsEvent):
131 node = itemsEvent.nodeIdentifier
132 for hooks in (client._hooks, client._hooks_temporary):
133 if node not in hooks:
134 continue
135 hooks_list = hooks[node]
136 for hook_data in hooks_list[:]:
137 if hook_data['service'] != itemsEvent.sender.userhostJID():
138 continue
139 try:
140 callback = hook_data['callback']
141 except KeyError:
142 # first time we get this hook, we create the callback
143 hook_type = hook_data['type']
144 try:
145 if hook_type == HOOK_TYPE_PYTHON_FILE:
146 hook_globals = {}
147 execfile(hook_data['arg'], hook_globals)
148 callback = hook_globals['hook']
149 else:
150 raise NotImplementedError(_(u'{hook_type} hook type not implemented yet').format(
151 hook_type=hook_type))
152 except Exception as e:
153 log.warning(_(u"Can't load Pubsub hook at node {node}, it will be removed: {reason}").format(
154 node=node, reason=e))
155 hooks_list.remove(hook_data)
156 continue
157
158 for item in itemsEvent.items:
159 try:
160 callback(self.host, client, item)
161 except Exception as e:
162 log.warning(_(u"Error while running Pubsub hook for node {node}: {msg}").format(
163 node = node,
164 msg = e))
165
166 def _addHook(self, service, node, hook_type, hook_arg, persistent, profile):
167 client = self.host.getClient(profile)
168 service = jid.JID(service) if service else client.jid.userhostJID()
169 return self.addHook(client, service, unicode(node), unicode(hook_type), unicode(hook_arg), persistent)
170
171 def addHook(self, client, service, node, hook_type, hook_arg, persistent):
172 r"""Add a hook which will be triggered on a pubsub notification
173
174 @param service(jid.JID): service of the node
175 @param node(unicode): Pubsub node
176 @param hook_type(unicode): type of the hook, one of:
177 - HOOK_TYPE_PYTHON: a python module (must be in path)
178 module must have a "hook" method which will be called
179 - HOOK_TYPE_PYTHON_FILE: a python file
180 file must have a "hook" method which will be called
181 - HOOK_TYPE_PYTHON_CODE: direct python code
182 /!\ Python hooks will be executed in SàT context,
183 with host, client and item as arguments, it means that:
184 - they can do whatever they wants, so don't run untrusted hooks
185 - they MUST NOT BLOCK, they are run in Twisted async environment and blocking would block whole SàT process
186 - item are domish.Element
187 @param hook_arg(unicode): argument of the hook, depending on the hook_type
188 can be a module path, file path, python code
189 """
190 assert service is not None
191 return self.installHook(client, service, node, hook_type, hook_arg, persistent)
192
193 def _removeHook(self, service, node, hook_type, hook_arg, profile):
194 client = self.host.getClient(profile)
195 service = jid.JID(service) if service else client.jid.userhostJID()
196 return self.removeHook(client, service, node, hook_type or None, hook_arg or None)
197
198 def removeHook(self, client, service, node, hook_type=None, hook_arg=None):
199 """Remove a persistent or temporaty root
200
201 @param service(jid.JID): service of the node
202 @param node(unicode): Pubsub node
203 @param hook_type(unicode, None): same as for [addHook]
204 match all if None
205 @param hook_arg(unicode, None): same as for [addHook]
206 match all if None
207 @return(int): number of hooks removed
208 """
209 removed = 0
210 for hooks in (client._hooks, client._hooks_temporary):
211 if node in hooks:
212 for hook_data in hooks[node]:
213 if (service != hook_data[u'service']
214 or hook_type is not None and hook_type != hook_data[u'type']
215 or hook_arg is not None and hook_arg != hook_data[u'arg']):
216 continue
217 hooks[node].remove(hook_data)
218 removed += 1
219 if not hooks[node]:
220 # no more hooks, we can remove the node
221 del hooks[node]
222 self._removeNodeManager(client, node)
223 else:
224 if hooks == client._hooks:
225 hooks.force(node)
226 return removed
227
228 def _listHooks(self, profile):
229 hooks_list = self.listHooks(self.host.getClient(profile))
230 for hook in hooks_list:
231 hook[u'service'] = hook[u'service'].full()
232 hook[u'persistent'] = C.boolConst(hook[u'persistent'])
233 return hooks_list
234
235 def listHooks(self, client):
236 """return list of registered hooks"""
237 hooks_list = []
238 for hooks in (client._hooks, client._hooks_temporary):
239 persistent = hooks is client._hooks
240 for node, hooks_data in hooks.iteritems():
241 for hook_data in hooks_data:
242 hooks_list.append({u'service': hook_data[u'service'],
243 u'node': node,
244 u'type': hook_data[u'type'],
245 u'arg': hook_data[u'arg'],
246 u'persistent': persistent
247 })
248 return hooks_list
249