Mercurial > libervia-backend

comparison sat/bridge/pb.py @ 4037:524856bd7b19

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.
author Goffi <goffi@goffi.org>
date Sat, 08 Apr 2023 13:54:42 +0200
parents 3c7a64d6f49f
children
comparison
equal deleted inserted replaced
4036:c4464d7ae97b 4037:524856bd7b19
53 53
54 class PBRoot(pb.Root): 54 class PBRoot(pb.Root):
55 def __init__(self): 55 def __init__(self):
56 self.signals_handlers = [] 56 self.signals_handlers = []
57 57
58 def remote_initBridge(self, signals_handler): 58 def remote_init_bridge(self, signals_handler):
59 self.signals_handlers.append(HandlerWrapper(signals_handler)) 59 self.signals_handlers.append(HandlerWrapper(signals_handler))
60 log.info("registered signal handler") 60 log.info("registered signal handler")
61 61
62 def sendSignalEb(self, failure_, signal_name): 62 def send_signal_eb(self, failure_, signal_name):
63 if not failure_.check(pb.PBConnectionLost): 63 if not failure_.check(pb.PBConnectionLost):
64 log.error( 64 log.error(
65 f"Error while sending signal {signal_name}: {failure_}", 65 f"Error while sending signal {signal_name}: {failure_}",
66 ) 66 )
67 67
68 def sendSignal(self, name, args, kwargs): 68 def send_signal(self, name, args, kwargs):
69 to_remove = [] 69 to_remove = []
70 for wrapper in self.signals_handlers: 70 for wrapper in self.signals_handlers:
71 handler = wrapper.handler 71 handler = wrapper.handler
72 try: 72 try:
73 d = handler.callRemote(name, *args, **kwargs) 73 d = handler.callRemote(name, *args, **kwargs)
74 except pb.DeadReferenceError: 74 except pb.DeadReferenceError:
75 to_remove.append(wrapper) 75 to_remove.append(wrapper)
76 else: 76 else:
77 d.addErrback(self.sendSignalEb, name) 77 d.addErrback(self.send_signal_eb, name)
78 if to_remove: 78 if to_remove:
79 for wrapper in to_remove: 79 for wrapper in to_remove:
80 log.debug("Removing signal handler for dead frontend") 80 log.debug("Removing signal handler for dead frontend")
81 self.signals_handlers.remove(wrapper) 81 self.signals_handlers.remove(wrapper)
82 82
83 def _bridgeDeactivateSignals(self): 83 def _bridge_deactivate_signals(self):
84 if hasattr(self, "signals_paused"): 84 if hasattr(self, "signals_paused"):
85 log.warning("bridge signals already deactivated") 85 log.warning("bridge signals already deactivated")
86 if self.signals_handler: 86 if self.signals_handler:
87 self.signals_paused.extend(self.signals_handler) 87 self.signals_paused.extend(self.signals_handler)
88 else: 88 else:
89 self.signals_paused = self.signals_handlers 89 self.signals_paused = self.signals_handlers
90 self.signals_handlers = [] 90 self.signals_handlers = []
91 log.debug("bridge signals have been deactivated") 91 log.debug("bridge signals have been deactivated")
92 92
93 def _bridgeReactivateSignals(self): 93 def _bridge_reactivate_signals(self):
94 try: 94 try:
95 self.signals_handlers = self.signals_paused 95 self.signals_handlers = self.signals_paused
96 except AttributeError: 96 except AttributeError:
97 log.debug("signals were already activated") 97 log.debug("signals were already activated")
98 else: 98 else:
100 log.debug("bridge signals have been reactivated") 100 log.debug("bridge signals have been reactivated")
101 101
102 ##METHODS_PART## 102 ##METHODS_PART##
103 103
104 104
105 class Bridge(object): 105 class bridge(object):
106 def __init__(self): 106 def __init__(self):
107 log.info("Init Perspective Broker...") 107 log.info("Init Perspective Broker...")
108 self.root = PBRoot() 108 self.root = PBRoot()
109 conf = config.parseMainConf() 109 conf = config.parse_main_conf()
110 getConf = partial(config.getConf, conf, "bridge_pb", "") 110 get_conf = partial(config.get_conf, conf, "bridge_pb", "")
111 conn_type = getConf("connection_type", "unix_socket") 111 conn_type = get_conf("connection_type", "unix_socket")
112 if conn_type == "unix_socket": 112 if conn_type == "unix_socket":
113 local_dir = Path(config.getConfig(conf, "", "local_dir")).resolve() 113 local_dir = Path(config.config_get(conf, "", "local_dir")).resolve()
114 socket_path = local_dir / "bridge_pb" 114 socket_path = local_dir / "bridge_pb"
115 log.info(f"using UNIX Socket at {socket_path}") 115 log.info(f"using UNIX Socket at {socket_path}")
116 reactor.listenUNIX( 116 reactor.listenUNIX(
117 str(socket_path), pb.PBServerFactory(self.root), mode=0o600 117 str(socket_path), pb.PBServerFactory(self.root), mode=0o600
118 ) 118 )
119 elif conn_type == "socket": 119 elif conn_type == "socket":
120 port = int(getConf("port", 8789)) 120 port = int(get_conf("port", 8789))
121 log.info(f"using TCP Socket at port {port}") 121 log.info(f"using TCP Socket at port {port}")
122 reactor.listenTCP(port, pb.PBServerFactory(self.root)) 122 reactor.listenTCP(port, pb.PBServerFactory(self.root))
123 else: 123 else:
124 raise ValueError(f"Unknown pb connection type: {conn_type!r}") 124 raise ValueError(f"Unknown pb connection type: {conn_type!r}")
125 125
126 def sendSignal(self, name, *args, **kwargs): 126 def send_signal(self, name, *args, **kwargs):
127 self.root.sendSignal(name, args, kwargs) 127 self.root.send_signal(name, args, kwargs)
128 128
129 def remote_initBridge(self, signals_handler): 129 def remote_init_bridge(self, signals_handler):
130 self.signals_handlers.append(signals_handler) 130 self.signals_handlers.append(signals_handler)
131 log.info("registered signal handler") 131 log.info("registered signal handler")
132 132
133 def register_method(self, name, callback): 133 def register_method(self, name, callback):
134 log.debug("registering PB bridge method [%s]" % name) 134 log.debug("registering PB bridge method [%s]" % name)
135 setattr(self.root, "remote_" + name, callback) 135 setattr(self.root, "remote_" + name, callback)
136 #  self.root.register_method(name, callback) 136 #  self.root.register_method(name, callback)
137 137
138 def addMethod( 138 def add_method(
139 self, name, int_suffix, in_sign, out_sign, method, async_=False, doc={} 139 self, name, int_suffix, in_sign, out_sign, method, async_=False, doc={}
140 ): 140 ):
141 """Dynamically add a method to PB Bridge""" 141 """Dynamically add a method to PB bridge"""
142 # FIXME: doc parameter is kept only temporary, the time to remove it from calls 142 # FIXME: doc parameter is kept only temporary, the time to remove it from calls
143 log.debug("Adding method {name} to PB bridge".format(name=name)) 143 log.debug("Adding method {name} to PB bridge".format(name=name))
144 self.register_method(name, method) 144 self.register_method(name, method)
145 145
146 def addSignal(self, name, int_suffix, signature, doc={}): 146 def add_signal(self, name, int_suffix, signature, doc={}):
147 log.debug("Adding signal {name} to PB bridge".format(name=name)) 147 log.debug("Adding signal {name} to PB bridge".format(name=name))
148 setattr( 148 setattr(
149 self, name, lambda *args, **kwargs: self.sendSignal(name, *args, **kwargs) 149 self, name, lambda *args, **kwargs: self.send_signal(name, *args, **kwargs)
150 ) 150 )
151 151
152 def bridgeDeactivateSignals(self): 152 def bridge_deactivate_signals(self):
153 """Stop sending signals to bridge 153 """Stop sending signals to bridge
154 154
155 Mainly used for mobile frontends, when the frontend is paused 155 Mainly used for mobile frontends, when the frontend is paused
156 """ 156 """
157 self.root._bridgeDeactivateSignals() 157 self.root._bridge_deactivate_signals()
158 158
159 def bridgeReactivateSignals(self): 159 def bridge_reactivate_signals(self):
160 """Send again signals to bridge 160 """Send again signals to bridge
161 161
162 Should only be used after bridgeDeactivateSignals has been called 162 Should only be used after bridge_deactivate_signals has been called
163 """ 163 """
164 self.root._bridgeReactivateSignals() 164 self.root._bridge_reactivate_signals()
165 165
166 def _debug(self, action, params, profile): 166 def _debug(self, action, params, profile):
167 self.sendSignal("_debug", action, params, profile) 167 self.send_signal("_debug", action, params, profile)
168 168
169 def actionNew(self, action_data, id, security_limit, profile): 169 def action_new(self, action_data, id, security_limit, profile):
170 self.sendSignal("actionNew", action_data, id, security_limit, profile) 170 self.send_signal("action_new", action_data, id, security_limit, profile)
171 171
172 def connected(self, jid_s, profile): 172 def connected(self, jid_s, profile):
173 self.sendSignal("connected", jid_s, profile) 173 self.send_signal("connected", jid_s, profile)
174 174
175 def contactDeleted(self, entity_jid, profile): 175 def contact_deleted(self, entity_jid, profile):
176 self.sendSignal("contactDeleted", entity_jid, profile) 176 self.send_signal("contact_deleted", entity_jid, profile)
177
178 def contact_new(self, contact_jid, attributes, groups, profile):
179 self.send_signal("contact_new", contact_jid, attributes, groups, profile)
177 180
178 def disconnected(self, profile): 181 def disconnected(self, profile):
179 self.sendSignal("disconnected", profile) 182 self.send_signal("disconnected", profile)
180 183
181 def entityDataUpdated(self, jid, name, value, profile): 184 def entity_data_updated(self, jid, name, value, profile):
182 self.sendSignal("entityDataUpdated", jid, name, value, profile) 185 self.send_signal("entity_data_updated", jid, name, value, profile)
183 186
184 def messageEncryptionStarted(self, to_jid, encryption_data, profile_key): 187 def message_encryption_started(self, to_jid, encryption_data, profile_key):
185 self.sendSignal("messageEncryptionStarted", to_jid, encryption_data, profile_key) 188 self.send_signal("message_encryption_started", to_jid, encryption_data, profile_key)
186 189
187 def messageEncryptionStopped(self, to_jid, encryption_data, profile_key): 190 def message_encryption_stopped(self, to_jid, encryption_data, profile_key):
188 self.sendSignal("messageEncryptionStopped", to_jid, encryption_data, profile_key) 191 self.send_signal("message_encryption_stopped", to_jid, encryption_data, profile_key)
189 192
190 def messageNew(self, uid, timestamp, from_jid, to_jid, message, subject, mess_type, extra, profile): 193 def message_new(self, uid, timestamp, from_jid, to_jid, message, subject, mess_type, extra, profile):
191 self.sendSignal("messageNew", uid, timestamp, from_jid, to_jid, message, subject, mess_type, extra, profile) 194 self.send_signal("message_new", uid, timestamp, from_jid, to_jid, message, subject, mess_type, extra, profile)
192 195
193 def newContact(self, contact_jid, attributes, groups, profile): 196 def param_update(self, name, value, category, profile):
194 self.sendSignal("newContact", contact_jid, attributes, groups, profile) 197 self.send_signal("param_update", name, value, category, profile)
195 198
196 def paramUpdate(self, name, value, category, profile): 199 def presence_update(self, entity_jid, show, priority, statuses, profile):
197 self.sendSignal("paramUpdate", name, value, category, profile) 200 self.send_signal("presence_update", entity_jid, show, priority, statuses, profile)
198 201
199 def presenceUpdate(self, entity_jid, show, priority, statuses, profile): 202 def progress_error(self, id, error, profile):
200 self.sendSignal("presenceUpdate", entity_jid, show, priority, statuses, profile) 203 self.send_signal("progress_error", id, error, profile)
201 204
202 def progressError(self, id, error, profile): 205 def progress_finished(self, id, metadata, profile):
203 self.sendSignal("progressError", id, error, profile) 206 self.send_signal("progress_finished", id, metadata, profile)
204 207
205 def progressFinished(self, id, metadata, profile): 208 def progress_started(self, id, metadata, profile):
206 self.sendSignal("progressFinished", id, metadata, profile) 209 self.send_signal("progress_started", id, metadata, profile)
207
208 def progressStarted(self, id, metadata, profile):
209 self.sendSignal("progressStarted", id, metadata, profile)
210 210
211 def subscribe(self, sub_type, entity_jid, profile): 211 def subscribe(self, sub_type, entity_jid, profile):
212 self.sendSignal("subscribe", sub_type, entity_jid, profile) 212 self.send_signal("subscribe", sub_type, entity_jid, profile)