bindings/python/bt2/bt2/graph.py

   1 # The MIT License (MIT)
   2 #
   3 # Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
   4 #
   5 # Permission is hereby granted, free of charge, to any person obtaining a copy
   6 # of this software and associated documentation files (the "Software"), to deal
   7 # in the Software without restriction, including without limitation the rights
   8 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 # copies of the Software, and to permit persons to whom the Software is
  10 # furnished to do so, subject to the following conditions:
  11 #
  12 # The above copyright notice and this permission notice shall be included in
  13 # all copies or substantial portions of the Software.
  14 #
  15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 # THE SOFTWARE.
  22
  23 from bt2 import native_bt, object, utils
  24 import bt2.connection
  25 import bt2.component
  26 import functools
  27 import bt2.port
  28 import bt2
  29
  30
  31 class GraphListenerType:
  32     PORT_ADDED = 0
  33     PORT_REMOVED = 1
  34     PORTS_CONNECTED = 2
  35     PORTS_DISCONNECTED = 3
  36
  37
  38 def _graph_port_added_listener_from_native(user_listener, port_ptr):
  39     try:
  40         port = bt2.port._create_from_ptr(port_ptr)
  41         port._get()
  42         user_listener(port)
  43     except:
  44         pass
  45
  46
  47 def _graph_port_removed_listener_from_native(user_listener, port_ptr):
  48     try:
  49         port = bt2.port._create_from_ptr(port_ptr)
  50         port._get()
  51         user_listener(port)
  52     except:
  53         pass
  54
  55
  56 def _graph_ports_connected_listener_from_native(user_listener,
  57                                                 upstream_port_ptr,
  58                                                 downstream_port_ptr):
  59     try:
  60         upstream_port = bt2.port._create_from_ptr(upstream_port_ptr)
  61         upstream_port._get()
  62         downstream_port = bt2.port._create_from_ptr(downstream_port_ptr)
  63         downstream_port._get()
  64         user_listener(upstream_port, downstream_port)
  65     except:
  66         pass
  67
  68
  69 def _graph_ports_disconnected_listener_from_native(user_listener,
  70                                                    upstream_comp_ptr,
  71                                                    downstream_comp_ptr,
  72                                                    upstream_port_ptr,
  73                                                    downstream_port_ptr):
  74     try:
  75         upstream_comp = bt2.component._create_generic_component_from_ptr(upstream_comp_ptr)
  76         upstream_comp._get()
  77         downstream_comp = bt2.component._create_generic_component_from_ptr(downstream_comp_ptr)
  78         downstream_comp._get()
  79         upstream_port = bt2.port._create_from_ptr(upstream_port_ptr)
  80         upstream_port._get()
  81         downstream_port = bt2.port._create_from_ptr(downstream_port_ptr)
  82         downstream_port._get()
  83         user_listener(upstream_comp, downstream_comp, upstream_port,
  84                       downstream_port)
  85     except:
  86         pass
  87
  88
  89 class Graph(object._Object):
  90     def __init__(self):
  91         ptr = native_bt.graph_create()
  92
  93         if ptr is None:
  94             raise bt2.CreationError('cannot create graph object')
  95
  96         super().__init__(ptr)
  97
  98     def _handle_status(self, status, gen_error_msg):
  99         if status == native_bt.GRAPH_STATUS_COMPONENT_REFUSES_PORT_CONNECTION:
 100             raise bt2.PortConnectionRefused
 101         elif status == native_bt.GRAPH_STATUS_CANCELED:
 102             raise bt2.GraphCanceled
 103         elif status == native_bt.GRAPH_STATUS_END:
 104             raise bt2.Stop
 105         elif status == native_bt.GRAPH_STATUS_AGAIN:
 106             raise bt2.TryAgain
 107         elif status == native_bt.GRAPH_STATUS_NO_SINK:
 108             raise bt2.NoSinkComponent
 109         elif status < 0:
 110             raise bt2.Error(gen_error_msg)
 111
 112     def add_component(self, component_class, name, params=None):
 113         if isinstance(component_class, bt2.component._GenericComponentClass):
 114             cc_ptr = component_class._ptr
 115         elif issubclass(component_class, bt2.component._UserComponent):
 116             cc_ptr = component_class._cc_ptr
 117         else:
 118             raise TypeError("'{}' is not a component class".format(component_class.__class__.__name__))
 119
 120         utils._check_str(name)
 121         params = bt2.create_value(params)
 122
 123         if params is None:
 124             params_ptr = None
 125         else:
 126             params_ptr = params._ptr
 127
 128         status, comp_ptr = native_bt.graph_add_component(self._ptr, cc_ptr,
 129                                                          name, params_ptr)
 130         self._handle_status(status, 'cannot add component to graph')
 131         assert(comp_ptr)
 132         return bt2.component._create_generic_component_from_ptr(comp_ptr)
 133
 134     def connect_ports(self, upstream_port, downstream_port):
 135         utils._check_type(upstream_port, bt2.port._OutputPort)
 136         utils._check_type(downstream_port, bt2.port._InputPort)
 137         status, conn_ptr = native_bt.graph_connect_ports(self._ptr,
 138                                                          upstream_port._ptr,
 139                                                          downstream_port._ptr)
 140         self._handle_status(status, 'cannot connect component ports within graph')
 141         assert(conn_ptr)
 142         return bt2.connection._Connection._create_from_ptr(conn_ptr)
 143
 144     def add_listener(self, listener_type, listener):
 145         if not hasattr(listener, '__call__'):
 146             raise TypeError("'listener' parameter is not callable")
 147
 148         if listener_type == GraphListenerType.PORT_ADDED:
 149             fn = native_bt.py3_graph_add_port_added_listener
 150             listener_from_native = functools.partial(_graph_port_added_listener_from_native,
 151                                                      listener)
 152         elif listener_type == GraphListenerType.PORT_REMOVED:
 153             fn = native_bt.py3_graph_add_port_removed_listener
 154             listener_from_native = functools.partial(_graph_port_removed_listener_from_native,
 155                                                      listener)
 156         elif listener_type == GraphListenerType.PORTS_CONNECTED:
 157             fn = native_bt.py3_graph_add_ports_connected_listener
 158             listener_from_native = functools.partial(_graph_ports_connected_listener_from_native,
 159                                                      listener)
 160         elif listener_type == GraphListenerType.PORTS_DISCONNECTED:
 161             fn = native_bt.py3_graph_add_ports_disconnected_listener
 162             listener_from_native = functools.partial(_graph_ports_disconnected_listener_from_native,
 163                                                      listener)
 164         else:
 165             raise TypeError
 166
 167         listener_id = fn(self._ptr, listener_from_native)
 168         utils._handle_ret(listener_id, 'cannot add listener to graph object')
 169         return bt2._ListenerHandle(listener_id, self)
 170
 171     def run(self):
 172         status = native_bt.graph_run(self._ptr)
 173
 174         if status == native_bt.GRAPH_STATUS_END:
 175             return
 176
 177         self._handle_status(status, 'graph object stopped running because of an unexpected error')
 178
 179     def cancel(self):
 180         status = native_bt.graph_cancel(self._ptr)
 181         self._handle_status(status, 'cannot cancel graph object')
 182
 183     @property
 184     def is_canceled(self):
 185         is_canceled = native_bt.graph_is_canceled(self._ptr)
 186         assert(is_canceled >= 0)
 187         return is_canceled > 0
 188
 189     def __eq__(self, other):
 190         if type(other) is not type(self):
 191             return False
 192
 193         return self.addr == other.addr