def connect(self, server): self.server = server self.meteor = MeteorClient('ws://{}/websocket'.format(self.server)) self.meteor.on('connected', self.connected) self.meteor.connect() self.state = 'connecting' self.trigger_event('connecting')
def __init__(self, url, magic_phrase, max_turns=10, callback=None, callback_params=1, msg_q=False): print('starting service') self.start_proba = 1.0 self.magic_phrase = magic_phrase self.url = replace_localhost(url) self.bot = Alice() self.max_turns = max_turns self.sending_message = False self._id = None self.use_msg_q = msg_q # msg_q sets whether or not we are queueing messages self.websocket = 'ws://%s/websocket' % self.url self.client = MeteorClient(self.websocket) self.client.ddp_client.ddpsocket.extra_headers = [('Bot', 'true')] print(self.client.ddp_client.ddpsocket.handshake_headers) self.client.connect() self.idle_time = 3 * 60 self.thread_time = 2 self.max_retry = 3
def __init__(self, username, password, api_key, debug=False, no_meteor=False): self.username = username self.encoded_password = password.encode() if password else None if not no_meteor: self.meteor_client = MeteorClient(SOCKET_BASE, debug=debug) else: self.meteor_client = None self.http = DicecloudHTTP(API_BASE, api_key, debug=debug) self.logged_in = False self.debug = debug
def __init__(self, config): self.config = config self.universes = {} self.fades = {} self.last = 0 self.ready = False self.meteor = MeteorClient(self.config['server']) self.meteor.on('connected', self.connect_cb) self.meteor.connect()
def initMeteorConnect(self): """ this will use library python-meteor in order to escablish session to selected meteor :return: """ self.logm("MWorkerLib:initMeteorConnect:", "meteor python lib client iniciaisation...") self.meteorClient = MeteorClient('ws://127.0.0.1:3000/websocket', auto_reconnect=True) self.meteorClient.connect() self.subscribeCollectionSynchron(['unassigned', 'active', 'trash'], self.SYNCHRO_TIMEOUT) self.logm("MWorkerLib:initMeteorConnect:", "meteor python lib client iniciaisation done...")
def __init__(self, server_url='ws://localhost:3000/websocket', worker=None): self.server_url = server_url self.client = MeteorClient(server_url) self.client.on('subscribed', self.subscribed) self.client.on('unsubscribed', self.unsubscribed) self.client.on('added', self.added) self.client.on('changed', self.changed) self.client.on('removed', self.removed) self.client.on('connected', self.connected) self.client.on('logged_in', self.logged_in) self.client.on('logged_out', self.logged_out) self.worker = worker self.connected = False self.ready = False
def report_sequence_status(fixture_id, cavity, status, progress): lclient = MeteorClient('ws://127.0.0.1:3000/websocket', auto_reconnect=True) try: lclient.connect() except Exception as e: print (e) try: lclient.call('setCavityStatus', [fixture_id, cavity['id'], status, progress], callback_function) except Exception as e: print (e) try: lclient.close() except Exception as e: print (e)
def report_lock_status(fixture_id, lock, status): lclient = MeteorClient('ws://127.0.0.1:3000/websocket', auto_reconnect=True) try: lclient.connect() except Exception as e: print (e) try: lclient.call('setLockStatus', [fixture_id, lock, status], callback_function) except Exception as e: print (e) try: lclient.close() except Exception as e: print (e)
def __init__(self, user, password, server='demo.rocket.chat'): self.username = user self.password = password self.server = server self.debug = True self._prefixs = [] self.client = client = MeteorClient('wss://demo.rocket.chat/websocket') # registering internal handlers self.client.on('connected', self._connected) self.client.on('closed', self._closed) self.client.on('logging_in', self._logging_in) self.client.on('failed', self._failed) self.client.on('added', self._added) self.client.on('changed', self._changed) self.client.on('unsubscribed', self._unsubscribed) self.client.on('subscribed', self._subscribed)
def __init__(self, user, password, server): self.username = user self.password = password self.server = server self.debug = True self._prefixs = [] self.client = client = MeteorClient(server) # registering internal handlers (callbacks) self.client.on('logging_in', self._logging_in) self.client.on('connected', self._connected) self.client.on('closed', self._closed) self.client.on('failed', self._failed) self.client.on('added', self._added) self.client.on('changed', self._changed) self.client.on('unsubscribed', self._unsubscribed) self.client.on('subscribed', self._subscribed) self.messages = []
def __init__(self, username, password, ui): self.username = username self.password = password self.ui = ui self.now = mktime(datetime.now().timetuple())*1e3 self.resume_token = '' self.client = MeteorClient('wss://kwak.io/websocket') self.client.connect() self.client.login(self.username, self.password, token=self.resume_token, callback=self.logged_in) self.hot_channels = [] self.hot_channels_name = [] self.all_channels_name = [] self.current_channel = 'dev' self.client.call('getHotChannels', [], self.set_hot_channels_name) self.client.call('channelList', [], self.set_all_channels_name) self.client.on('connected', self.connected) self.client.on('added', self.added)
def get_new_login(server_url, callback=None): """ queries the server to give a new login""" server_url = replace_localhost(server_url) # connects to the server websocket = 'ws://%s/websocket' % server_url client = MeteorClient(websocket) client.connect() def cb(error, data): client.close() if callback: callback(error, data) # queries the method with a magicphrase client.call('getBotUsername', magic_phrase, cb)
ledcontrol6 = 15 ledname1 = 'First' ledname2 = 'Second' ledname3 = 'Third' ledname4 = 'Forth' ledname5 = 'Fifth' ledname6 = 'Sixth' from MeteorClient import MeteorClient client = MeteorClient('ws://127.0.0.1:3000/websocket') #client = MeteorClient('ws://user-status.meteor.com/websocket') def subscribed(subscription): print('* SUBSCRIBED {}'.format(subscription)) # conn = client.find_one('items', selector={'name': getHwAddr('eth0') }) if subscription == 'local-items': def getHwAddr(ifname): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) info = fcntl.ioctl(s.fileno(), 0x8927, struct.pack('256s', ifname[:15])) return ':'.join(['%02x' % ord(char) for char in info[18:24]]) print getHwAddr('eth0') # new part newmac = getHwAddr('eth0') conn = client.find_one('items', selector={'name': newmac }) print(format(conn))
class DicecloudClient: instance = None user_id = None def __init__(self, username, password, api_key, debug=False, no_meteor=False): self.username = username self.encoded_password = password.encode() if password else None if not no_meteor: self.meteor_client = MeteorClient(SOCKET_BASE, debug=debug) else: self.meteor_client = None self.http = DicecloudHTTP(API_BASE, api_key, debug=debug) self.logged_in = False self.debug = debug def initialize(self): if self.meteor_client is None: log.info(f"Initialized without Meteor.") return log.info(f"Initializing Dicecloud Meteor client (debug={TESTING})") self.meteor_client.connect() loops = 0 while (not self.meteor_client.connected) and loops < 100: time.sleep(0.1) loops += 1 log.info(f"Connected to Dicecloud in {loops/10} seconds") def on_login(error, data): if data: type(self).user_id = data.get('id') self.logged_in = True else: log.warning(error) raise LoginFailure() self.meteor_client.login(self.username, self.encoded_password, callback=on_login) loops = 0 while not self.logged_in and loops < 100: time.sleep(0.1) loops += 1 log.info(f"Logged in as {self.user_id}") def ensure_connected(self): if self.logged_in: # everything is fine:tm: return self.initialize() def _get_list_id(self, character_id, list_name=None): """ :param character: (str) the character to get the spell list ID of. :param list_name: (str) The name of the spell list to look for. Returns default if not passed. :return: (str) The default list id. """ char = self.get_character(character_id) if list_name: spell_list = next((l for l in char.get('spellLists', []) if l['name'].lower() == list_name.lower()), None) else: spell_list = next((l for l in char.get('spellLists', [])), None) if not spell_list: raise InsertFailure("No spell list found on sheet.") return spell_list['_id'] def get_character(self, char_id): return self.http.get(f'/character/{char_id}/json') def add_spell(self, character, spell): """Adds a spell to the dicecloud list.""" return self.add_spells(character, [spell]) def add_spells(self, character_id, spells, spell_list=None): """ :param character_id: (str) The character to add spells for. :param spells: (list) The list of spells to add :param spell_list: (str) The spell list name to search for in Dicecloud. """ list_id = self._get_list_id(character_id, spell_list) if not list_id: # still raise InsertFailure("No matching spell lists on origin sheet.") return self.http.post( f'/api/character/{character_id}/spellList/{list_id}', [s.to_dict() for s in spells]) def create_character(self, name: str = "New Character", gender: str = None, race: str = None, backstory: str = None): data = {'name': name} if gender is not None: data['gender'] = gender if race is not None: data['race'] = race if backstory is not None: data['backstory'] = backstory data['settings'] = {'viewPermission': 'public'} # sharing is caring! response = self.http.post('/api/character', data) return response['id'] def delete_character(self, char_id: str): self.http.delete(f'/api/character/{char_id}') def get_user_id(self, username: str): username = urllib.parse.quote_plus(username) user_id = self.http.get(f'/api/user?username={username}') return user_id['id'] def transfer_ownership(self, char_id: str, user_id: str): self.http.put(f'/api/character/{char_id}/owner', {'id': user_id}) def insert_feature(self, char_id, feature): return (self.insert_features(char_id, [feature]))[0] def insert_features(self, char_id: str, features: list): response = self.http.post(f'/api/character/{char_id}/feature', [f.to_dict() for f in features]) return response def insert_proficiency(self, char_id, prof): return (self.insert_proficiencies(char_id, [prof]))[0] def insert_proficiencies(self, char_id: str, profs: list): response = self.http.post(f'/api/character/{char_id}/prof', [p.to_dict() for p in profs]) return response def insert_effect(self, char_id, effect): return (self.insert_effects(char_id, [effect]))[0] def insert_effects(self, char_id: str, effects: list): response = self.http.post(f'/api/character/{char_id}/effect', [e.to_dict() for e in effects]) return response def insert_class(self, char_id, klass): return (self.insert_classes(char_id, [klass]))[0] def insert_classes(self, char_id: str, classes: list): response = self.http.post(f'/api/character/{char_id}/class', [c.to_dict() for c in classes]) return response
#!/usr/bin/env python """ Check to see if an process is running. If not, restart. Run this in a cron job """ import os import sys import time import fcntl, socket, struct from MeteorClient import MeteorClient # client = MeteorClient('ws://127.0.0.1:3030/websocket') client = MeteorClient('ws://127.0.0.1:3000/websocket') process_name = "/root/smartag-python.py" # change this to the name of your process #process_name= "meteor_run.sh" # process_name= "/home/atanas/MeteorProjects/iot/serverstate.py" def getHwAddr(ifname): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) info = fcntl.ioctl(s.fileno(), 0x8927, struct.pack('256s', ifname[:15])) return ':'.join(['%02x' % ord(char) for char in info[18:24]]) print getHwAddr('eth0') # new part newmac = getHwAddr('eth0') client.connect() tmp = os.popen("ps -Af").read() print tmp[:] if process_name in tmp[:]: print "LOCAL SERVER RUNNING" print process_name
mc.subscribe("buttons", callback=mcSubscribeCallback) mc.subscribe("screensets", callback=mcSubscribeCallback) mc.subscribe("organisations", callback=mcSubscribeCallback) print("{}: Subscribied".format(nicetime(time.time()))) event.set() return True except Exception as ex: print( "mcLoggedIn. Already subscribed, exception type {}, exception: {}". format(type(ex), ex.args)) return False if __name__ == '__main__': meteor_websocket = "ws://staging.spur.site/websocket" mc = MeteorClient(meteor_websocket) mc.on('connected', mcConnected) mc.on('logging_in', mcLoggingIn) mc.on('logged_in', mcLoggedIn) mc.on('logged_out', mcLoggedOut) mc.on('failed', mcFailed) mc.on('closed', mcClosed) mc.on('subscribed', mcSubscribed) mc.on('added', mcAdded) mc.on('changed', mcChanged) mc.on('removed', mcRemoved) print("{}: Connecting".format(nicetime(time.time()))) event = threading.Event() mc.connect() subscribe() event.wait()
class AoikRocketChatErrbot(ErrBot): """ Errbot backend for Rocket.Chat. The backend logs in as a Rocket.Chat user, receiving and sending messages. """ def __init__(self, config): """ Constructor. :param config: Errbot's config module. :return: None. """ # Call super method super(AoikRocketChatErrbot, self).__init__(config) # Get the backend's config object self._config_obj = getattr(self.bot_config, _CONFIG_OBJ_KEY, None) # Get logging level from env variable or config object log_level = orig_log_level = self._get_config( CONFIG_KEYS.BOT_LOG_LEVEL, None) # If not specified if log_level is None: # Get logging level from config module log_level = orig_log_level = getattr(self.bot_config, CONFIG_KEYS.BOT_LOG_LEVEL, None) # If not specified if log_level is None: # Use default log_level = logging.DEBUG # If the logging level is string, e.g. 'DEBUG'. # This means it may be an attribute name of the `logging` module. if isinstance(log_level, str): # Get attribute value from the `logging` module log_level = getattr(logging, log_level, None) # Error message error_msg = None # If the logging level is not int if not isinstance(log_level, int): # Get message error_msg = 'Config `BOT_LOG_LEVEL` value is invalid: {}'.format( repr(orig_log_level)) # Log message self._log_error(error_msg) # Raise error raise ValueError(error_msg) # Get logger self._logger = logging.getLogger('aoikrocketchaterrbot') # Set logging level self._logger.setLevel(log_level) # Get message msg = '# ----- Created logger -----\nBOT_LOG_LEVEL: {}'.format( log_level) # Log message self._logger.debug(msg) # Get rocket chat server URI self._server_uri = self._get_config(CONFIG_KEYS.SERVER_URI) # If server URI is not specified if self._server_uri is None: # Get message error_msg = 'Missing config `SERVER_URI`.' # Log message self._log_error(error_msg) # Raise error raise ValueError(error_msg) # Get login username self._login_username = self._get_config(CONFIG_KEYS.LOGIN_USERNAME) # If login username is not specified if self._login_username is None: # Get message error_msg = 'Missing config `LOGIN_USERNAME`.' # Log message self._log_error(error_msg) # Raise error raise ValueError(error_msg) # Get login password self._login_password = self._get_config(CONFIG_KEYS.LOGIN_PASSWORD) # If login password is not specified if self._login_password is None: # Get message error_msg = 'Missing config `LOGIN_PASSWORD`.' # Log message self._log_error(error_msg) # Raise error raise ValueError(error_msg) # If login password is not bytes if not isinstance(self._login_password, bytes): # Convert login password to bytes self._login_password = bytes(self._login_password, 'utf-8') # Create login user's identifier object. # # This attribute is required by superclass. # self.bot_identifier = self.build_identifier(self._login_username) # Event set when the the meteor client has done topic subscribing. # # When the event is set, the meteor client is in one of the two states: # - The topic subscribing has succeeded and the meteor client has # started handling messages. # - The topic subscribing has failed and the meteor client has been # closed. # # The rationale is that the loop at 65ZNO uses the meteor client's # `connected` attribute to decide whether continue, and the attribute # value is ready for use only after this event is set. self._subscribing_done_event = Event() # Event set when the meteor client calls the `closed` callback at # 3DMYH. # # The rationale is that the main thread code at 5W6XQ has to wait until # the meteor client is closed and the `closed` callback hooked at 7MOJX # is called. This ensures the cleanup is fully done. # self._meteor_closed_event = Event() @property def mode(self): """ Get mode name. :return: Mode name. """ # Return mode name return 'aoikrocketchaterrbot' def _log_debug(self, msg): """ Log debug message. :param msg: Message to log. :return: None. """ # Log the message self._logger.debug(msg) def __hash__(self): """Bots are now stored as a key in the bot so they need to be hashable.""" return id(self) def _log_error(self, msg): """ Log error message. :param msg: Message to log. :return: None. """ # Log the message self._logger.error(msg) def _get_config(self, key, default=None): """ Get config value from env variable or config object. Env variable takes precedence. :param key: Config key. :param default: Default value. :return: Config value. """ # Get env variable name env_var_name = _ENV_VAR_NAME_PREFIX + key # Get config value from env variable config_value = os.environ.get(env_var_name, None) # If not specified if config_value is None: # If not have config object if self._config_obj is None: # Use default config_value = default # If have config object else: # Get config value from config object config_value = getattr(self._config_obj, key, default) # Return config value return config_value def _get_bool_config(self, key, default=None): """ Get boolean config value from env variable or config object. Env variable takes precedence. :param key: Config key. :param default: Default value. :return: Config value. """ # Get config value config_value = self._get_config(key=key, default=default) # If config value is false. # This aims to handle False, 0, and None. if not config_value: # Return False return False # If config value is not false else: # Get config value's string in lower case config_value_str_lower = str(config_value).lower() # Consider '0', case-insensitive 'false' and 'no' as false, # otherwise as true. return config_value_str_lower not in ['0', 'false', 'no'] def _patch_meteor_client(self): """ Patch meteor client to fix an existing bug. :return: None. """ # Get whether need patch meteor client. Default is True. need_patch = self._get_bool_config(CONFIG_KEYS.PATCH_METEOR_CLIENT, True) # If need patch meteor client if need_patch: # Create `change_data` function def change_data(self, collection, id, fields, cleared): """ Callback called when data change occurred. :param self: CollectionData object. :param collection: Data collection key. :param id: Data item key. :param fields: Data fields changed. :param cleared: Data fields to be cleared. :return None. """ # If the data collection key not exists # # The original `change_data` function assumes it is existing, # but it is not in some cases. # if collection not in self.data: # Add data collection self.data[collection] = {} # If the data item key not exists. # # The original `change_data` function assumes it is existing, # but it is not in some cases. # if id not in self.data[collection]: # Add data item self.data[collection][id] = {} # For each data field changed for key, value in fields.items(): # Add to the data item self.data[collection][id][key] = value # For each data field to be cleared for key in cleared: # Delete from the data item del self.data[collection][id][key] # Store original `change_data`. # # pylint: disable=protected-access CollectionData._orig_change_data = CollectionData.change_data # pylint: enable=protected-access # Replace original `change_data` CollectionData.change_data = change_data def build_identifier(self, username): """ Create identifier object for given username. :param username: Rocket chat user name. :return: RocketChatUser instance. """ # Create identifier object return RocketChatUser(username) def serve_forever(self): """ Run the bot. Called by the Errbot framework. :return: None. """ # Log message self._log_debug('# ----- serve_forever -----') # Patch meteor client self._patch_meteor_client() # Get whether reconnect is enabled reconnect_enabled = self._get_bool_config( CONFIG_KEYS.RECONNECT_ENABLED, default=True, ) try: # Loop while True: try: # Run for once self.serve_once() # If have error except Exception: # Log message self._log_error(('# ----- `serve_once` failed with error' ' -----\n{}').format(format_exc())) # If reconnect is enabled if reconnect_enabled: # Get message msg = ('# ----- Sleep before reconnect -----\n' 'Interval: {:.2f}').format(self._reconnection_delay) # Log message self._log_debug(msg) # Sleep before reconnect self._delay_reconnect() # Log message self._log_debug('# ----- Wake up to reconnect -----') # Continue the loop continue # If reconnect is not enabled else: # Break the loop break # If have `KeyboardInterrupt` except KeyboardInterrupt: # Do not treat as error pass # Always do finally: # Call `shutdown` self.shutdown() # Log message self._log_debug('# ===== serve_forever =====') def serve_once(self): """ Run the bot until the connection is disconnected. :return: None. """ # Log message self._log_debug('# ----- serve_once -----') # Log message self._log_debug(('# ----- Create meteor client -----\n' 'SERVER_URI: {}').format(self._server_uri)) # Create meteor client self._meteor_client = MeteorClient( self._server_uri, # Disable the meteor client's auto reconnect. # Let `serve_forever` handle reconnect. auto_reconnect=False, ) # Log message self._log_debug('# ----- Hook meteor client callbacks -----') # 5DI82 # Hook meteor client `connected` callback self._meteor_client.on('connected', self._meteor_connected_callback) # 2RAYF # Hook meteor client `changed` callback self._meteor_client.on('changed', self._meteor_changed_callback) # 4XIZB # Hook meteor client `added` callback self._meteor_client.on('added', self._meteor_added_callback) # 2JEIK # Hook meteor client `removed` callback self._meteor_client.on('removed', self._meteor_removed_callback) # 32TF2 # Hook meteor client `failed` callback self._meteor_client.on('failed', self._meteor_failed_callback) # 5W6RX # Hook meteor client `reconnected` callback self._meteor_client.on('reconnected', self._meteor_reconnected_callback) # 7MOJX # Hook meteor client `closed` callback self._meteor_client.on('closed', self._meteor_closed_callback) # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Log message self._log_debug('# ----- Connect to meteor server -----') try: # Connect to meteor server. # # If the connecting succeeds, the meteor client's thread will call # `self._meteor_connected_callback` hooked at 5DI82. The login, # topic subscribing, and message handling are run in that thread. # # The main thread merely waits until the meteor client is closed, # meanwhile it calls heartbeat function at interval if specified. # self._meteor_client.connect() # If have error except: # Log message self._log_debug('# ----- Connecting failed -----') # Log message self._log_debug('# ----- Unhook meteor client callbacks -----') # Remove meteor client callbacks self._meteor_client.remove_all_listeners() # Remove meteor client reference self._meteor_client = None # The two events below should not have been set if the connecting # failed. Just in case. # # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Raise the error raise # Get whether heartbeat is enabled heartbeat_enabled = self._get_bool_config( CONFIG_KEYS.HEARTBEAT_ENABLED) try: # Wait until the topic subscribing is done in another thread at # 5MS7A self._subscribing_done_event.wait() # If heartbeat is enabled if heartbeat_enabled: # Get heartbeat function heartbeat_func = self._get_config(CONFIG_KEYS.HEARTBEAT_FUNC) # Assert the function is callable assert callable(heartbeat_func), repr(heartbeat_func) # Get heartbeat interval heartbeat_interval = self._get_config( CONFIG_KEYS.HEARTBEAT_INTERVAL, default=10, ) # Convert heartbeat interval to float heartbeat_interval = float(heartbeat_interval) # 65ZNO # Loop until the meteor client is disconnected while self._meteor_client.connected: # Send heartbeat heartbeat_func(self) # Sleep before sending next heartbeat time.sleep(heartbeat_interval) # 5W6XQ # Wait until the meteor client is closed and the `closed` callback # is called at 3DMYH self._meteor_closed_event.wait() # If have error except: # Close meteor client. # # This will cause `self._meteor_closed_callback` to be called, # which will set the `self._meteor_closed_event` below. # self._meteor_client.close() # See 5W6XQ self._meteor_closed_event.wait() # Raise the error raise # Always do finally: # Log message self._log_debug('# ----- Unhook meteor client callbacks -----') # Remove meteor client callbacks self._meteor_client.remove_all_listeners() # Remove meteor client reference. # # Do this before calling `callback_presence` below so that the # plugins will not be able to access the already closed client. # self._meteor_client = None # Log message self._log_debug('# ----- Call `callback_presence` -----') # Call `callback_presence` self.callback_presence( Presence(identifier=self.bot_identifier, status=OFFLINE)) # Log message self._log_debug('# ----- Call `disconnect_callback` -----') # Call `disconnect_callback` to unload plugins self.disconnect_callback() # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Log message self._log_debug('# ===== serve_once =====') def _meteor_connected_callback(self): """ Callback called when the meteor client is connected. Hooked at 5DI82. :return: None. """ # Log message self._log_debug('# ----- _meteor_connected_callback -----') # Log message self._log_debug( '# ----- Log in to meteor server -----\nUser: {}'.format( self._login_username)) # Log in to meteor server self._meteor_client.login( user=self._login_username, password=self._login_password, # 2I0GP callback=self._meteor_login_callback, ) def _meteor_login_callback(self, error_info, success_info): """ Callback called when the meteor client has succeeded or failed login. Hooked at 2I0GP. :param error_info: Error info. :param success_info: Success info. :return: None. """ # Log message self._log_debug('# ----- _meteor_login_callback -----') # If have error info if error_info is not None: # Get message msg = 'Login failed:\n{}'.format(pformat(error_info, width=1)) # Log message self._log_debug(msg) # Close meteor client. # This will cause `_meteor_closed_callback` be called. self._meteor_client.close() # If not have error info else: # Get message msg = 'Login succeeded:\n{}'.format(pformat(success_info, width=1)) # Log message self._log_debug(msg) # Subscribe to message events self._meteor_client.subscribe( # Topic name name='stream-room-messages', params=[ # All messages from rooms the rocket chat user has joined '__my_messages__', False, ], # 6BKIR callback=self._meteor_subscribe_callback, ) def _meteor_subscribe_callback(self, error_info): """ Callback called when the meteor client has succeeded or failed \ subscribing. Hooked at 6BKIR. :param error_info: Error info. :return: None. """ # Log message self._log_debug('# ----- _meteor_subscribe_callback -----') # If have error info if error_info is not None: # Get message msg = 'Subscribing failed:\n{}'.format(pformat(error_info, width=1)) # Log message self._log_debug(msg) # Close meteor client. # This will cause `self._meteor_closed_callback` to be called. self._meteor_client.close() # If not have error info else: # Log message self._log_debug('Subscribing succeeded.') # Log message self._log_debug('# ----- Call `connect_callback` -----') # Call `connect_callback` to load plugins. # # This is called in meteor client's thread. # Plugins should not assume they are loaded from the main thread. # self.connect_callback() # Log message self._log_debug('# ----- Call `callback_presence` -----') # Call `callback_presence` self.callback_presence( Presence(identifier=self.bot_identifier, status=ONLINE)) # Log message self._log_debug( '# ----- Hook callback `_meteor_changed_callback` -----') # Reset reconnection count self.reset_reconnection_count() # 5MS7A # Set the topic subscribing is done self._subscribing_done_event.set() def _meteor_changed_callback(self, collection, id, fields, cleared): """ Callback called when the meteor client received message. Hooked at 2RAYF. :param collection: Data collection key. :param id: Data item key. :param fields: Data fields changed. :param cleared: Data fields to be cleared. :return: None. """ # If is message event if collection == 'stream-room-messages': # Get `args` value args = fields.get('args', None) # If `args` value is list if isinstance(args, list): # For each message info for msg_info in args: # Get message msg = msg_info.get('msg', None) # If have message if msg is not None: # Get sender info sender_info = msg_info['u'] # Get sender username sender_username = sender_info['username'] # If the sender is not the bot itself if sender_username != self._login_username: # Create sender's identifier object sender_identifier = self.build_identifier( sender_username) # Create extras info extras = { # 2QTGO 'msg_info': msg_info, } # Create received message object msg_obj = Message( body=msg, frm=sender_identifier, to=self.bot_identifier, extras=extras, ) # Log message self._log_debug( '# ----- Call `callback_message` -----') # Call `callback_message` to dispatch the message # to plugins self.callback_message(msg_obj) def _meteor_added_callback(self, collection, id, fields): """ Callback called when the meteor client emits `added` event. Hooked at 4XIZB. :param collection: Data collection key. :param id: Data item key. :param fields: Data fields. :return: None. """ # Log message self._log_debug('# ----- _meteor_added_callback -----') def _meteor_removed_callback(self, collection, id): """ Callback called when the meteor client emits `removed` event. Hooked at 2JEIK. :param collection: Data collection key. :param id: Data item key. :return: None. """ # Log message self._log_debug('# ----- _meteor_removed_callback -----') def _meteor_failed_callback(self): """ Callback called when the meteor client emits `failed` event. Hooked at 32TF2. :return: None. """ # Log message self._log_debug('# ----- _meteor_failed_callback -----') def _meteor_reconnected_callback(self): """ Callback called when the meteor client emits `reconnected` event. Hooked at 5W6RX. :return: None. """ # Log message self._log_debug('# ----- _meteor_reconnected_callback -----') def _meteor_closed_callback(self, code, reason): """ Callback called when the meteor client emits `closed` event. Hooked at 7MOJX. :param code: Close code. :param reason: Close reason. :return: None. """ # Log message self._log_debug( '# ----- _meteor_closed_callback -----\nCode: {}\nReason: {}'. format(code, reason)) # Set the topic subscribing is done self._subscribing_done_event.set() # 3DMYH # Set the meteor client's `closed` event is emitted self._meteor_closed_event.set() def build_reply(self, mess, text=None, private=False, threaded=False): """ Create reply message object. Used by `self.send_simple_reply`. :param mess: The original message object. :param text: Reply message text. :param private: Whether the reply message is private. :return: Message object. """ # Create reply message object reply = Message( body=text, frm=mess.to, to=mess.frm, extras={ # 5QXGV # Store the original message object 'orig_msg': mess }) # Return reply message object return reply def prefix_groupchat_reply(self, message, identifier): """ Add group chat prefix to the message. Used by `self.send` and `self.send_simple_reply`. :param message: Message object to send. :param identifier: The message receiver's identifier object. :return: None. """ # Do nothing def send_rocketchat_message(self, params): """ Send message to meteor server. :param params: RPC method `sendMessage`'s parameters. :return: None. """ # If argument `params` is not list if not isinstance(params, list): # Put it in a list params = [params] # Send message to meteor server self._meteor_client.call( method='sendMessage', params=params, ) def send_message(self, mess): """ Send message to meteor server. Used by `self.split_and_send_message`. `self.split_and_send_message` is used by `self.send` and `self.send_simple_reply`. :param mess: Message object to send. :return: None. """ # Call super method to dispatch to plugins super(AoikRocketChatErrbot, self).send_message(mess) # Get original message object. # # The key is set at 5QXGV and 3YRCT. # orig_msg = mess.extras['orig_msg'] # Get original message info. # # The key is set at 2QTGO # msg_info = orig_msg.extras['msg_info'] # Get room ID room_id = msg_info['rid'] # Send message to meteor server self.send_rocketchat_message(params={ 'rid': room_id, 'msg': mess.body, }) def send( self, identifier, text, in_reply_to=None, groupchat_nick_reply=False, ): """ Send message to meteor server. :param identifier: Receiver's identifier object. :param text: Message text to send. :param in_reply_to: Original message object. :param groupchat_nick_reply: Whether the message to send is group chat. `self.prefix_groupchat_reply` will be called to process the message if it is group chat. :return: None. """ # If the identifier object is not Identifier instance if not isinstance(identifier, Identifier): # Get message error_msg = ( 'Argument `identifier` is not Identifier instance: {}').format( repr(identifier)) # Raise error raise ValueError(error_msg) # If the original message is not given if in_reply_to is None: # Get message error_msg = 'Argument `in_reply_to` must be given.' # Raise error raise ValueError(error_msg) # Create message object msg_obj = Message( body=text, frm=in_reply_to.to, to=identifier, extras={ # 3YRCT # Store the original message object 'orig_msg': in_reply_to, }, ) # Get group chat prefix from config group_chat_prefix = self.bot_config.GROUPCHAT_NICK_PREFIXED # If the receiver is a room if isinstance(identifier, Room): # If have group chat prefix, # or the message is group chat. if group_chat_prefix or groupchat_nick_reply: # Call `prefix_groupchat_reply` to process the message self.prefix_groupchat_reply(msg_obj, in_reply_to.frm) # Send the message self.split_and_send_message(msg_obj) def query_room(self, room): """ Query room info. Not implemented. :param room: Room ID. :return: None. """ # Return None return None def rooms(self): """ Get room list. Not implemented. :return: Empty list. """ # Return empty list return [] def change_presence(self, status=ONLINE, message=''): """
def insert_callback(error, data): if error: print(error) return print(data) def callback_function(error, result): print("callback") if error: print(error) return print(result) client = MeteorClient("ws://127.0.0.1:3000/websocket") client.on("connected", connected) client.on("failed", failed) client.connect() timestamp = str(datetime.now()) lat = 1.2956 lng = 103.7767 speed = 50 bearing = 50 altitude = 50 client.insert( "Telemetry",
ledcontrol2 = 16 ledcontrol3 = 18 ledcontrol4 = 22 ledcontrol5 = 11 ledcontrol6 = 15 ledname1 = 'First' ledname2 = 'Second' ledname3 = 'Third' ledname4 = 'Forth' ledname5 = 'Fifth' ledname6 = 'Sixth' from MeteorClient import MeteorClient client = MeteorClient('ws://127.0.0.1:3000/websocket') # client = MeteorClient('ws://testddp.meteor.com/websocket') def subscribed(subscription): print('* SUBSCRIBED {}'.format(subscription)) # conn = client.find_one('items', selector={'name': getHwAddr('eth0') }) # if subscription == 'local-items': # def getHwAddr(ifname): # s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # info = fcntl.ioctl(s.fileno(), 0x8927, struct.pack('256s', ifname[:15])) # return ':'.join(['%02x' % ord(char) for char in info[18:24]]) # print getHwAddr('eth0') # # new part # newmac = getHwAddr('eth0') # conn = client.find_one('items', selector={'name': newmac })
class DDP(Thread): def __init__(self): Thread.__init__(self) self.meteor = conf.get('ddp', 'meteor') self.client = MeteorClient(self.meteor, debug=False) self.client.on('added', self.on_added) self.client.on('changed', self.on_changed) self.client.on('subscribed', self.on_subscribed) self.client.on('connected', self.on_connected) self.client.on('removed', self.on_removed) self.client.on('closed', self.on_closed) self.client.on('logged_in', self.on_logged_in) self.displayName = conf.get('sussexlogin', 'room_name') self.vu_min = -70 self.vu_range = 40 self.do_vu = 0 self.last_vu = None self.ip = socket.gethostbyname(socket.gethostname()) self.id = conf.get('ingest', 'hostname') self._user = conf.get('ddp', 'user') self._password = conf.get('ddp', 'password') self._http_host = conf.get('ddp', 'http_host') self._audiostream_port = conf.get('audiostream', 'port') or 31337 self.netreg_id = conf.get('ddp', 'netreg_id') self.store_audio = conf.get_boolean('ddp', 'store_audio') self.paused = False self.recording = False self.currentMediaPackage = None self.currentProfile = None self.has_disconnected = False cam_available = conf.get('sussexlogin', 'cam_available') or cam_available if cam_available in ('True', 'true', True, '1', 1): self.cam_available = 1 elif cam_available in ('False', 'false', False, '0', 0): self.cam_available = 0 else: self.cam_available = int(cam_available) self.audiofaders = [] faders = conf.get('ddp', 'audiofaders').split() for fader in faders: audiofader = {} fader = 'audiofader-' + fader audiofader['name'] = conf.get(fader, 'name') audiofader['display'] = conf.get(fader, 'display') audiofader['min'] = conf.get_int(fader, 'min') audiofader['max'] = conf.get_int(fader, 'max') audiofader['type'] = conf.get(fader, 'type') audiofader['setrec'] = conf.get_boolean(fader, 'setrec') audiofader['mute'] = conf.get_boolean(fader, 'mute') audiofader['unmute'] = conf.get_boolean(fader, 'unmute') audiofader['setlevel'] = conf.get_int(fader, 'setlevel') try: audiofader['control'] = alsaaudio.Mixer( control=audiofader['name']) self.audiofaders.append(audiofader) except Exception as e: logger.warn(e) fd, eventmask = self.audiofaders[0]['control'].polldescriptors()[0] self.watchid = gobject.io_add_watch(fd, eventmask, self.mixer_changed) dispatcher.connect('galicaster-init', self.on_init) dispatcher.connect('update-rec-vumeter', self.vumeter) dispatcher.connect('galicaster-notify-timer-short', self.heartbeat) dispatcher.connect('start-before', self.on_start_recording) dispatcher.connect('restart-preview', self.on_stop_recording) dispatcher.connect('update-rec-status', self.on_rec_status_update) def run(self): self.connect() def connect(self): if not self.has_disconnected: try: self.client.connect() except Exception: logger.warn('DDP connection failed') def update(self, collection, query, update): if self.client.connected and self.subscribedTo('GalicasterControl'): try: self.client.update(collection, query, update, callback=self.update_callback) except Exception: logger.warn("Error updating document " "{collection: %s, query: %s, update: %s}" % (collection, query, update)) def insert(self, collection, document): if self.client.connected and self.subscribedTo('GalicasterControl'): try: self.client.insert(collection, document, callback=self.insert_callback) except Exception: logger.warn( "Error inserting document {collection: %s, document: %s}" % (collection, document)) def heartbeat(self, element): if self.client.connected: self.update_images() else: self.connect() def on_start_recording(self, sender, id): self.recording = True self.currentMediaPackage = self.media_package_metadata(id) self.currentProfile = context.get_state().profile.name self.update('rooms', {'_id': self.id}, { '$set': { 'currentMediaPackage': self.currentMediaPackage, 'currentProfile': self.currentProfile, 'recording': self.recording } }) def on_stop_recording(self, sender=None): self.recording = False self.currentMediaPackage = None self.currentProfile = None self.update('rooms', {'_id': self.id}, { '$unset': { 'currentMediaPackage': '', 'currentProfile': '' }, '$set': { 'recording': self.recording } }) self.update_images(1.5) def on_init(self, data): self.update_images(1.5) def update_images(self, delay=0): worker = Thread(target=self._update_images, args=(delay, )) worker.start() def _update_images(self, delay): time.sleep(delay) files = {} audio_devices = ['audiotest', 'autoaudio', 'pulse'] for track in context.get_state().profile.tracks: if track.device not in audio_devices: file = os.path.join('/tmp', track.file + '.jpg') try: if (os.path.getctime(file) > time.time() - 3): files[track.flavor] = (track.flavor + '.jpg', open(file, 'rb'), 'image/jpeg') except Exception: logger.warn("Unable to check date of or open file (%s)" % file) im = ImageGrab.grab(bbox=(10, 10, 1280, 720), backend='imagemagick') im.thumbnail((640, 360)) output = cStringIO.StringIO() if im.mode != "RGB": im = im.convert("RGB") im.save(output, format="JPEG") files['galicaster'] = ('galicaster.jpg', output.getvalue(), 'image/jpeg') try: # add verify=False for testing self signed certs requests.post("%s/image/%s" % (self._http_host, self.id), files=files, auth=(self._user, self._password)) except Exception: logger.warn('Unable to post images') def mixer_changed(self, source=None, condition=None, reopen=True): if reopen: for audiofader in self.audiofaders: audiofader['control'] = alsaaudio.Mixer( control=audiofader['name']) self.update_audio() return True def vumeter(self, element, data): if self.do_vu == 0: if data == "Inf": data = 0 else: if data < -self.vu_range: data = -self.vu_range elif data > 0: data = 0 data = int(((data + self.vu_range) / float(self.vu_range)) * 100) if data != self.last_vu: update = {'vumeter': data} self.update('rooms', {'_id': self.id}, {'$set': update}) self.last_vu = data self.do_vu = (self.do_vu + 1) % 20 def on_rec_status_update(self, element, data): is_paused = data == 'Paused' if is_paused: self.update_images(.75) if self.paused != is_paused: self.update('rooms', {'_id': self.id}, {'$set': { 'paused': is_paused }}) self.paused = is_paused if data == ' Recording ': subprocess.call(['killall', 'maliit-server']) self.update_images(.75) def media_package_metadata(self, id): mp = context.get_repository().get(id) line = mp.metadata_episode.copy() duration = mp.getDuration() line["duration"] = long(duration / 1000) if duration else None # Does series_title need sanitising as well as duration? created = mp.getDate() line["created"] = calendar.timegm(created.utctimetuple()) for key, value in mp.metadata_series.iteritems(): line["series_" + key] = value for key, value in line.iteritems(): if value in [None, []]: line[key] = '' return line def subscription_callback(self, error): if error: logger.warn("Subscription callback returned error: %s" % error) def insert_callback(self, error, data): if error: logger.warn("Insert callback returned error: %s" % error) def update_callback(self, error, data): if error: logger.warn("Update callback returned error: %s" % error) def on_subscribed(self, subscription): if (subscription == 'GalicasterControl'): me = self.client.find_one('rooms') stream_key = uuid.uuid4().get_hex() # Data to push when inserting or updating data = { 'displayName': self.displayName, 'ip': self.ip, 'paused': self.paused, 'recording': self.recording, 'heartbeat': int(time.time()), 'camAvailable': self.cam_available, 'netregId': self.netreg_id, 'inputs': self.inputs(), 'stream': { 'port': self._audiostream_port, 'key': stream_key }, 'galicasterVersion': galicaster.__version__ } if self.currentMediaPackage: data['currentMediaPackage'] = self.currentMediaPackage if self.currentProfile: data['currentProfile'] = self.currentProfile if me: # Items to unset unset = {} if not self.currentMediaPackage: unset['currentMediaPackage'] = '' if not self.currentProfile: unset['currentProfile'] = '' # Update to push update = {'$set': data} if unset: update['$unset'] = unset self.update('rooms', {'_id': self.id}, update) else: audio = self.read_audio_settings() data['_id'] = self.id data['audio'] = audio self.insert('rooms', data) def inputs(self): inputs = {'presentations': ['Presentation']} inputs['cameras'] = [] labels = conf.get('sussexlogin', 'matrix_cam_labels') cam_labels = [] if labels: cam_labels = [l.strip() for l in labels.split(',')] for i in range(0, self.cam_available): label = cam_labels[i] if i < len(cam_labels) else "Camera %d" % ( i + 1) inputs['cameras'].append(label) return inputs def set_audio(self, fields): faders = fields.get('audio') if faders: for fader in faders: mixer = None level = fader.get('level') for audiofader in self.audiofaders: if audiofader['name'] == fader['name']: mixer = audiofader['control'] break if mixer: l, r = mixer.getvolume(fader['type']) if level >= 0 and l != level: mixer.setvolume(level, 0, fader['type']) mixer.setvolume(level, 1, fader['type']) if self.store_audio: # Relies on no password sudo access for current user to alsactl subprocess.call(['sudo', 'alsactl', 'store']) def on_added(self, collection, id, fields): self.set_audio(fields) self.update_audio() def on_changed(self, collection, id, fields, cleared): self.set_audio(fields) me = self.client.find_one('rooms') if self.paused != me['paused']: self.set_paused(me['paused']) if context.get_state().is_recording != me['recording']: self.set_recording(me) def on_removed(self, collection, id): self.on_subscribed(None) def set_paused(self, new_status): self.paused = new_status dispatcher.emit("toggle-pause-rec") def set_recording(self, me): self.recording = me['recording'] if self.recording: meta = me.get('currentMediaPackage', {}) or {} profile = me.get('currentProfile', 'nocam') series = (meta.get('series_title', ''), meta.get('isPartOf', '')) user = { 'user_name': meta.get('creator', ''), 'user_id': meta.get('rightsHolder', '') } title = meta.get('title', 'Unknown') dispatcher.emit('sussexlogin-record', (user, title, series, profile)) else: dispatcher.emit("stop-record", '') def on_connected(self): logger.info('Connected to Meteor') token = conf.get('ddp', 'token') self.client.login(self._user, self._password, token=token) def on_logged_in(self, data): conf.set('ddp', 'token', data['token']) conf.update() try: self.client.subscribe('GalicasterControl', params=[self.id], callback=self.subscription_callback) except Exception: logger.warn('DDP subscription failed') def on_closed(self, code, reason): self.has_disconnected = True logger.error('Disconnected from Meteor: err %d - %s' % (code, reason)) def update_audio(self): me = self.client.find_one('rooms') audio = self.read_audio_settings() update = False if me: mAudio = me.get('audio') mAudioNames = [x['name'] for x in mAudio] audioNames = [x['name'] for x in audio] if set(mAudioNames) != set(audioNames): update = True if not update: for key, fader in enumerate(audio): if mAudio[key].get('level') != fader.get('level'): update = True if update: self.update('rooms', {'_id': self.id}, {'$set': { 'audio': audio }}) def read_audio_settings(self): audio_settings = [] for audiofader in self.audiofaders: if audiofader['display']: audio_settings.append(self.control_values(audiofader)) # ensure fixed values mixer = audiofader['control'] if audiofader['setrec']: mixer.setrec(1) if audiofader['mute']: mixer.setmute(1) if audiofader['unmute']: mixer.setmute(0) if audiofader['setlevel'] >= 0: mixer.setvolume(audiofader['setlevel'], 0, audiofader['type']) if 'Joined Playback Volume' not in mixer.volumecap(): mixer.setvolume(audiofader['setlevel'], 1, audiofader['type']) return audio_settings def control_values(self, audiofader): controls = {} left, right = audiofader['control'].getvolume(audiofader['type']) controls['min'] = audiofader['min'] controls['max'] = audiofader['max'] controls['level'] = left controls['type'] = audiofader['type'] controls['name'] = audiofader['name'] controls['display'] = audiofader['display'] return controls def subscribedTo(self, publication): return self.client.subscriptions.get(publication) is not None
msg['short_summary'] = "Not available" msg['topics'] = "Not available" logging.debug("Updating Edits with message %s", msg) client.insert('edits', msg) #--------------------------------------------------------# # Main # #--------------------------------------------------------# if __name__ == "__main__": # Connect to meteor server ws = "ws://ddp--8162-wikiedits.meteor.com/websocket" #ws = "ws://127.0.0.1:3000/websocket" logging.info("Connecting to meteor server") client = MeteorClient(ws, auto_reconnect=True, auto_reconnect_timeout=10) client.connect() client.subscribe('piedata') client.subscribe('edits') client.subscribe('bardata') logging.info("Connected") logging.info("Starting IRC server") # Start Wikipedia bot server = 'irc.wikimedia.org' port = 6667 nickname = 'elyasebot' channel = '#en.wikipedia' bot = WikiBot(channel, nickname, server, port) bot.start()
class DDP(Thread): def __init__(self): Thread.__init__(self) self.meteor = conf.get('ddp', 'meteor') self.client = MeteorClient(self.meteor, debug=False) self.client.on('added', self.on_added) self.client.on('changed', self.on_changed) self.client.on('subscribed', self.on_subscribed) self.client.on('connected', self.on_connected) self.client.on('removed', self.on_removed) self.client.on('closed', self.on_closed) self.client.on('logged_in', self.on_logged_in) self.displayName = conf.get('sussexlogin', 'room_name') self.vu_min = -70 self.vu_range = 40 self.do_vu = 0 self.last_vu = None self.ip = socket.gethostbyname(socket.gethostname()) self.id = conf.get('ingest', 'hostname') self._user = conf.get('ddp', 'user') self._password = conf.get('ddp', 'password') self._http_host = conf.get('ddp', 'http_host') self._audiostream_port = conf.get('audiostream', 'port') or 31337 self.netreg_id = conf.get('ddp', 'netreg_id') self.store_audio = conf.get_boolean('ddp', 'store_audio') self.paused = False self.recording = False self.currentMediaPackage = None self.currentProfile = None self.has_disconnected = False cam_available = conf.get( 'sussexlogin', 'cam_available') or cam_available if cam_available in ('True', 'true', True, '1', 1): self.cam_available = 1 elif cam_available in ('False', 'false', False, '0', 0): self.cam_available = 0 else: self.cam_available = int(cam_available) self.audiofaders = [] faders = conf.get('ddp', 'audiofaders').split() for fader in faders: audiofader = {} fader = 'audiofader-' + fader audiofader['name'] = conf.get(fader, 'name') audiofader['display'] = conf.get(fader, 'display') audiofader['min'] = conf.get_int(fader, 'min') audiofader['max'] = conf.get_int(fader, 'max') audiofader['type'] = conf.get(fader, 'type') audiofader['setrec'] = conf.get_boolean(fader, 'setrec') audiofader['mute'] = conf.get_boolean(fader, 'mute') audiofader['unmute'] = conf.get_boolean(fader, 'unmute') audiofader['setlevel'] = conf.get_int(fader, 'setlevel') try: audiofader['control'] = alsaaudio.Mixer( control=audiofader['name']) self.audiofaders.append(audiofader) except Exception as e: logger.warn(e) fd, eventmask = self.audiofaders[0]['control'].polldescriptors()[0] self.watchid = gobject.io_add_watch(fd, eventmask, self.mixer_changed) dispatcher.connect('galicaster-init', self.on_init) dispatcher.connect('update-rec-vumeter', self.vumeter) dispatcher.connect('galicaster-notify-timer-short', self.heartbeat) dispatcher.connect('start-before', self.on_start_recording) dispatcher.connect('restart-preview', self.on_stop_recording) dispatcher.connect('update-rec-status', self.on_rec_status_update) def run(self): self.connect() def connect(self): if not self.has_disconnected: try: self.client.connect() except Exception: logger.warn('DDP connection failed') def update(self, collection, query, update): if self.client.connected and self.subscribedTo('GalicasterControl'): try: self.client.update( collection, query, update, callback=self.update_callback) except Exception: logger.warn( "Error updating document " "{collection: %s, query: %s, update: %s}" % (collection, query, update)) def insert(self, collection, document): if self.client.connected and self.subscribedTo('GalicasterControl'): try: self.client.insert( collection, document, callback=self.insert_callback) except Exception: logger.warn( "Error inserting document {collection: %s, document: %s}" % (collection, document)) def heartbeat(self, element): if self.client.connected: self.update_images() else: self.connect() def on_start_recording(self, sender, id): self.recording = True self.currentMediaPackage = self.media_package_metadata(id) self.currentProfile = context.get_state().profile.name self.update( 'rooms', { '_id': self.id }, { '$set': { 'currentMediaPackage': self.currentMediaPackage, 'currentProfile': self.currentProfile, 'recording': self.recording } }) def on_stop_recording(self, sender=None): self.recording = False self.currentMediaPackage = None self.currentProfile = None self.update( 'rooms', { '_id': self.id }, { '$unset': { 'currentMediaPackage': '', 'currentProfile': '' }, '$set': { 'recording': self.recording } }) self.update_images(1.5) def on_init(self, data): self.update_images(1.5) def update_images(self, delay=0): worker = Thread(target=self._update_images, args=(delay,)) worker.start() def _update_images(self, delay): time.sleep(delay) files = {} audio_devices = ['audiotest', 'autoaudio', 'pulse'] for track in context.get_state().profile.tracks: if track.device not in audio_devices: file = os.path.join('/tmp', track.file + '.jpg') try: if(os.path.getctime(file) > time.time() - 3): files[track.flavor] = (track.flavor + '.jpg', open(file, 'rb'), 'image/jpeg') except Exception: logger.warn("Unable to check date of or open file (%s)" % file) im = ImageGrab.grab(bbox=(10, 10, 1280, 720), backend='imagemagick') im.thumbnail((640, 360)) output = cStringIO.StringIO() if im.mode != "RGB": im = im.convert("RGB") im.save(output, format="JPEG") files['galicaster'] = ('galicaster.jpg', output.getvalue(), 'image/jpeg') try: # add verify=False for testing self signed certs requests.post( "%s/image/%s" % (self._http_host, self.id), files=files, auth=( self._user, self._password)) except Exception: logger.warn('Unable to post images') def mixer_changed(self, source=None, condition=None, reopen=True): if reopen: for audiofader in self.audiofaders: audiofader['control'] = alsaaudio.Mixer( control=audiofader['name']) self.update_audio() return True def vumeter(self, element, data): if self.do_vu == 0: if data == "Inf": data = 0 else: if data < -self.vu_range: data = -self.vu_range elif data > 0: data = 0 data = int(((data + self.vu_range) / float(self.vu_range)) * 100) if data != self.last_vu: update = {'vumeter': data} self.update('rooms', {'_id': self.id}, {'$set': update}) self.last_vu = data self.do_vu = (self.do_vu + 1) % 20 def on_rec_status_update(self, element, data): is_paused = data == 'Paused' if is_paused: self.update_images(.75) if self.paused != is_paused: self.update( 'rooms', { '_id': self.id}, { '$set': { 'paused': is_paused}}) self.paused = is_paused if data == ' Recording ': subprocess.call(['killall', 'maliit-server']) self.update_images(.75) def media_package_metadata(self, id): mp = context.get_repository().get(id) line = mp.metadata_episode.copy() duration = mp.getDuration() line["duration"] = long(duration / 1000) if duration else None # Does series_title need sanitising as well as duration? created = mp.getDate() line["created"] = calendar.timegm(created.utctimetuple()) for key, value in mp.metadata_series.iteritems(): line["series_" + key] = value for key, value in line.iteritems(): if value in [None, []]: line[key] = '' return line def subscription_callback(self, error): if error: logger.warn("Subscription callback returned error: %s" % error) def insert_callback(self, error, data): if error: logger.warn("Insert callback returned error: %s" % error) def update_callback(self, error, data): if error: logger.warn("Update callback returned error: %s" % error) def on_subscribed(self, subscription): if(subscription == 'GalicasterControl'): me = self.client.find_one('rooms') stream_key = uuid.uuid4().get_hex() # Data to push when inserting or updating data = { 'displayName': self.displayName, 'ip': self.ip, 'paused': self.paused, 'recording': self.recording, 'heartbeat': int(time.time()), 'camAvailable': self.cam_available, 'netregId': self.netreg_id, 'inputs': self.inputs(), 'stream': { 'port': self._audiostream_port, 'key': stream_key }, 'galicasterVersion': galicaster.__version__ } if self.currentMediaPackage: data['currentMediaPackage'] = self.currentMediaPackage if self.currentProfile: data['currentProfile'] = self.currentProfile if me: # Items to unset unset = {} if not self.currentMediaPackage: unset['currentMediaPackage'] = '' if not self.currentProfile: unset['currentProfile'] = '' # Update to push update = { '$set': data } if unset: update['$unset'] = unset self.update('rooms', {'_id': self.id}, update) else: audio = self.read_audio_settings() data['_id'] = self.id data['audio'] = audio self.insert('rooms', data) def inputs(self): inputs = { 'presentations': ['Presentation'] } inputs['cameras'] = [] labels = conf.get('sussexlogin', 'matrix_cam_labels') cam_labels = [] if labels: cam_labels = [l.strip() for l in labels.split(',')] for i in range(0, self.cam_available): label = cam_labels[i] if i < len( cam_labels) else "Camera %d" % (i + 1) inputs['cameras'].append(label) return inputs def set_audio(self, fields): faders = fields.get('audio') if faders: for fader in faders: mixer = None level = fader.get('level') for audiofader in self.audiofaders: if audiofader['name'] == fader['name']: mixer = audiofader['control'] break if mixer: l, r = mixer.getvolume(fader['type']) if level >= 0 and l != level: mixer.setvolume(level, 0, fader['type']) mixer.setvolume(level, 1, fader['type']) if self.store_audio: # Relies on no password sudo access for current user to alsactl subprocess.call(['sudo', 'alsactl', 'store']) def on_added(self, collection, id, fields): self.set_audio(fields) self.update_audio() def on_changed(self, collection, id, fields, cleared): self.set_audio(fields) me = self.client.find_one('rooms') if self.paused != me['paused']: self.set_paused(me['paused']) if context.get_state().is_recording != me['recording']: self.set_recording(me) def on_removed(self, collection, id): self.on_subscribed(None) def set_paused(self, new_status): self.paused = new_status dispatcher.emit("toggle-pause-rec") def set_recording(self, me): self.recording = me['recording'] if self.recording: meta = me.get('currentMediaPackage', {}) or {} profile = me.get('currentProfile', 'nocam') series = (meta.get('series_title', ''), meta.get('isPartOf', '')) user = {'user_name': meta.get('creator', ''), 'user_id': meta.get('rightsHolder', '')} title = meta.get('title', 'Unknown') dispatcher.emit('sussexlogin-record', (user, title, series, profile)) else: dispatcher.emit("stop-record", '') def on_connected(self): logger.info('Connected to Meteor') token = conf.get('ddp', 'token') self.client.login(self._user, self._password, token=token) def on_logged_in(self, data): conf.set('ddp', 'token', data['token']) conf.update() try: self.client.subscribe( 'GalicasterControl', params=[ self.id], callback=self.subscription_callback) except Exception: logger.warn('DDP subscription failed') def on_closed(self, code, reason): self.has_disconnected = True logger.error('Disconnected from Meteor: err %d - %s' % (code, reason)) def update_audio(self): me = self.client.find_one('rooms') audio = self.read_audio_settings() update = False if me: mAudio = me.get('audio') mAudioNames = [x['name'] for x in mAudio] audioNames = [x['name'] for x in audio] if set(mAudioNames) != set(audioNames): update = True if not update: for key, fader in enumerate(audio): if mAudio[key].get('level') != fader.get('level'): update = True if update: self.update( 'rooms', { '_id': self.id}, { '$set': { 'audio': audio}}) def read_audio_settings(self): audio_settings = [] for audiofader in self.audiofaders: if audiofader['display']: audio_settings.append( self.control_values(audiofader) ) # ensure fixed values mixer = audiofader['control'] if audiofader['setrec']: mixer.setrec(1) if audiofader['mute']: mixer.setmute(1) if audiofader['unmute']: mixer.setmute(0) if audiofader['setlevel'] >= 0: mixer.setvolume(audiofader['setlevel'], 0, audiofader['type']) if 'Joined Playback Volume' not in mixer.volumecap(): mixer.setvolume(audiofader['setlevel'], 1, audiofader['type']) return audio_settings def control_values(self, audiofader): controls = {} left, right = audiofader['control'].getvolume(audiofader['type']) controls['min'] = audiofader['min'] controls['max'] = audiofader['max'] controls['level'] = left controls['type'] = audiofader['type'] controls['name'] = audiofader['name'] controls['display'] = audiofader['display'] return controls def subscribedTo(self, publication): return self.client.subscriptions.get(publication) is not None
def __init__(self): Thread.__init__(self) self.meteor = conf.get('ddp', 'meteor') self.client = MeteorClient(self.meteor, debug=False) self.client.on('added', self.on_added) self.client.on('changed', self.on_changed) self.client.on('subscribed', self.on_subscribed) self.client.on('connected', self.on_connected) self.client.on('removed', self.on_removed) self.client.on('closed', self.on_closed) self.client.on('logged_in', self.on_logged_in) self.displayName = conf.get('sussexlogin', 'room_name') self.vu_min = -70 self.vu_range = 40 self.do_vu = 0 self.last_vu = None self.ip = socket.gethostbyname(socket.gethostname()) self.id = conf.get('ingest', 'hostname') self._user = conf.get('ddp', 'user') self._password = conf.get('ddp', 'password') self._http_host = conf.get('ddp', 'http_host') self._audiostream_port = conf.get('audiostream', 'port') or 31337 self.netreg_id = conf.get('ddp', 'netreg_id') self.store_audio = conf.get_boolean('ddp', 'store_audio') self.paused = False self.recording = False self.currentMediaPackage = None self.currentProfile = None self.has_disconnected = False cam_available = conf.get( 'sussexlogin', 'cam_available') or cam_available if cam_available in ('True', 'true', True, '1', 1): self.cam_available = 1 elif cam_available in ('False', 'false', False, '0', 0): self.cam_available = 0 else: self.cam_available = int(cam_available) self.audiofaders = [] faders = conf.get('ddp', 'audiofaders').split() for fader in faders: audiofader = {} fader = 'audiofader-' + fader audiofader['name'] = conf.get(fader, 'name') audiofader['display'] = conf.get(fader, 'display') audiofader['min'] = conf.get_int(fader, 'min') audiofader['max'] = conf.get_int(fader, 'max') audiofader['type'] = conf.get(fader, 'type') audiofader['setrec'] = conf.get_boolean(fader, 'setrec') audiofader['mute'] = conf.get_boolean(fader, 'mute') audiofader['unmute'] = conf.get_boolean(fader, 'unmute') audiofader['setlevel'] = conf.get_int(fader, 'setlevel') try: audiofader['control'] = alsaaudio.Mixer( control=audiofader['name']) self.audiofaders.append(audiofader) except Exception as e: logger.warn(e) fd, eventmask = self.audiofaders[0]['control'].polldescriptors()[0] self.watchid = gobject.io_add_watch(fd, eventmask, self.mixer_changed) dispatcher.connect('galicaster-init', self.on_init) dispatcher.connect('update-rec-vumeter', self.vumeter) dispatcher.connect('galicaster-notify-timer-short', self.heartbeat) dispatcher.connect('start-before', self.on_start_recording) dispatcher.connect('restart-preview', self.on_stop_recording) dispatcher.connect('update-rec-status', self.on_rec_status_update)
import sys from MeteorClient import MeteorClient if len(sys.argv) < 3: print 'Usage: import.py <url> <cmd>' sys.exit(1) client = MeteorClient('ws://' + sys.argv[1] + '/websocket') client.connect() if sys.argv[2] == 'coffman': lat = -93.232234 lon = 44.974536 client.call('insertFakeJob', [lat, lon, sys.argv[3]]) elif sys.argv[2] == 'stpaul': lat = -93.0688954 lon = 44.8985577 client.call('insertFakeJob', [lat, lon, sys.argv[3]]) else: print 'Unknown command', sys.argv[2]
#import pymongo #con = pymongo.MongoClient(host='54.201.12.92', port=8001) #con.database_names() import time from MeteorClient import MeteorClient client = MeteorClient('ws://www.snowdrone.xyz/websocket') client.connect() def subscription_callback(error): if error: print(error) def insert_callback(error, data): if error: print(error) return print(data) def update_callback(error, data): if error: print(error) return print(data) def remove_callback(error, data): if error: print(error) return print(data) client.subscribe('snowDroneTest4', callback=subscription_callback) #all_posts = client.find('snowDroneTest3') #print all_posts boolTrue = True
exit() sensorList = sensors.get('sensors') username = config.get('username') password = config.get('password') if not sensorList: logging.error ('No sensor defined in .sensors') exit() # Begin main application logging.info ('Setting meteor service') global client client = MeteorClient(host) logging.info ('Connecting to service') client.connect() client.on('connected', onConnected) client.on('reconnected', onConnected) try: logging.info ('Setting GPIO and start listening to sensors') GPIO.setmode(GPIO.BCM) for sensor in filter(getInterruptingOnly,sensorList): registerSensorCallback(sensor) while True: for sensor in filter(getTemperatureOnly, sensorList): readTemp(sensor) time.sleep(pollingTime)
import time import yaml from MeteorClient import MeteorClient import numpy as np import scipy as sp import os import json import importlib from fusedwind.core.problem_builder import FUSEDProblem client = MeteorClient('ws://127.0.0.1:3000/websocket') def callback_function(error, result): if error: print(error) return print(result) def subscribed(subscription): print('* SUBSCRIBED {}'.format(subscription)) def unsubscribed(subscription): print('* UNSUBSCRIBED {}'.format(subscription)) problems = {}
def __init__(self): Thread.__init__(self) self.meteor = conf.get('ddp', 'meteor') self.client = MeteorClient(self.meteor, debug=False) self.client.on('added', self.on_added) self.client.on('changed', self.on_changed) self.client.on('subscribed', self.on_subscribed) self.client.on('connected', self.on_connected) self.client.on('removed', self.on_removed) self.client.on('closed', self.on_closed) self.client.on('logged_in', self.on_logged_in) self.displayName = conf.get('sussexlogin', 'room_name') self.vu_min = -70 self.vu_range = 40 self.do_vu = 0 self.last_vu = None self.ip = socket.gethostbyname(socket.gethostname()) self.id = conf.get('ingest', 'hostname') self._user = conf.get('ddp', 'user') self._password = conf.get('ddp', 'password') self._http_host = conf.get('ddp', 'http_host') self._audiostream_port = conf.get('audiostream', 'port') or 31337 self.netreg_id = conf.get('ddp', 'netreg_id') self.store_audio = conf.get_boolean('ddp', 'store_audio') self.paused = False self.recording = False self.currentMediaPackage = None self.currentProfile = None self.has_disconnected = False cam_available = conf.get('sussexlogin', 'cam_available') or cam_available if cam_available in ('True', 'true', True, '1', 1): self.cam_available = 1 elif cam_available in ('False', 'false', False, '0', 0): self.cam_available = 0 else: self.cam_available = int(cam_available) self.audiofaders = [] faders = conf.get('ddp', 'audiofaders').split() for fader in faders: audiofader = {} fader = 'audiofader-' + fader audiofader['name'] = conf.get(fader, 'name') audiofader['display'] = conf.get(fader, 'display') audiofader['min'] = conf.get_int(fader, 'min') audiofader['max'] = conf.get_int(fader, 'max') audiofader['type'] = conf.get(fader, 'type') audiofader['setrec'] = conf.get_boolean(fader, 'setrec') audiofader['mute'] = conf.get_boolean(fader, 'mute') audiofader['unmute'] = conf.get_boolean(fader, 'unmute') audiofader['setlevel'] = conf.get_int(fader, 'setlevel') try: audiofader['control'] = alsaaudio.Mixer( control=audiofader['name']) self.audiofaders.append(audiofader) except Exception as e: logger.warn(e) fd, eventmask = self.audiofaders[0]['control'].polldescriptors()[0] self.watchid = gobject.io_add_watch(fd, eventmask, self.mixer_changed) dispatcher.connect('galicaster-init', self.on_init) dispatcher.connect('update-rec-vumeter', self.vumeter) dispatcher.connect('galicaster-notify-timer-short', self.heartbeat) dispatcher.connect('start-before', self.on_start_recording) dispatcher.connect('restart-preview', self.on_stop_recording) dispatcher.connect('update-rec-status', self.on_rec_status_update)
# -*- coding: utf-8 -*- # Define your item pipelines here # # Don't forget to add your pipeline to the ITEM_PIPELINES setting # See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html from scrapy import signals from scrapy.contrib.exporter import CsvItemExporter from MeteorClient import MeteorClient # try to reconnect every second #client = MeteorClient('ws://127.0.0.1:3333/websocket', auto_reconnect=True, auto_reconnect_timeout=1) client = MeteorClient('ws://127.0.0.1:3004/websocket', auto_reconnect=True, auto_reconnect_timeout=1) client.connect() def insert_callback(error, data): if error: print(error) return print(data) class GameListingPipeline(object): def __init__(self): self.files = {} @classmethod def from_crawler(cls, crawler): pipeline = cls() crawler.signals.connect(pipeline.spider_opened, signals.spider_opened) crawler.signals.connect(pipeline.spider_closed, signals.spider_closed)
print collection print fields def changed(collection, id, fields, cleared): print ("changed:{}".format(id) + " fields: {}".format(fields)) def connected(): print('* CONNECTED') client.login("test", "test") def subscription_callback(error): if error: print(error) try: client = MeteorClient('ws://rbmobility.emtmadrid.es:3333/websocket', auto_reconnect = True, auto_reconnect_timeout = 5, debug = False) client.on('subscribed', subscribed) client.on('unsubscribed', unsubscribed) client.on('added', added) client.on('connected', connected) client.on('changed',changed) client.connect() # ctrl + c to kill the script while True: try: time.sleep(1) except KeyboardInterrupt:
import time from MeteorClient import MeteorClient client = MeteorClient('ws://127.0.0.1:3000/websocket', debug=True) client.connect() client.subscribe('SessionsList') name = time.strftime("%I:%M:%S") time.sleep(1) client.insert('Sessions', {'title': name}) time.sleep(1) # confirm that a publication was started based on the session name passed in client.subscribe(name) time.sleep(1)
class ConnectionManager(): def __init__(self, server_url='ws://localhost:3000/websocket', worker=None): self.server_url = server_url self.client = MeteorClient(server_url) self.client.on('subscribed', self.subscribed) self.client.on('unsubscribed', self.unsubscribed) self.client.on('added', self.added) self.client.on('changed', self.changed) self.client.on('removed', self.removed) self.client.on('connected', self.connected) self.client.on('logged_in', self.logged_in) self.client.on('logged_out', self.logged_out) self.worker = worker self.connected = False self.ready = False def connect(self): self.client.connect() def connected(self): self.connected = True print('connected to ' + self.server_url) #self.client.login('test', '*****') if not 'workers.worker' in self.client.subscriptions: self.client.subscribe( 'workers.worker', [self.worker.id, self.worker.token]) def logged_in(self, data): self.userId = data['id'] print('* LOGGED IN {}'.format(data)) def subscribed(self, subscription): print('* SUBSCRIBED {}'.format(subscription)) self.ready = True if subscription == 'workers.worker': if self.client.find_one('workers', selector={'_id': self.worker.id}): print('-----Worker {} found-----'.format(self.worker.id)) if not 'widgets.worker' in self.client.subscriptions: self.client.subscribe( 'widgets.worker', [self.worker.id, self.worker.token]) else: raise Exception('Failed to find the worker with id:{} token{}'.format( self.worker.id, self.worker.token)) if subscription == 'widgets.worker': print('widgets of this worker SUBSCRIBED-') elif subscription == 'tasks.worker': print('* tasks of this worker SUBSCRIBED-') def added(self, collection, id, fields): print('* ADDED {} {}'.format(collection, id)) # for key, value in fields.items(): # print(' - FIELD {} {}'.format(key, value)) if collection == 'tasks': if not self.worker.workTasks.has_key(id): if fields.has_key('worker') and fields['worker'] == self.worker.id: taskDoc = self.client.find_one('tasks', selector={'_id': id}) widget = self.worker.get_registered_widget(taskDoc['widgetId']) if widget: task = Task(taskDoc, self.worker, self.client) if task and task.id: self.worker.add_task(task) else: # remove task if widget is not registered self.client.call('tasks.update.worker', [ id, self.worker.id, self.worker.token, {'$set': {'visible2worker': False}}]) else: # remove task if widget is not registered self.client.call('tasks.update.worker', [ id, self.worker.id, self.worker.token, {'$set': {'visible2worker': False}}]) elif collection == 'users': self.userName = fields['username'] elif collection == 'widgets': # widget = fields#self.client.find_one('widgets', selector={'name': widget_ = Widget(self.client.find_one( 'widgets', selector={'_id': id}), self.worker, self.client) if widget_.id: self.worker.register_widget(widget_) if not 'tasks.worker' in self.client.subscriptions: self.client.subscribe( 'tasks.worker', [self.worker.id, self.worker.token]) def changed(self, collection, id, fields, cleared): #print('* CHANGED {} {}'.format(collection, id)) # for key, value in fields.items(): # print(' - FIELD {} {}'.format(key, value)) # for key, value in cleared.items(): # print(' - CLEARED {} {}'.format(key, value)) if collection == 'tasks': if self.worker.workTasks.has_key(id): task = self.worker.workTasks[id] for key, value in fields.items(): if key == 'cmd': self.worker.execute_task_cmd(task, key, value) elif key == 'worker': self.worker.task_worker_changed(task, key, value) if task.processor.changeCallbackDict.has_key(key): for changeCallback in task.processor.changeCallbackDict[key]: try: changeCallback(task, key, value) except Exception as e: traceback.print_exc() task.set('status.error', traceback.format_exc()) for key, value in cleared.items(): if key == 'cmd': self.worker.execute_task_cmd(task, key, value) elif key == 'worker': self.worker.task_worker_changed(task, key, value) if task.processor.changeCallbackDict.has_key(key): for changeCallback in task.processor.changeCallbackDict[key]: try: changeCallback(task, key, value) except Exception as e: traceback.print_exc() task.set('status.error', traceback.format_exc()) else: if fields.has_key('worker') and fields['worker'] == self.worker.id: self.worker.add_task(id) #print('task is not in worktask list: ' + id) if collection == 'widgets': widget_ = Widget(self.client.find_one( 'widgets', selector={'_id': id}), self.worker, self.client) if widget_.id: self.worker.register_widget(widget_) if fields.has_key('workers'): if fields['workers'].has_key(self.worker.id): #print('worker config changed') worker = fields['workers'][self.worker.id] if worker.has_key('cmd'): self.worker.execute_worker_cmd(worker['cmd']) def removed(self, collection, id): print('* REMOVED {} {}'.format(collection, id)) if collection == 'tasks': if self.worker.workTasks.has_key(id): task = self.worker.workTasks[id] self.worker.remove_task(task) for cb in task.processor.removeCallbackList: cb(task) def unsubscribed(self, subscription): print('* UNSUBSCRIBED {}'.format(subscription)) def logged_out(): self.userId = None print('* LOGGED OUT') def subscription_callback(self, error): if error: print(error) def run(self): # (sort of) hacky way to keep the client alive # ctrl + c to kill the script try: while True: time.sleep(1) except: traceback.print_exc() finally: self.stop() print('server exited') def stop(self): try: for task in self.worker.workTasks: if task.processor: task.processor.stop() except Exception as e: pass self.worker['status'] = 'stopped' for subscription in self.client.subscriptions.copy(): self.client.unsubscribe(subscription)
print('start upload') opts = { "file": {"name": fname, "type": fileType, "size": fileSize, "meta": meta}, "fileId": self.fileId, "chunkSize": chunkSize, "fileLength": 1 if chunkCount <= 0 else chunkCount, } self.finished = False self.error = False returnMeta = self.transport == 'http' self.client.call(self.methodNames['_Start'], [ opts, returnMeta], self._upload_start_callback) return self.fileId if __name__ == '__main__': client = MeteorClient('ws://127.0.0.1:3000/websocket') client.connect() # upload example, work with Meteor-Files example: demo-simplest-upload # server code: https://github.com/VeliovGroup/Meteor-Files/tree/master/demo-simplest-upload client.subscribe('files'); uploader = Uploader(client, 'files', transport='ddp', verbose=True) #import time #t0 = time.time() uploader.upload("test.jpeg") while not uploader.finished: time.sleep(0.1) #t1 = time.time()
"meta": meta }, "fileId": self.fileId, "chunkSize": chunkSize, "fileLength": 1 if chunkCount <= 0 else chunkCount, } self.finished = False self.error = False returnMeta = self.transport == 'http' self.client.call(self.methodNames['_Start'], [opts, returnMeta], self._upload_start_callback) return self.fileId if __name__ == '__main__': client = MeteorClient('ws://127.0.0.1:3000/websocket') client.connect() # upload example, work with Meteor-Files example: demo-simplest-upload # server code: https://github.com/VeliovGroup/Meteor-Files/tree/master/demo-simplest-upload client.subscribe('files') uploader = Uploader(client, 'files', transport='ddp', verbose=True) #import time #t0 = time.time() uploader.upload("test.jpeg") while not uploader.finished: time.sleep(0.1) #t1 = time.time()
configuration.LED_B_PINS[0], connection) for i in range(1, len(configuration.LED_R_PINS)): led.addLED(configuration.LED_R_PINS[i], configuration.LED_G_PINS[i], configuration.LED_B_PINS[i]) led.setColor(0, 0, 255) arduino = ArduinoApi(connection=connection) arduino.pinMode(configuration.PUMP_PIN, arduino.OUTPUT) for pin in configuration.VALVE_PINS: arduino.pinMode(pin, arduino.OUTPUT) scale = Hx711(configuration.LOAD_CELL_DOUT_PIN, configuration.LOAD_CELL_SCK_PIN, connection) client = MeteorClient(configuration.SERVER) def write_log(type, message): client.call('log.insert', [type, message]) def update_callback(error, data): if error: write_log('error', 'Error on update: {}'.format(error)) def insert_callback(error, data): if error: write_log('error', 'Error on insert: {}'.format(error))
class DisplayMinion(App): action_map = { 'media': MediaAction, 'playlist': PlaylistAction, 'song': SongAction, 'presentation': PresentationAction, 'presentationslide': PresentationAction, 'timer': TimerAction, 'camera': GStreamerAction, 'clear-layer': Action } def __init__(self, **kwargs): self._id = None self.server = None self.ready = False self.state = 'disconnected' # 'disconnected' => 'connecting' => 'connected' => 'registering' => 'registered' self.binds = {} self.layers = {} self.sections = [] self.last_blocks = None self.fullscreen = False self.defaults = json.load(open('common/default_settings.json')) super(DisplayMinion, self).__init__(**kwargs) def debug(self, *args): print(*args) # if self.config.get('debug'): # print(*args) def bind(self, event, function): if self.binds.get(event): self.binds[event].append(function) else: self.binds[event] = [function] def trigger_event(self, event): event_data = {'event': event, 'client': self} for function in self.binds.get(event, []): function(event_data) def connect(self, server): self.server = server self.meteor = MeteorClient('ws://{}/websocket'.format(self.server)) self.meteor.on('connected', self.connected) self.meteor.connect() self.state = 'connecting' self.trigger_event('connecting') def connected(self): self.state = 'connected' self.trigger_event('connected') self.debug('Connected to server') self.time = MeteorTime(self.meteor) Clock.schedule_interval(self.time.update, 0.5) self.collections = 0 self.collections_ready = 0 for collection in ['settings', 'stages', 'minions', 'media', 'mediaplaylists', 'songs', 'songarrangements', 'songsections', 'presentations', 'presentationslides']: self.collections += 1 self.meteor.subscribe(collection, callback=self.subscription_ready) def subscription_ready(self, err): if err: self.debug(err) self.collections_ready += 1 if self.collections_ready >= self.collections: self.trigger_event('loaded') self.debug('All subscriptions ready') def register(self, _id): self._id = _id self.meteor.call('minionConnect', [_id], self.prep) self.state = 'registering' self.trigger_event('registering') def prep(self, e, r): self.state = 'registered' self.trigger_event('registered') self.debug('Registered') self.meteor.on('added', self.added) self.meteor.on('changed', self.changed) self.minion = self.meteor.find_one('minions', selector = {'_id': self._id}); self.stage = self.meteor.find_one('stages', selector = {'_id': self.minion['stage']}) self.update_minion_settings(self.minion) Clock.create_trigger(self.update_layers)() Clock.schedule_once(self.update_minion_blocks, 0) self.ready = True def added(self, collection, _id, fields): self.changed(collection, _id, fields, None) def changed(self, collection, _id, fields, cleared): if not self.ready: return if collection == 'minions' and _id == self._id: self.minion = self.meteor.find_one('minions', selector = {'_id': self._id}); self.update_minion_settings(self.minion) if collection == 'stages' and _id == self.minion['stage']: self.stage = self.meteor.find_one('stages', selector = {'_id': self.minion['stage']}) Clock.create_trigger(self.update_layers)() def update_minion_settings(self, minion): if not minion['settings']['blocks'] == self.last_blocks: self.last_blocks = minion['settings']['blocks'] Clock.schedule_once(self.update_minion_blocks, 0) if not minion['settings'].get('mediaminion_width', 0) == self.source.disp_size[0] or \ not minion['settings'].get('mediaminion_height', 0) == self.source.disp_size[1]: self.source.disp_size = (int(minion['settings'].get('mediaminion_width') or 0), int(minion['settings'].get('mediaminion_height') or 0)) self.source.resize() def update_minion_blocks(self, dt): # Note: Sections were originally named "blocks", so far I've been too lazy to rewrite all the cedarserver code to reflect the new name. -IHS start_length = len(self.sections) block_delta = len(self.minion['settings']['blocks']) - start_length if block_delta > 0: for n in range(block_delta): config = self.minion['settings']['blocks'][start_length + n] section = Section( source = self.source, block = config, client = self ) self.layout.add_widget(section) self.sections.append(section) elif block_delta < 0: for n in range(abs(block_delta)): section = self.sections.pop() self.layout.remove_widget(section) for index, section in enumerate(self.sections): config = self.minion['settings']['blocks'][index] if not section.block == config: # TODO add brightness etc. section.block = config section.recalc() def update_layers(self, dt = None): layers = self.stage.get('layers', []) for layer, action in layers.items(): if not layer in self.minion['layers']: continue if action and self.layers.get(layer): # Test if new action is the same as the current one current = self.layers.get(layer).action if action['_id'] == current['_id']: if action['type'] == 'song': if action.get('args') and current.get('args') and \ action['args']['section'] == current['args']['section'] and \ action['args']['index'] == current['args']['index']: continue elif action['type'] == 'presentation': if action.get('args') and current.get('args') and \ action['args']['order'] == current['args']['order'] and \ action['args']['fillin'] == current['args']['fillin']: continue else: continue if action and self.action_map.get(action['type']): self.layers[layer] = self.action_map[action['type']](action, self.layers.get(layer) or None, self) self.layers[layer].show() elif action == None and self.layers.get(layer): self.layers[layer].hide() self.layers[layer].remove() self.layers[layer] = None def get_layer_index(self, target_layer): layers = self.stage['settings']['layers'] layer_index = layers.index(target_layer) higher_layers = layers[layer_index + 1:] widget_index = 0 for layer in higher_layers: higher_action = self.layers.get(layer) if higher_action: higher_index = higher_action.get_current_widget_index() if not higher_index == None: widget_index = higher_index + 1 break return widget_index def add_layer_widget(self, new_widget, layer): # TODO switch to this behavior once https://github.com/kivy/kivy/issues/4293 is resolved # self.source.add_widget(widget, index = self.get_layer_index(layer)) widgets = self.source.children[:] new_index = self.get_layer_index(layer) for widget in widgets: self.source.remove_widget(widget) widgets.insert(new_index, new_widget) widgets.reverse() for widget in widgets: self.source.add_widget(widget) def remove_widget(self, widget): self.source.remove_widget(widget) def get_application_config(self): return super(DisplayMinion, self).get_application_config('~/.%(appname)s.ini') def build_config(self, config): config.setdefaults('connection', { 'server': 'localhost:3000', '_id': '', 'autoconnect': 'no', }) config.setdefaults('window', { 'fullscreen': 'no' }) config.setdefaults('outputs', { 'shmsink': 'no' }) def toggle_fullscreen(self, thing, touch): if not self.ui.layout.collide_point(*touch.pos): if self.fullscreen: Window.fullscreen = 0 else: Window.fullscreen = 'auto' self.fullscreen = not self.fullscreen def on_stop(self): self.source.stop() def build(self): self.title = 'Cedar Display Client' if self.config.get('window', 'fullscreen') == 'yes': Window.fullscreen = 'auto' if kivy.utils.platform is 'windows': self.icon = 'logo/logo-128x128.png' else: self.icon = 'logo/logo-1024x1024.png' self.source = DisplaySource(self, pos_hint = {'x': 1, 'y': 1}, size_hint = [None, None]) self.source.bind(on_touch_down = self.toggle_fullscreen) self.layout = FloatLayout() self.layout.add_widget(self.source) self.ui = UserInterface(self) return self.layout
#!/usr/bin/env python """ Check to see if an process is running. If not, restart. Run this in a cron job """ import os import sys import time import fcntl, socket, struct from MeteorClient import MeteorClient # client = MeteorClient('ws://127.0.0.1:3030/websocket') client = MeteorClient('ws://127.0.0.1:3000/websocket') process_name= "/root/smartag-python.py" # change this to the name of your process #process_name= "meteor_run.sh" # process_name= "/home/atanas/MeteorProjects/iot/serverstate.py" def getHwAddr(ifname): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) info = fcntl.ioctl(s.fileno(), 0x8927, struct.pack('256s', ifname[:15])) return ':'.join(['%02x' % ord(char) for char in info[18:24]]) print getHwAddr('eth0') # new part newmac = getHwAddr('eth0') client.connect() tmp = os.popen("ps -Af").read() print tmp[:] if process_name in tmp[:]: print "LOCAL SERVER RUNNING" print process_name
import time from MeteorClient import MeteorClient client = MeteorClient('ws://127.0.0.1:3000/websocket', debug=True) client.connect() client.subscribe('SessionsList') time.sleep(1) sessions = client.find('sessions') print(sessions) time.sleep(1)
def serve_once(self): """ Run the bot until the connection is disconnected. :return: None. """ # Log message self._log_debug('# ----- serve_once -----') # Log message self._log_debug(('# ----- Create meteor client -----\n' 'SERVER_URI: {}').format(self._server_uri)) # Create meteor client self._meteor_client = MeteorClient( self._server_uri, # Disable the meteor client's auto reconnect. # Let `serve_forever` handle reconnect. auto_reconnect=False, ) # Log message self._log_debug('# ----- Hook meteor client callbacks -----') # 5DI82 # Hook meteor client `connected` callback self._meteor_client.on('connected', self._meteor_connected_callback) # 2RAYF # Hook meteor client `changed` callback self._meteor_client.on('changed', self._meteor_changed_callback) # 4XIZB # Hook meteor client `added` callback self._meteor_client.on('added', self._meteor_added_callback) # 2JEIK # Hook meteor client `removed` callback self._meteor_client.on('removed', self._meteor_removed_callback) # 32TF2 # Hook meteor client `failed` callback self._meteor_client.on('failed', self._meteor_failed_callback) # 5W6RX # Hook meteor client `reconnected` callback self._meteor_client.on('reconnected', self._meteor_reconnected_callback) # 7MOJX # Hook meteor client `closed` callback self._meteor_client.on('closed', self._meteor_closed_callback) # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Log message self._log_debug('# ----- Connect to meteor server -----') try: # Connect to meteor server. # # If the connecting succeeds, the meteor client's thread will call # `self._meteor_connected_callback` hooked at 5DI82. The login, # topic subscribing, and message handling are run in that thread. # # The main thread merely waits until the meteor client is closed, # meanwhile it calls heartbeat function at interval if specified. # self._meteor_client.connect() # If have error except: # Log message self._log_debug('# ----- Connecting failed -----') # Log message self._log_debug('# ----- Unhook meteor client callbacks -----') # Remove meteor client callbacks self._meteor_client.remove_all_listeners() # Remove meteor client reference self._meteor_client = None # The two events below should not have been set if the connecting # failed. Just in case. # # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Raise the error raise # Get whether heartbeat is enabled heartbeat_enabled = self._get_bool_config( CONFIG_KEYS.HEARTBEAT_ENABLED) try: # Wait until the topic subscribing is done in another thread at # 5MS7A self._subscribing_done_event.wait() # If heartbeat is enabled if heartbeat_enabled: # Get heartbeat function heartbeat_func = self._get_config(CONFIG_KEYS.HEARTBEAT_FUNC) # Assert the function is callable assert callable(heartbeat_func), repr(heartbeat_func) # Get heartbeat interval heartbeat_interval = self._get_config( CONFIG_KEYS.HEARTBEAT_INTERVAL, default=10, ) # Convert heartbeat interval to float heartbeat_interval = float(heartbeat_interval) # 65ZNO # Loop until the meteor client is disconnected while self._meteor_client.connected: # Send heartbeat heartbeat_func(self) # Sleep before sending next heartbeat time.sleep(heartbeat_interval) # 5W6XQ # Wait until the meteor client is closed and the `closed` callback # is called at 3DMYH self._meteor_closed_event.wait() # If have error except: # Close meteor client. # # This will cause `self._meteor_closed_callback` to be called, # which will set the `self._meteor_closed_event` below. # self._meteor_client.close() # See 5W6XQ self._meteor_closed_event.wait() # Raise the error raise # Always do finally: # Log message self._log_debug('# ----- Unhook meteor client callbacks -----') # Remove meteor client callbacks self._meteor_client.remove_all_listeners() # Remove meteor client reference. # # Do this before calling `callback_presence` below so that the # plugins will not be able to access the already closed client. # self._meteor_client = None # Log message self._log_debug('# ----- Call `callback_presence` -----') # Call `callback_presence` self.callback_presence( Presence(identifier=self.bot_identifier, status=OFFLINE)) # Log message self._log_debug('# ----- Call `disconnect_callback` -----') # Call `disconnect_callback` to unload plugins self.disconnect_callback() # Clear the event self._subscribing_done_event.clear() # Clear the event self._meteor_closed_event.clear() # Log message self._log_debug('# ===== serve_once =====')
class MWorker: multiprocessPluginManager = "" # yapsy manager meteorClient = "" # python-meteor client # session=requests.Session() #http client meteorUrl = "ws://127.0.0.1:3000/websocket" CYCLE_DEFAULT_DELAY = 20 # 10 seconds SYNCHRO_TIMEOUT = 10 # meteor functions are asynchron. this is delay for how long i should wait till # it is considered as fail... 2 sec are default subscription_status = {} # this will assure, subscription is ready... "subscription_name":true/false workername = "localhostworker" # this is worker name - this must be initialised at moment of start, and # must by uniqued... data = "" error = "" syncwaitdone = False def __init__(self, meteorUrl): """ constructor :return: """ self.meteorUrl = meteorUrl self.logm("MWorker:constructor", "python meteor client initialisation:") self.initMeteorConnect() self.logm("MWorker:constructor", "getting unassigned") # self.infiniteCycle() self.getUnassigned() def infiniteCycle(self): """ this is to keep thread running - it can be interupted by ctrl+c :return: """ while True: try: time.sleep(1) except KeyboardInterrupt: break def initMeteorConnect(self): """ this will use library python-meteor in order to escablish session to selected meteor :return: """ self.logm("MWorkerLib:initMeteorConnect:", "meteor python lib client iniciaisation...") self.meteorClient = MeteorClient('ws://127.0.0.1:3000/websocket', auto_reconnect=True) self.meteorClient.connect() self.subscribeCollectionSynchron(['unassigned', 'active', 'trash'], self.SYNCHRO_TIMEOUT) self.logm("MWorkerLib:initMeteorConnect:", "meteor python lib client iniciaisation done...") def meteorCollectionSubscribed(self, subscription): self.subscription_status[subscription] = True; self.logm("MWorkerLib:subscribed:", 'SUBSCRIBED {}'.format(subscription)) def meteorConnected(self): self.logm("MWorkerLib:connected:", ' CONNECTED') def initYapsy(self): """ inicialisation of yapsi subsystems... :return: """ self.multiprocessPluginManager = MultiprocessPluginManager() self.multiprocessPluginManager.setPluginPlaces(["plugins"]) self.multiprocessPluginManager.collectPlugins() self.logm("MWorkerLib:initYapsy:", "following pluggins ready") for pluginInfo in self.multiprocessPluginManager.getAllPlugins(): self.logm("MWorkerLib:initYapsy:", ">" + pluginInfo.name) def isSubscriptionProcessDone(self): """ this will check, if in self.subscription_status all collections are set to true :return: true if all requested collections are subscribed, orthervice false.. """ kk = self.subscription_status.keys() for col in kk: if self.subscription_status[col] == False: self.logm("MWorkerLib:isSubscriptionProcessDone:", self.subscription_status) return False return True def subscribeCollectionSynchron(self, collections, timeout): """ this is synchron method. this means, there is loop for "timeout" seconds, so subscription can be estalished... :param: timeout - number of seconds for cycle this function will have :param: collections - array of collections to be subscribed with self.meteorClient... ['unassigned', 'active', 'trash'] :return: will return true, or collection if some is false """ self.logm("MWorkerLib:subscribeCollectionsynchron:", "begining with subscription") self.meteorClient.on('subscribed', self.meteorCollectionSubscribed) self.meteorClient.on('connected', self.meteorConnected) for col in collections: self.subscription_status[col] = False self.meteorClient.subscribe(col) self.logm("MWorkerLib:subscribeCollectionSynchron", "subscription init done, now waiting...:" + str(self.meteorClient.subscriptions.keys())) epoch = int(time.time()) while (((int(time.time()) - epoch) < timeout) and ( (self.isSubscriptionProcessDone() == False))): try: time.sleep(1) self.logm("MWorkerLib:subscribeCollectionSynchron", "inside waiting cycle :" + str(self.meteorClient.subscriptions.keys())) except KeyboardInterrupt: break if (self.isSubscriptionProcessDone() == False): self.logm("MWorkerLib:subscribeCollectionSynchron", "some requested subscription failed...:" + str(self.subscription_status)) return False else: self.logm("MWorkerLib:subscribeCollectionSynchron", "requested subscription successfuly subscribed...") return True def getUnassigned(self): """ get list of unassigned tasks :return: list of unassigned tasks """ self.logm("MWorkerLib:getUnassigned", "geting all unassigned") all_posts = self.meteorClient.find('unassigned') self.logm("MWorkerLib:getUnassigned", "found following unassigned:" + str(all_posts)) def subscription_callback(self, error): if error: self.logm("MWorkerLib:subscription_callback", "subsribing to unassigned failed") return self.logm("MWorkerLib:subscription_callback", "subsribing to unassigned succeed") def logm(self, tag="undefined tag", text="undefined text"): """ logger wrapper .... :param tag: tag :param level: level ( 1..10 ) :param text: dscription of logging :return: """ timestamp = self.getTimestamp() print("{d} t:{a} t:{c} ".format(a=tag, c=text, d=timestamp)) ####################################### support methods def getTimestamp(self): ts = time.time() return datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S') def callViewToolkit(self, method, parameters, callback): """ this will execute call... please note, for simple geting collection data, no need to create method... :param method: name of function :param parameters: what to give to viewtoolkit :callback - as all meteor calls are async, callback is required def callback_function(error, result): if error: print(error) return print(result) :return: """ self.logm("MWorkerLib:callViewToolkit", "method:" + method + " with parameters:" + parameters + " called") self.meteorClient.call(method, parameters, callback) def isPluginActiveInPluginManager(self, pluginname): """ this is to check if plugin which is parameter exist in worker, and if yes, if it is activated... :param pluginname: :return: true in case plugin is activated """ for pluginInfo in self.multiprocessPluginManager.getAllPlugins(): self.logm("MWorkerLib:isPlugginActiveInPluginManager:", "checking plugin " + pluginInfo.name + "against " + pluginname) if (pluginname == pluginInfo.name): self.logm("MWorkerLib:isPlugginActiveInPluginManager:", "plugin was found, let see if it is activated " + str(pluginInfo.is_activated)) if pluginInfo.is_activated: self.logm("MWorkerLib:isPlugginActiveInPluginManager:", "yes, plugin exist and was activated. returning true") return True self.logm("MWorkerLib:isPlugginActiveInPluginManager:", "could not found plugin you uare asking for, or it is not activated, returning False") return False def activatePlugin(self, pluginname): """ plugin activation itself :param pluginname: :return: """ self.logm("MWorkerLib:isPlugginActiveInPluginManager:activatePlugin", "plugin {a} will be activated now...".format(a=pluginname)) self.multiprocessPluginManager.activatePluginByName(pluginname) self.logm("MWorkerLib:isPlugginActiveInPluginManager:activatePlugin", "plugin {a} was activated...".format(a=pluginname)) def moveJobFromActiveToTrash(self,jobname): """ will move job by its name from active to trash :param jobname: :return: """ #kontrola, zda trash ma v sobe vytvoreneho workera: if(self.isWorkerInTrash()==False): self.createWorkerRecordInTrash() job=self.getJobInActiveByName(jobname) if (job==None): return False if self.createJobInTrashSynchronised(job): self.deleteJobFromActiveSynchronised(jobname) def deleteJobFromActiveSynchronised(self,jobname): """ delete job from active :param jobname: :return: """ result = False self.syncwaitdone = False # zacatek locku self.logm("MWorkerLib:deleteJobFromActiveSynchronised", "worker:" + self.workername + " is going to remove job from active " + str(jobname)) self.meteorClient.remove( 'active',{'_id':self.workername,'jobs._id':jobname}, callback=self.callback_synchro) res = self.syncWait() # konec locku self.logm("MWorkerLib:deleteJobFromActiveSynchronised", "worker:" + self.workername + " removed " + str(jobname)+ "result is "+str(res)) return res def createJobInTrashSynchronised(self,job): """ this will create job in trash collection under worker name... :param job: :return: """ #inseritng job self.logm("MWorkerLib:createJobInTrash", "worker:" + self.workername + " is going to insert to trash following: " + str(job)) self.syncwaitdone = False # zacatek locku self.meteorClient.update('trash', {'_id': self.workername}, {'$push': {"jobs":job}}, callback=self.callback_synchro) res = self.syncWait() # konec locku return res def getJobInActiveByName(self,jobname): """ this will get job back :param jobname: name of job in active ... :return: return job, or None """ res = self.meteorClient.find_one('active',{'_id':self.workername,'jobs.jobname':jobname}) if res==[]: return None return res def moveJobFromUnassignedToActiveSynchronised(self, jobname): """ this will shift job from unassigned to active... based on job name, which must be unique in hwhile system :param jobname: :return: """ #kontrola, zda existuje worker v active, a kdyz ne, tak se vlozi podle template if(self.isWorkerInActive()==False): self.logm("MWorkerLib:moveJobFromUnassignedToActiveSynchronised", " dont see record for worker {w} in active !! creating it ".format(w=self.workername)) self.createWorkerRecordInActive() resulttmp = self.findJobinUnassigned(jobname) if(len(resulttmp)!=1): raise NoJobFound(" given job name "+jobname+" doesnt exist") job=resulttmp[0] self.logm("MWorkerLib:moveJobFromUnassignedToActiveSynchronised", " job {a} will be activated now...".format(a=str(job))) if (self.createMyJobInActiveSynchronised(job)): if(self.deleteJobFromUnassignedSynchronised(job)): self.logm("MWorkerLib:moveJobFromUnassignedToActiveSynchronised", " job inserting to db is ok, job deleted from unassigned ") return True self.logm("MWorkerLib:moveJobFromUnassignedToActiveSynchronised", "job inserting to db failed") return False def isWorkerInTrash(self): """ will check is self.workername can be found in trash :return: true if it can be found, false if not """ result = self.meteorClient.find('trash',{"_id":self.workername}) self.logm("MWorkerLib:isWorkerInTrash", "checking, if i see my worker name in trash "+str(result)) if len(result)==1: self.logm("MWorkerLib:isWorkerInTrash", " worker with my name found in trash, erturning true") return True else: self.logm("MWorkerLib:isWorkerInTrash", "found nothing, returning False") return False def isWorkerInActive(self): """ will check is self.workername can be found in active :return: true if it can be found, false if not """ result = self.meteorClient.find('active',{"_id":self.workername}) self.logm("MWorkerLib:isWorkerInActive", "checking, if i see my worker name in active "+str(result)) if len(result)==1: self.logm("MWorkerLib:isWorkerInActive", " worker with my name found in active, erturning true") return True else: self.logm("MWorkerLib:isWorkerInActive", "found nothing, returning False") return False def createWorkerRecordInActive(self): """ will create new worker - it will not be checking if there is already worker created in active... :return: """ template={"_id":self.workername,"worker":self.workername,"workerusername":"******","jobs":[]} self.logm("MWorkerLib:createWorkerRecordInActive", "worker:" + self.workername + " is going to by added to collection active ") self.syncwaitdone = False # zacatek locku self.meteorClient.insert('active', template, callback=self.callback_synchro) res = self.syncWait() # konec locku return res def createWorkerRecordInTrash(self): """ will create new worker - it will not be checking if there is already worker created in active... :return: """ template={"_id":self.workername,"worker":self.workername,"workerusername":"******","jobs":[]} self.logm("MWorkerLib:createWorkerRecordInTrash", "worker:" + self.workername + " is going to by added to collection trash ") self.syncwaitdone = False # zacatek locku self.meteorClient.insert('trash', template, callback=self.callback_synchro) res = self.syncWait() # konec locku return res def findJobinUnassigned(self, jobname): """ will return job from unassigned by jobname this is synchron method... it will wait for ( synchron_timeout ) seconds, and return false :param job: :return: false on timeout ( synchron_timeout ) or if return is different from 1. """ return self.meteorClient.find('unassigned', {"_id": jobname}) def createMyJobInActiveSynchronised(self, job): """ this will take as input dict of job... and add it to jobs[] in proper worker... :param job: dict of job... :return: false on timeout ( synchron_timeout ) or if return is different from 1. """ template = { 'pluginname': job['pluginname'], 'jobname': job['jobname'], 'starttime': int(time.time()), # epocha 'ttl': job['expectedttl'], 'inputparams': job['inputparams'], 'progress': 0, 'result': "undefined" } self.logm("MWorkerLib:createMyJobInActive", "worker:" + self.workername + " is going to insert to active following: " + str(job)) self.syncwaitdone = False # zacatek locku self.meteorClient.update('active', {'_id': self.workername}, {'$push': {'jobs': template}}, callback=self.callback_synchro) res = self.syncWait() # konec locku return res def callback_synchro(self, error, data): self.data = data self.error = error if error: self.logm("MWorkerLib:update_callback_synchro", "worker:" + self.workername + " failed error is " + str(error)) self.syncwaitdone = True return self.logm("MWorkerLib:update_callback_synchro", "is ok. number of updates is " + str(data)) self.syncwaitdone = True def syncWait(self): """ this will wait till data of error are not empty. it will do for self.SYNCHRO_TIMEOUT seconds. then it will return False also it will check what is return value from request. if update is 0, false, othervice true """ epoch = int(time.time()) while (((int(time.time()) - epoch) < self.SYNCHRO_TIMEOUT) and (self.syncwaitdone == False)): try: time.sleep(1) self.logm("MWorkerLib:syncWait", "inside waiting cycle :") except KeyboardInterrupt: break if (self.syncwaitdone == False): # cycle was broken before timeou return False try: # zkouska, zda se updatoval aspon jeden radek if (int(self.data) == 0): # mongo changed nothing, but there was no error return False else: return True except: pass # nothing found, cykluus end on timeout return False def deleteJobFromUnassignedSynchronised(self, job): """ this will delete selected job from unassigned this is synchron method... it will wait for ( synchron_timeout ) seconds, and return false :param job: :return: false on timeout ( synchron_timeout ) or if return is different from 1. """ self.syncwaitdone = False # zacatek locku self.logm("MWorkerLib:createMyJobInActive", "worker:" + self.workername + " is going to remove job from unassigned " + str(job)) self.meteorClient.remove('unassigned', {'_id': job['_id']}, callback=self.callback_synchro) res = self.syncWait() # konec locku self.logm("MWorkerLib:createMyJobInActive", "worker:" + self.workername + " removed " + str(job)+ "result is "+str(res)) return res #########################testing def testScenario1(self): """ this is scenario 1... this will move job from unassigned to active, then from active to trash... also it will list unassigned tasks :return: self.logm("MWorkerLib:testScenario1", "start test scenario 1") self.logm("MWorkerLib:testScenario1", "moving from unassigned to active") all_posts = self.meteorClient.find('unassigned') #job = (all_posts).keys() #get first unassigned: firstUnassigned=self.meteorClient.find('unassigned')[0] ttltmp=100 #pro testovaci ucely jsem vytvoril v active workera: # db.active.insert({"_id":"localhostworker","worker":"localhostworker","workerusername":"******","jobs":[]}) template={ 'pluginname':firstUnassigned['pluginname'], 'starttime':int(time.time()), #epocha 'ttl':ttltmp, 'inputparams':firstUnassigned['inputparams'], 'progress':0, 'result':"undefined" } #insert to active: #musim pouzit id_ protoze klient rve ze kod je insecure a musi se pouzit id #s _id je dalsi problem. protoze interne mongodb pouziva objekt, ne stringu #tak bude vyhodnejsi nahradit pri vytvoreni workeru v active _id s nejakym retezcem _ worker=self.meteorClient.find_one('active',{"worker" : "localhostworker"}) #worker["workerusername"]="******" self.logm("MWorkerLib:testScenario1", "worker:"+str(worker)+" "+worker['_id']) worker1=self.meteorClient.find_one('active',{"_id":worker["_id"]}) self.logm("MWorkerLib:testScenario1", "worker:"+str(worker1)+" "+worker1['_id']) self.meteorClient.update('active',{'_id':worker['_id']},{'$push':{'jobs':template}},callback=update_callback) #self.infiniteCycle() self.logm("MWorkerLib:testScenario1", "deleting job from unassigned") self.meteorClient.remove('unassigned',{'_id':firstUnassigned['_id']},callback=remove_callback) time.sleep(5) """ job = {'_id': "asdasdsad", 'jobname': "asdasd", 'pluginname': "asdasda", 'inputparams': "assad", 'expectedttl': "100"} #otestovane a funkcni 11.2.2016: #tohle presune job s danym jmenem do active pod jmeno mistniho workera... #self.moveJobFromUnassignedToActiveSynchronised("blabla") self.moveJobFromActiveToTrash("blabla")
class Client: def __init__(self, username, password, ui): self.username = username self.password = password self.ui = ui self.now = mktime(datetime.now().timetuple())*1e3 self.resume_token = '' self.client = MeteorClient('wss://kwak.io/websocket') self.client.connect() self.client.login(self.username, self.password, token=self.resume_token, callback=self.logged_in) self.hot_channels = [] self.hot_channels_name = [] self.all_channels_name = [] self.current_channel = 'dev' self.client.call('getHotChannels', [], self.set_hot_channels_name) self.client.call('channelList', [], self.set_all_channels_name) self.client.on('connected', self.connected) self.client.on('added', self.added) def set_hot_channels_name(self, error, result): if error: self.ui.chatbuffer_add(error) return self.hot_channels_name = result def set_all_channels_name(self, error, result): if error: self.ui.chatbuffer_add(error) return self.all_channels_name = result def subscribe_to_channel(self, channel): self.current_channel = channel try: self.client.unsubscribe('messages') except: pass self.ui.chatbuffer_add('* LISTENING TO CHANNEL {}'.format(channel)) self.client.subscribe('messages', [self.current_channel]) def subscribe_to_users(self, channel): self.client.subscribe('users', [channel]) def added(self, collection, id, fields): # only add new messages, not backlog if collection == 'messages' and fields['time'] > self.now: # fields : channel | time | text | user self.ui.chatbuffer_add('{}\t{}: {}'.format(fields['time'], fields['user'], fields['text'])) elif collection == 'users': # fields : username | profile | color if len(fields['profile']) > 0 and bool(fields['profile']['online']) == True: self.ui.userlist.append(fields['username']) self.ui.redraw_userlist() def connected(self): self.ui.chatbuffer_add('* CONNECTED') def logged_in(self, error, data): if error: self.ui.chatbuffer_add('LOGIN ERROR {}'.format(error)) else: self.resume_token = data['token'] self.client.call('setOnline', []) self.ui.chatbuffer_add('* LOGGED IN') def logout(self): self.ui.chatbuffer_add('* BYE (LOVELY DUCK)')
REFINER1_ID = 'refiner1id' REFINER2_ID = 'refiner12id' OBJS = { # REFINER1_ID: { # 'sensor': # 'pin': # }, # REFINER2_ID: { # 'sensor': # 'pin': # } } client = MeteorClient(URL) # def hello(): # print "hello, world" # t = Timer(30.0, hello) # t.start() def temp(id): sensor = OBJS[id]['sensor'] if sensor: t = sensor.get_temperature(W1ThermSensor.DEGREES_F) print 'Temp is: %.2f' % t return t else:
import os import time from MeteorClient import MeteorClient UNAME = os.environ.get('DICECLOUD_USER', '') PWD = os.environ.get('DICECLOUD_PWD', '').encode() client = MeteorClient('ws://dicecloud.com/websocket', debug=True) client.connect() print("Connected") while not client.connected: time.sleep(0.1) client.login(UNAME, PWD) print("Logged in") time.sleep(1) # wait until users collection has updated USER_ID = client.find_one('users', selector={'username': UNAME}).get('_id') print("User ID: " + USER_ID) char_id = 'Mtx98jb3c3wWcrWPj' def main(): # check_char() test_id() def test_id(): client.insert('characters', {
def __init__(self, debug=False): self.meteor_client = MeteorClient(SOCKET_BASE, debug=debug) self.http = DicecloudHTTP(API_BASE, API_KEY, debug=debug) self.logged_in = False
import time from MeteorClient import MeteorClient from datetime import datetime, timedelta from threading import Thread, Lock from collections import namedtuple from operator import attrgetter USERNAME = '******' PASSWORD = '******' SERVER = 'ws://152.228.80.179:3000/websocket' client = MeteorClient(SERVER) # How do we handle changes that are close to the dispensing period? # Keep a copy, then wipe the schedule. If the dosage is not scheduled for today... just add it # Otherwise, check if the time has already been passed... if it has skip it # If the time is close to the current time, check to see if it's already been/being dispensed # if it has, then skip it # Otherwise just add it... class Scheduler: def __init__(self): # Initialize the schedule self.schedule = [] # Start the dispensing task Thread(target = self.dispense).start() def refresh_schedule(self): threadLock.acquire() # In reality we shouldn't just naively wipe out the old schedule # like this self.schedule = []
Giampaolo Rodola's nettop simulator here: # https://github.com/giampaolo/psutil/blob/master/examples/nettop.py # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """ import time import sys import psutil from MeteorClient import MeteorClient # DDP python client based on the example here: # https://github.com/hharnisc/python-meteor/blob/master/example.py client = MeteorClient('ws://127.0.0.1:3000/websocket') # Meteor client callbacks def subscribed(subscription): print('* SUBSCRIBED {}'.format(subscription)) def connected(): print('* CONNECTED') def subscription_callback(error): if error: print(error) def insert_callback(error, data): if error: print(error)
import time import math import copy import random from drink_mixing import mymix from gesaltdrinkomatic import * from MeteorClient import MeteorClient client = MeteorClient('ws://127.0.0.1:3000/websocket') list_drinks=[]; list_drinks_alcohol=[]; list_drinks_bin=[]; #global list_drinks_alcohol_all #global list_drinks_bin_all #global list_drinks_all_final list_drinks_alcohol_all=[]; list_drinks_bin_all=[]; global count_old count_old=0 times=0 ########################### (Defining mix) ############################ mydict = {} #initialize drink list,n_drinks,radii
class MyProgram: def __init__(self): slackLog("Gate scanner started.") self.parents= {} #load parents self.client = MeteorClient('ws://chloe.asianhope.org:8080/websocket',debug=False) self.client.connect() self.client.login(METEOR_USERNAME,METEOR_PASSWORD) self.client.subscribe('cards') self.client.subscribe('scans') time.sleep(3) #give it some time to finish loading everything self.all_cards = self.client.find('cards') slackLog("Pulled records for: "+str(len(self.all_cards))+" cards") for card in self.all_cards: try: barcode = card['barcode'] name = card['name'] cardtype = card['type'] expires = card['expires'] profile = card.get('profile',barcode+".JPG") #default picture associations = card['associations'] self.parents.update({barcode:card}) except KeyError: slackLog(barcode+' has missing data',delay=True) pass # load style css for template screen = Gdk.Screen.get_default() css_provider = Gtk.CssProvider() css_provider.load_from_path('style.css') context = Gtk.StyleContext() context.add_provider_for_screen(screen, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) # connect to glade teamplate self.gladefile = "cardmanager.glade" self.glade = Gtk.Builder() self.glade.add_from_file(self.gladefile) self.glade.connect_signals(self) #get window from glade self.app_window=self.glade.get_object("main_window") # Window Name in GLADE self.app_window.fullscreen() # quit app self.app_window.connect("delete-event",Gtk.main_quit) #change color of window?? #self.green = gtk.gdk.color_parse('green') #self.black = gtk.gdk.color_parse('black') #self.app_window.modify_bg(gtk.STATE_NORMAL,self.black) # get objects from glade self.header = self.glade.get_object("header") self.header_context = self.header.get_style_context() self.header_title = self.glade.get_object("header_title") self.parent_image = self.glade.get_object("img_parent") self.child_container = self.glade.get_object("grid1") self.button_search = self.glade.get_object("btn_search") self.entry = self.glade.get_object("search_input") self.pname = self.glade.get_object("lbl_pname") self.pbarcode = self.glade.get_object("lbl_pbarcode") self.pexpires = self.glade.get_object("lbl_pexpires") self.error_message = self.glade.get_object("lbl_error_message") #add event to button_search self.button_search.connect("clicked", self.search_button_clicked, "3") # display children images pixbuf = Pixbuf.new_from_file("static/logo.png") scaled_buf = pixbuf.scale_simple(CHILD_DIMENSIONS_X,CHILD_DIMENSIONS_Y,InterpType.BILINEAR) self.pickup_students = ['0']*9 #seed the list with the size we want for i in range(0,9): self.pickup_students[i] = Gtk.Image() self.pickup_students[i].set_from_pixbuf(scaled_buf) self.label=Gtk.Table(3,3,True) self.label.attach(self.pickup_students[0],0,1,0,1) self.label.attach(self.pickup_students[1],1,2,0,1) self.label.attach(self.pickup_students[2],2,3,0,1) self.label.attach(self.pickup_students[3],0,1,1,2) self.label.attach(self.pickup_students[4],1,2,1,2) self.label.attach(self.pickup_students[5],2,3,1,2) self.label.attach(self.pickup_students[6],0,1,2,3) self.label.attach(self.pickup_students[7],1,2,2,3) self.label.attach(self.pickup_students[8],2,3,2,3) self.label.set_col_spacings(10) self.label.set_row_spacings(10) # add lebel of image to container in glade self.child_container.add(self.label) # display parent picture pixbuf = Pixbuf.new_from_file("static/logo.png") scaled_buf = pixbuf.scale_simple(PARENT_DIMENSIONS_X,PARENT_DIMENSIONS_Y,InterpType.BILINEAR) self.parent_image.set_from_pixbuf(scaled_buf) # self.button_search.can_default(True) # self.button_search.grab_default() self.entry.set_activates_default(True) self.app_window.set_focus(self.entry) self.error_message.set_text("") self.app_window.show_all() return def search_button_clicked(self, widget, data=None): associations = [] self.error_message.set_text("") # remove classes in header header_class_list = self.header_context.list_classes() for class_name in header_class_list: self.header_context.remove_class(class_name) for i in range(0,9): #make sure all pictures are reset pixbuf = Pixbuf.new_from_file("static/logo.png") scaled_buf = pixbuf.scale_simple(CHILD_DIMENSIONS_X,CHILD_DIMENSIONS_Y,InterpType.BILINEAR) self.pickup_students[i].set_from_pixbuf(scaled_buf) #grab pid pid = self.entry.get_text() slackLog('Scanned card: '+pid,delay=True) #do a lookup for the name try: #get parent information #parent_card = self.client.find_one('cards', selector={'barcode': pid}) parent_card = self.parents[pid] slackLog('```'+str(parent_card)+'```',delay=True) if not parent_card: self.header_title.set_text("Invalid Card!") self.header_context.add_class('header_invalid_card') self.pname.set_text("Card Not Found!") self.pbarcode.set_text("XXXX") self.pexpires.set_text("xxxx-xx-xx") pixbuf = Pixbuf.new_from_file("static/NA.JPG") scaled_buf = pixbuf.scale_simple(PARENT_DIMENSIONS_X,PARENT_DIMENSIONS_Y,InterpType.BILINEAR) self.parent_image.set_from_pixbuf(scaled_buf) else: pname = parent_card.get('name', pid) parent_picture = parent_card.get('profile',pid+".JPG") expires = parent_card.get('expires',"Expiry not set") barcode = parent_card.get('barcode',"Barcode not set") associations = parent_card.get('associations',[]) # if card expired if expires < date.today().isoformat(): associations = [] self.header_title.set_text("Card has expired!") self.header_context.add_class('header_expired') else: def getScanCallbackFunction(error, result): # if cannot get scan, display error message if error: self.header_title.set_text('Scan failed!') self.error_message.set_text(error['message']) self.header_context.add_class('header_invalid_card') return else: # if card no scan in, add new scan if result == None: # scan in action = 'Security Scan' value = 0.00 products = [] user = METEOR_USERNAME self.client.call('scanIn',[pid,action,value,products,user],scanInCallbackFunction) # if card already scan in, update scan else: # scan out scan_id = result['_id'] self.client.call('scanOut',[scan_id],scanOutCallbackFunction) def scanInCallbackFunction(error,result): # to check if card scan-in success or error if error: self.header_title.set_text('Scan failed!') self.error_message.set_text(error['message']) self.header_context.add_class('header_invalid_card') else: self.header_title.set_text("Scan-in") self.header_context.add_class('header_scan_in') def scanOutCallbackFunction(error,result): # to check if card scan-out success or error if error: self.header_title.set_text('Scan failed!') self.error_message.set_text(error['message']) self.header_context.add_class('header_invalid_card') else: self.header_title.set_text("Scan-out") self.header_context.add_class('header_scan_out') # get scan to check if scan in or scan out self.client.call('get_scan',[pid],getScanCallbackFunction) self.pname.set_text(pname) self.pbarcode.set_text(barcode) self.pexpires.set_text(expires) # load picture try: slackLog('loading parent picture: '+str(pid),delay=True) fetchPhotosByID(parent_picture) pixbuf = Pixbuf.new_from_file("resource/"+parent_picture) scaled_buf = pixbuf.scale_simple(PARENT_DIMENSIONS_X,PARENT_DIMENSIONS_Y,InterpType.BILINEAR) self.parent_image.set_from_pixbuf(scaled_buf) except Exception as inst: slackLog("No parent picture for: "+pid,delay=True) pixbuf = Pixbuf.new_from_file("static/unknown.jpg") scaled_buf = pixbuf.scale_simple(PARENT_DIMENSIONS_X,PARENT_DIMENSIONS_Y,InterpType.BILINEAR) self.parent_image.set_from_pixbuf(scaled_buf) except KeyError: slackLog('Scanned card: '+pid+' could not be found',delay=True) #display an error self.header_title.set_text("Invalid Card!") self.header_context.add_class('header_invalid_card') self.pname.set_text("Card Not Found!") self.pbarcode.set_text("XXXX") self.pexpires.set_text("xxxx-xx-xx") pixbuf = Pixbuf.new_from_file("static/NA.JPG") scaled_buf = pixbuf.scale_simple(PARENT_DIMENSIONS_X,PARENT_DIMENSIONS_Y,InterpType.BILINEAR) self.parent_image.set_from_pixbuf(scaled_buf) #reset everything self.entry.set_text('') self.app_window.set_focus(self.entry) self.app_window.show() #try and load the studnts starting after the parents name i = 0 if(len(associations)): pool = ThreadPool(len(associations)) results = pool.map(fetchPhotosByID,associations) for sid in associations: #if the student picture exists locally, load it try: pixbuf = Pixbuf.new_from_file("resource/"+sid+".JPG") scaled_buf = pixbuf.scale_simple(CHILD_DIMENSIONS_X,CHILD_DIMENSIONS_Y,InterpType.BILINEAR) self.pickup_students[i].set_from_pixbuf(scaled_buf) #if not, load the NA picture to indicate a student w/o a picture except: print("Unexpected error:```") print sys.exc_info()[0] pixbuf = Pixbuf.new_from_file("static/NA.JPG") scaled_buf = pixbuf.scale_simple(CHILD_DIMENSIONS_X,CHILD_DIMENSIONS_Y,InterpType.BILINEAR) self.pickup_students[i].set_from_pixbuf(scaled_buf) i+=1 #clear entry box and reset focus self.entry.set_text('') self.app_window.set_focus(self.entry) self.app_window.show()
import time from MeteorClient import MeteorClient client = MeteorClient('ws://127.0.0.1:3000/websocket') def subscribed(subscription): print('* SUBSCRIBED {}'.format(subscription)) def unsubscribed(subscription): print('* UNSUBSCRIBED {}'.format(subscription)) def added(collection, id, fields): print('* ADDED {} {}'.format(collection, id)) for key, value in fields.items(): print(' - FIELD {} {}'.format(key, value)) # query the data each time something has been added to # a collection to see the data `grow` all_lists = client.find('lists', selector={}) print('Lists: {}'.format(all_lists)) print('Num lists: {}'.format(len(all_lists))) # if collection == 'list' you could subscribe to the list here # with something like # client.subscribe('todos', id) # all_todos = client.find('todos', selector={}) # print 'Todos: {}'.format(all_todos)
def __init__(self): slackLog("Gate scanner started.") self.parents= {} #load parents self.client = MeteorClient('ws://chloe.asianhope.org:8080/websocket',debug=False) self.client.connect() self.client.login(METEOR_USERNAME,METEOR_PASSWORD) self.client.subscribe('cards') self.client.subscribe('scans') time.sleep(3) #give it some time to finish loading everything self.all_cards = self.client.find('cards') slackLog("Pulled records for: "+str(len(self.all_cards))+" cards") for card in self.all_cards: try: barcode = card['barcode'] name = card['name'] cardtype = card['type'] expires = card['expires'] profile = card.get('profile',barcode+".JPG") #default picture associations = card['associations'] self.parents.update({barcode:card}) except KeyError: slackLog(barcode+' has missing data',delay=True) pass # load style css for template screen = Gdk.Screen.get_default() css_provider = Gtk.CssProvider() css_provider.load_from_path('style.css') context = Gtk.StyleContext() context.add_provider_for_screen(screen, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) # connect to glade teamplate self.gladefile = "cardmanager.glade" self.glade = Gtk.Builder() self.glade.add_from_file(self.gladefile) self.glade.connect_signals(self) #get window from glade self.app_window=self.glade.get_object("main_window") # Window Name in GLADE self.app_window.fullscreen() # quit app self.app_window.connect("delete-event",Gtk.main_quit) #change color of window?? #self.green = gtk.gdk.color_parse('green') #self.black = gtk.gdk.color_parse('black') #self.app_window.modify_bg(gtk.STATE_NORMAL,self.black) # get objects from glade self.header = self.glade.get_object("header") self.header_context = self.header.get_style_context() self.header_title = self.glade.get_object("header_title") self.parent_image = self.glade.get_object("img_parent") self.child_container = self.glade.get_object("grid1") self.button_search = self.glade.get_object("btn_search") self.entry = self.glade.get_object("search_input") self.pname = self.glade.get_object("lbl_pname") self.pbarcode = self.glade.get_object("lbl_pbarcode") self.pexpires = self.glade.get_object("lbl_pexpires") self.error_message = self.glade.get_object("lbl_error_message") #add event to button_search self.button_search.connect("clicked", self.search_button_clicked, "3") # display children images pixbuf = Pixbuf.new_from_file("static/logo.png") scaled_buf = pixbuf.scale_simple(CHILD_DIMENSIONS_X,CHILD_DIMENSIONS_Y,InterpType.BILINEAR) self.pickup_students = ['0']*9 #seed the list with the size we want for i in range(0,9): self.pickup_students[i] = Gtk.Image() self.pickup_students[i].set_from_pixbuf(scaled_buf) self.label=Gtk.Table(3,3,True) self.label.attach(self.pickup_students[0],0,1,0,1) self.label.attach(self.pickup_students[1],1,2,0,1) self.label.attach(self.pickup_students[2],2,3,0,1) self.label.attach(self.pickup_students[3],0,1,1,2) self.label.attach(self.pickup_students[4],1,2,1,2) self.label.attach(self.pickup_students[5],2,3,1,2) self.label.attach(self.pickup_students[6],0,1,2,3) self.label.attach(self.pickup_students[7],1,2,2,3) self.label.attach(self.pickup_students[8],2,3,2,3) self.label.set_col_spacings(10) self.label.set_row_spacings(10) # add lebel of image to container in glade self.child_container.add(self.label) # display parent picture pixbuf = Pixbuf.new_from_file("static/logo.png") scaled_buf = pixbuf.scale_simple(PARENT_DIMENSIONS_X,PARENT_DIMENSIONS_Y,InterpType.BILINEAR) self.parent_image.set_from_pixbuf(scaled_buf) # self.button_search.can_default(True) # self.button_search.grab_default() self.entry.set_activates_default(True) self.app_window.set_focus(self.entry) self.error_message.set_text("") self.app_window.show_all() return
class BotWrapper: def __init__(self, url, magic_phrase, max_turns=10, callback=None, callback_params=1, msg_q=False): print('starting service') self.start_proba = 1.0 self.magic_phrase = magic_phrase self.url = replace_localhost(url) self.bot = Alice() self.max_turns = max_turns self.sending_message = False self._id = None self.use_msg_q = msg_q # msg_q sets whether or not we are queueing messages self.websocket = 'ws://%s/websocket' % self.url self.client = MeteorClient(self.websocket) self.client.ddp_client.ddpsocket.extra_headers = [('Bot', 'true')] print(self.client.ddp_client.ddpsocket.handshake_headers) self.client.connect() self.idle_time = 3 * 60 self.thread_time = 2 self.max_retry = 3 def restart_idler(self): ''' Restarts the idle watcher ''' print('restarting idler') if hasattr(self, 'idler_thread') and self.idler_thread: self.idler_thread.cancel() self.idler_thread = threading.Timer(self.idle_time, self.idle_user_handler) self.idler_thread.start() def idle_user_handler(self): """ Handler that disconnects conversation in the event that a user leaves """ print('user is idle disconnect') self.idler_thread = None self.end_convo() def login(self, user='******', pwd='botbot', callback=None, callback_params=0): print('logging in') def set_user(data): self.set_user_id(data['id']) print('user id set to', self._id) if callback and callback_params == 1: print('running callback with 1 parameter') callback(self) elif callback and callback_params == 0: callback() # TODO make this into threading timers. while not self._id: self.client.login(user, pwd, callback=func_wrap(set_user, params=1)) time.sleep(0.5) def logout(self): self.client.logout() # def find_and_join_room(self): # """ Finds a room and joins it """ # self.find_room(callback=(lambda roomId : self.join_room(roomId))) # # def find_room(self, callback=None): # print('looking for an open room') # def room_callback(): # print('looking for a room') # user = self.client.find_one('users') # print('user dict',user.items()) # if user["in_convo"]: # roomObj = user["curConvo"] # print('roomid: ', roomObj) # else: # openrooms = self.client.find('convos') # {curSessions : {$lt :2}} # roomObj = openrooms[0] if openrooms and len(openrooms) > 0 else -1 # # # TODO may have issues with room id when user is in convo # if roomObj != -1: # if type(roomObj) == str: # print(roomObj, 'room') # print('openrooms', openrooms) # callback(roomObj['_id']) # # Add user to room # # else: # print('No rooms found. Back to the bat cave') # self.subscribe('currentUser',params=[], callback=func_wrap( # lambda : room_callback() # ) # ) def subscribe(self, collection, params=[], callback=None): """ Wrapper for subscribe to avoid issues with already subscribed rooms """ try: print("subscribing to {}".format(collection)) self.client.subscribe(collection, params, callback) except MeteorClientException: print( 'Already subscribed to {}. Running callback with None'.format( collection)) if callback: callback(None) def join_room(self, roomId, otherUserId, callback=None): """ Join a room based on roomId """ print('join room with id', roomId) self.roomId = roomId self.msg_queue = [] self.available = False self.client.call( 'convos.addUserToRoom', params=[roomId, self.magic_phrase], callback=func_wrap(lambda: self.subscribe( 'chat', [roomId], func_wrap(lambda: self.subscribe( 'msgs', [roomId], func_wrap(lambda: self.subscribe( 'currentUsers', [roomId], func_wrap(lambda: self.watch_room( roomId, func_wrap(lambda: self.send_ready( roomId, otherUserId, callback))))))))))) def send_ready(self, roomId, otherUserId, callback=None): self.client.call('convos.botReady', params=[roomId, otherUserId, self.magic_phrase], callback=callback) def unsubscribe(self, collection): """ Unsubscribe from the collection """ try: self.client.unsubscribe(collection) except MeteorClientException: print('\t"{}" not subscribed to.'.format(collection)) def end_convo(self): """ End the conversation """ print('end conversation and unsubscribe from it all') self.client.remove_all_listeners('added') self.client.remove_all_listeners('changed') self.unsubscribe('chat') self.unsubscribe('msgs') self.unsubscribe('currentUsers') self.client.call('users.exitConvo', []) self.client.call('convos.updateRatings', [self.roomId, 'not']) self.available = True if hasattr(self, 'idler_thread') and self.idler_thread: self.idler_thread.cancel() def set_wpm(self): """ Set the words per minute of the bot """ wpm = random.randint(150, 200) self.cps = 60 / (wpm * 5) print('Setting wpm : {} '.format(wpm)) def prime_bot(self, convo_obj): """ the conversational bot """ print('convo_obj', convo_obj) input_msg = 'hi' if 'msgs' in convo_obj and convo_obj['msgs']: topic_msg_id = convo_obj['msgs'][0] msg_obj = self.client.find_one('messages', selector={'_id': topic_msg_id}) if msg_obj: input_msg = msg_obj['message'] msg = self.bot.message(input_msg, self.roomId) if random.random() > self.start_proba: self.send_message(msg) def watch_room(self, roomId, callback=None): """ Setup Event Listeneres for a room and checks to make sure that the room is updating """ self.turns = 0 convo_obj = self.client.find_one('convos', selector={'_id': roomId}) self.room_closed = convo_obj['closed'] self.set_wpm() self.last_message = "" self.confirmed_messages = [ ] # all messages sent by the user that have been confirmed self.thread = MessageHandlerThread(self) def message_added(collection, id, fields): """ callback for when a message is added """ if (collection == 'messages' and 'message' in fields and 'user' in fields): print(type(self._id), type(fields['user']), self._id, fields['user']) if fields['user'] != self._id and self.last_message != fields[ 'message']: self.restart_idler() self.receive_message(fields['message']) self.last_message = fields['message'] self.thread.message_received = True elif fields['user'] == self._id: print('\t messages from self detected') self.confirmed_messages.append(fields['message']) self.client.on('added', message_added) def watch_convo(collection, id, fields, cleared): """ callback for when any part of the conversation is updated """ if self.roomId and collection == "convos" and id == self.roomId: # print('\t',fields) if 'closed' in fields: print('\tRoom is closed: ', fields['closed']) self.room_closed = fields['closed'] self.end_convo() if 'msgs' in fields: print('\tMessages updated in convo "{}"'.format(id)) # TODO this is bugggy self.thread.convo_updated = True if 'turns' in fields: print('\tTurns updated to "{}"'.format(fields['turns'])) self.turns = fields['turns'] elif self.roomId == id: print(collection, id, fields) self.client.on('changed', watch_convo) # mark the bot as ready to talk self.restart_idler() self.prime_bot(convo_obj) print("before thread") self.thread.start() print("after thread") if callback: callback(None) def respond(self): """ Kind of a hacky way to respond to the conversation """ print("responding") if self.msg_queue and self.use_msg_q: partner_msg = self.msg_queue[0] self.msg_queue = self.msg_queue[1:] msg = self.bot.message(partner_msg, self.roomId) print(msg) self.send_message(msg) if self.msg_queue and not self.sending_message: partner_msg = self.msg_queue[-1] self.msg_queue = self.msg_queue[:-1] msg = self.bot.message(partner_msg, self.roomId) print(msg) self.send_message(msg) def still_in_conv(self): """ Returns whether the conversation is still moving """ in_conv = self.roomId != None and not self.client.find_one( 'convos', selector={'_id': self.roomId})['closed'] print('\tstill in conv', in_conv) if not in_conv: self.end_convo() print( '\tclosed: ', self.client.find_one('convos', selector={'_id': self.roomId})['closed']) return in_conv def get_convo_dict(self): if self.roomId: return self.client.find_one('convos', selector={'_id': self.roomId}) else: return {} def get_message(self, idx): ''' Returns the message at idx''' convo_dict = self.get_convo_dict() if convo_dict: topic_msg_id = convo_dict['msgs'][idx] msg_dict = self.client.find_one('messages', selector={'_id': topic_msg_id}) # print(msg_dict) if msg_dict: return msg_dict['message'] return '' def received_message(self, message): """ Checks whether the bot actually sent the message """ # TODO add handler that removes a confirmed message to save memory return message in self.confirmed_messages def retry_message(self, message, retry=0, callback=None): """ Handler that makes attempts to connect a user back into a conversation """ # TODO set as properties if retry == 0 or not self.received_message( message) and retry < self.max_retry: self.update_conversation(message, callback) if retry != 0: print('\t\tRetry {} of sending "{}"'.format(retry, message)) t = threading.Timer(self.thread_time, lambda: self.retry_message(message, retry + 1)) t.start() elif retry >= self.max_retry: print( '\tMax retries reached - couldn\'t verify whether {} was received' .format(message)) else: print('\t"{}" successfully received'.format(message)) def update_conversation(self, message, callback=None): self.client.call('convos.updateChat', [message, self.roomId], callback) def _send_message(self, message, callback=None): self.last_message_sent = message if self.still_in_conv(): self.retry_message(message, callback=callback) else: print('Not responding - conversation is OVER') self.sending_message = False def send_message(self, message, callback=None): # calculates typing speed based on rough cps for user sleep_time = self.cps * len(message) print("Preparing to send '{}' Waiting '{}' seconds.".format( message, sleep_time)) t = threading.Timer(sleep_time, lambda: self._send_message(message, callback)) t.start() def receive_message(self, message): """ Called whenever the bot receives a message """ print('Received "{}"'.format(message)) self.msg_queue.append(message) # message = 'sup then' # self.bot.message(message) # self.send_message(message) def set_user_id(self, id): self.available = True print('set user id to ', id) self._id = id
from MeteorClient import MeteorClient filename = "2018-winter-students.csv" season = "winter" program = "after-school" columns = [ "Timestamp", "Email Address", "Child's Full Name", "Child's Address", "Child Date of Birth ", "Parent/Guardian Contact Name", "Parent/Guardian Phone Number", "Parent/Guardian Email Address", "Emergency Contact Name", "Emergency Phone Number", "Child's Uniform Size", "Does your child have any dietary restrictions?", "If your child has previously participated in KCTL, please identify his/her team." ] client = MeteorClient('ws://127.0.0.1:80/websocket') client.connect() def calculate_age(year, month, day): today = date.today() return today.year - year - ((today.month, today.day) < (month, day)) def site_bucket(dob): print(dob) dob_l = dob.split("-") year = int(dob_l[2]) month = int(dob_l[1]) day = int(dob_l[0]) age = calculate_age(year, month, day)
ledcontrol6 = 15 ledname1 = 'First' ledname2 = 'Second' ledname3 = 'Third' ledname4 = 'Forth' ledname5 = 'Fifth' ledname6 = 'Sixth' from MeteorClient import MeteorClient client = MeteorClient('ws://127.0.0.1:3000/websocket') # client = MeteorClient('ws://testddp.meteor.com/websocket') def subscribed(subscription): print('* SUBSCRIBED {}'.format(subscription)) # conn = client.find_one('items', selector={'name': getHwAddr('eth0') }) # if subscription == 'local-items': # def getHwAddr(ifname): # s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # info = fcntl.ioctl(s.fileno(), 0x8927, struct.pack('256s', ifname[:15])) # return ':'.join(['%02x' % ord(char) for char in info[18:24]]) # print getHwAddr('eth0') # # new part # newmac = getHwAddr('eth0') # conn = client.find_one('items', selector={'name': newmac }) # print(format(conn))
class DDP(Thread): def __init__(self): Thread.__init__(self) self.meteor = conf.get('ddp', 'meteor') self.client = MeteorClient(self.meteor, debug=False) self.client.on('added', self.on_added) self.client.on('changed', self.on_changed) self.client.on('subscribed', self.on_subscribed) self.client.on('connected', self.on_connected) self.client.on('removed', self.on_removed) self.client.on('closed', self.on_closed) self.client.on('logged_in', self.on_logged_in) self.displayName = conf.get('ddp', 'room_name') self.vu_min = -50 self.vu_range = 50 self.vu_data = 0 self.last_vu = None self.ip = conf.get('ingest', 'address') self.id = conf.get('ingest', 'hostname') self._user = conf.get('ddp', 'user') self._password = conf.get('ddp', 'password') self._http_host = conf.get('ddp', 'http_host') self._audiostream_port = conf.get('audiostream', 'port') or 31337 self.store_audio = conf.get_boolean('ddp', 'store_audio') self.screenshot_file = conf.get('ddp', 'existing_screenshot') self.high_quality = conf.get_boolean('ddp', 'hq_snapshot') self.paused = False self.recording = False self.currentMediaPackage = None self.currentProfile = None self.has_disconnected = False screen = Gdk.Screen.get_default() self._screen_width = screen.get_width() self._screen_height = screen.get_height() self.cardindex = None cam_available = conf.get('ddp', 'cam_available') or 0 if cam_available in ('True', 'true', True, '1', 1): self.cam_available = 1 elif cam_available in ('False', 'false', False, '0', 0): self.cam_available = 0 else: self.cam_available = int(cam_available) # Getting audiostream params. either using existing audiostreaming server like icecast or the audiostream plugin if conf.get('ddp', 'existing_stream_host'): self._stream_host = conf.get('ddp', 'existing_stream_host') else: self._stream_host = self.ip if conf.get_int('ddp', 'existing_stream_port'): self._audiostream_port = conf.get_int('ddp', 'existing_stream_port') else: self._audiostream_port = conf.get_int('audiostream', 'port') or 31337 if conf.get('ddp', 'existing_stream_key'): self.stream_key = conf.get('ddp', 'existing_stream_key') else: self.stream_key = uuid.uuid4().get_hex() if conf.get('ddp', 'extra_params'): self.extra_params_list = conf.get('ddp', 'extra_params').split(';') else: self.extra_params_list = [] logger.info( 'audiostream URI: {}'.format('http://' + self._stream_host + ':' + str(self._audiostream_port) + '/' + self.stream_key)) dispatcher.connect('init', self.on_init) dispatcher.connect('recorder-vumeter', self.vumeter) dispatcher.connect('timer-short', self.update_vu) dispatcher.connect('timer-short', self.heartbeat) dispatcher.connect('recorder-started', self.on_start_recording) dispatcher.connect('recorder-stopped', self.on_stop_recording) dispatcher.connect('recorder-status', self.on_rec_status_update) def run(self): self.connect() def connect(self): if not self.has_disconnected: try: self.client.connect() except Exception: logger.warn('DDP connection failed') def update(self, collection, query, update): if self.client.connected and self.subscribedTo('GalicasterControl'): try: self.client.update(collection, query, update, callback=self.update_callback) except Exception: logger.warn("Error updating document " "{collection: %s, query: %s, update: %s}" % (collection, query, update)) def insert(self, collection, document): if self.client.connected and self.subscribedTo('GalicasterControl'): try: self.client.insert(collection, document, callback=self.insert_callback) except Exception: logger.warn( "Error inserting document {collection: %s, document: %s}" % (collection, document)) def heartbeat(self, element): if self.client.connected: self.update_images() else: self.connect() def on_start_recording(self, sender, id): self.recording = True self.currentMediaPackage = self.media_package_metadata(id) self.currentProfile = conf.get_current_profile().name self.update('rooms', {'_id': self.id}, { '$set': { 'currentMediaPackage': self.currentMediaPackage, 'currentProfile': self.currentProfile, 'recording': self.recording } }) def on_stop_recording(self, mpid, sender=None): self.recording = False self.currentMediaPackage = None self.currentProfile = None self.update('rooms', {'_id': self.id}, { '$unset': { 'currentMediaPackage': '', 'currentProfile': '' }, '$set': { 'recording': self.recording } }) self.update_images(1.5) def on_init(self, data): self.update_images(1.5) def update_images(self, delay=0.0): worker = Thread(target=self._update_images, args=(delay, )) worker.start() def _update_images(self, delay): time.sleep(delay) files = {} if not self.screenshot_file: # take a screenshot with pyscreenshot im = ImageGrab.grab(bbox=(0, 0, self._screen_width, self._screen_height), backend='imagemagick') else: try: # used if screenshot already exists im = Image.open(self.screenshot_file) except IOError as e: logger.warn("Unable to open screenshot file {0}".format( self.screenshot_file)) return output = cStringIO.StringIO() image_format = 'JPEG' if not self.high_quality: im.thumbnail((640, 360), Image.ANTIALIAS) else: image_format = 'PNG' if im.mode != "RGB": im = im.convert("RGB") im.save(output, format=image_format ) # to reduce jpeg size use param: optimize=True files['galicaster'] = ('galicaster.jpg', output.getvalue(), 'image/jpeg') try: # add verify=False for testing self signed certs requests.post( "%s/image/%s" % (self._http_host, self.id), files=files, auth=(self._user, self._password )) # to ignore ssl verification, use param: verify=False except Exception: logger.warn('Unable to post images') def vumeter(self, element, data, data_chan2, vu_bool): if data == "Inf": data = 0 else: if data < -self.vu_range: data = -self.vu_range elif data > 0: data = 0 self.vu_data = int( ((data + self.vu_range) / float(self.vu_range)) * 100) def update_vu(self, element): if self.vu_data != self.last_vu: update = {'vumeter': self.vu_data} self.update('rooms', {'_id': self.id}, {'$set': update}) self.last_vu = self.vu_data def on_rec_status_update(self, element, data): if data == 'paused': is_paused = True else: is_paused = False if is_paused: self.update_images(.75) if self.paused == is_paused: self.update('rooms', {'_id': self.id}, {'$set': { 'paused': is_paused }}) self.paused = is_paused if data == 'recording': self.update_images(.75) def media_package_metadata(self, id): mp = context.get('recorder').current_mediapackage line = mp.metadata_episode duration = mp.getDuration() line["duration"] = long(duration / 1000) if duration else None # FIXME Does series_title need sanitising as well as duration? created = mp.getDate() # line["created"] = calendar.timegm(created.utctimetuple()) for key, value in mp.metadata_series.iteritems(): line["series_" + key] = value for key, value in line.iteritems(): if value in [None, []]: line[key] = '' # return line return line def subscription_callback(self, error): if error: logger.warn("Subscription callback returned error: %s" % error) def insert_callback(self, error, data): if error: logger.warn("Insert callback returned error: %s" % error) def update_callback(self, error, data): if error: logger.warn("Update callback returned error: %s" % error) def on_subscribed(self, subscription): if (subscription == 'GalicasterControl'): me = self.client.find_one('rooms') # Data to push when inserting or updating data = { 'displayName': self.displayName, 'ip': self.ip, 'paused': self.paused, 'recording': self.recording, 'heartbeat': int(time.time()), 'camAvailable': self.cam_available, 'inputs': self.inputs(), 'stream': { 'host': self._stream_host, 'port': self._audiostream_port, 'key': self.stream_key } } # Parse extra Meteor Mongodb collection elements and append for params in self.extra_params_list: param = params.split(':') data[param[0]] = param[1] if self.currentMediaPackage: data['currentMediaPackage'] = self.currentMediaPackage if self.currentProfile: data['currentProfile'] = self.currentProfile if me: # Items to unset unset = {} if not self.currentMediaPackage: unset['currentMediaPackage'] = '' if not self.currentProfile: unset['currentProfile'] = '' # Update to push update = {'$set': data} if unset: update['$unset'] = unset self.update('rooms', {'_id': self.id}, update) else: data['_id'] = self.id self.insert('rooms', data) def inputs(self): inputs = {'presentations': ['Presentation']} inputs['cameras'] = [] labels = conf.get('ddp', 'cam_labels') cam_labels = [] if labels: cam_labels = [l.strip() for l in labels.split(',')] for i in range(0, self.cam_available): label = cam_labels[i] if i < len(cam_labels) else "Camera %d" % ( i + 1) inputs['cameras'].append(label) return inputs def on_added(self, collection, id, fields): pass def on_changed(self, collection, id, fields, cleared): me = self.client.find_one('rooms') if self.paused != me['paused']: self.set_paused(me['paused']) if context.get('recorder').is_recording() != me['recording']: self.set_recording(me) def on_removed(self, collection, id): self.on_subscribed(None) def set_paused(self, new_status): if not self.paused: self.paused = new_status context.get('recorder').pause() else: self.paused = False context.get('recorder').resume() def set_recording(self, me): self.recording = me['recording'] if self.recording: # FIXME: Metadata isn't passed to recorder meta = me.get('currentMediaPackage', {}) or {} profile = me.get('currentProfile', 'nocam') series = (meta.get('series_title', ''), meta.get('isPartOf', '')) user = { 'user_name': meta.get('creator', ''), 'user_id': meta.get('rightsHolder', '') } title = meta.get('title', 'Unknown') context.get('recorder').record() else: context.get('recorder').stop() def on_connected(self): logger.info('Connected to Meteor') token = conf.get('ddp', 'token') self.client.login(self._user, self._password, token=token) def on_logged_in(self, data): conf.set('ddp', 'token', data['token']) conf.update() try: self.client.subscribe('GalicasterControl', params=[self.id], callback=self.subscription_callback) except Exception: logger.warn('DDP subscription failed') def on_closed(self, code, reason): self.has_disconnected = True logger.error('Disconnected from Meteor: err %d - %s' % (code, reason)) def subscribedTo(self, publication): return self.client.subscriptions.get(publication) != None
class DicecloudClient: instance = None user_id = None def __init__(self, debug=False): self.meteor_client = MeteorClient(SOCKET_BASE, debug=debug) self.http = DicecloudHTTP(API_BASE, API_KEY, debug=debug) self.logged_in = False @classmethod def getInstance(cls): if cls.instance is None: try: cls.instance = cls(debug=TESTING) cls.instance.initialize() except: return None return cls.instance def initialize(self): log.info(f"Initializing Dicecloud Meteor client (debug={TESTING})") self.meteor_client.connect() loops = 0 while (not self.meteor_client.connected) and loops < 100: time.sleep(0.1) loops += 1 log.info(f"Connected to Dicecloud in {loops/10} seconds") def on_login(error, data): if data: type(self).user_id = data.get('id') self.logged_in = True else: log.warning(error) raise LoginFailure() self.meteor_client.login(UNAME, PWD, callback=on_login) loops = 0 while not self.logged_in and loops < 100: time.sleep(0.1) loops += 1 log.info(f"Logged in as {self.user_id}") async def ensure_connected(self): if self.logged_in: # everything is fine:tm: return asyncio.get_event_loop().run_in_executor(None, self.initialize) async def _get_list_id(self, character, list_name=None): """ :param character: (Character) the character to get the spell list ID of. :param list_name: (str) The name of the spell list to look for. Returns default if not passed. :return: (str) The default list id. """ char_id = character.upstream[10:] char = await self.get_character(char_id) if list_name: list_id = next((l for l in char.get('spellLists', []) if l['name'].lower() == list_name.lower()), None) else: list_id = next((l for l in char.get('spellLists', [])), None) return list_id async def get_character(self, charId): return await self.http.get(f'/character/{charId}/json') async def add_spell(self, character, spell): """Adds a spell to the dicecloud list.""" return await self.add_spells(character, [spell]) async def add_spells(self, character, spells, spell_list=None): """ :param character: (Character) The character to add spells for. :param spells: (list) The list of spells to add :param spell_list: (str) The spell list name to search for in Dicecloud. """ list_id = await self._get_list_id(character, spell_list) if not list_id: # still raise InsertFailure( "No matching spell lists on origin sheet. Run `!update` if this seems incorrect." ) return await self.http.post( f'/api/character/{character.upstream[10:]}/spellList/{list_id}', [s.to_dicecloud() for s in spells]) async def create_character(self, name: str = "New Character", gender: str = None, race: str = None, backstory: str = None): data = {'name': name, 'writers': [self.user_id]} if gender is not None: data['gender'] = gender if race is not None: data['race'] = race if backstory is not None: data['backstory'] = backstory data['settings'] = {'viewPermission': 'public'} # sharing is caring! response = await self.http.post('/api/character', data) return response['id'] async def delete_character(self, charId: str): await self.http.delete(f'/api/character/{charId}') async def get_user_id(self, username: str): username = urllib.parse.quote_plus(username) userId = await self.http.get(f'/api/user?username={username}') return userId['id'] async def transfer_ownership(self, charId: str, userId: str): await self.http.put(f'/api/character/{charId}/owner', {'id': userId}) async def insert_feature(self, charId, feature): return (await self.insert_features(charId, [feature]))[0] async def insert_features(self, charId: str, features: list): response = await self.http.post(f'/api/character/{charId}/feature', [f.to_dict() for f in features]) return response async def insert_proficiency(self, charId, prof): return (await self.insert_proficiencies(charId, [prof]))[0] async def insert_proficiencies(self, charId: str, profs: list): response = await self.http.post(f'/api/character/{charId}/prof', [p.to_dict() for p in profs]) return response async def insert_effect(self, charId, effect): return (await self.insert_effects(charId, [effect]))[0] async def insert_effects(self, charId: str, effects: list): response = await self.http.post(f'/api/character/{charId}/effect', [e.to_dict() for e in effects]) return response async def insert_class(self, charId, klass): return (await self.insert_classes(charId, [klass]))[0] async def insert_classes(self, charId: str, classes: list): response = await self.http.post(f'/api/character/{charId}/class', [c.to_dict() for c in classes]) return response
def __init__(self): Thread.__init__(self) self.meteor = conf.get('ddp', 'meteor') self.client = MeteorClient(self.meteor, debug=False) self.client.on('added', self.on_added) self.client.on('changed', self.on_changed) self.client.on('subscribed', self.on_subscribed) self.client.on('connected', self.on_connected) self.client.on('removed', self.on_removed) self.client.on('closed', self.on_closed) self.client.on('logged_in', self.on_logged_in) self.displayName = conf.get('ddp', 'room_name') self.vu_min = -50 self.vu_range = 50 self.vu_data = 0 self.last_vu = None self.ip = conf.get('ingest', 'address') self.id = conf.get('ingest', 'hostname') self._user = conf.get('ddp', 'user') self._password = conf.get('ddp', 'password') self._http_host = conf.get('ddp', 'http_host') self._audiostream_port = conf.get('audiostream', 'port') or 31337 self.store_audio = conf.get_boolean('ddp', 'store_audio') self.screenshot_file = conf.get('ddp', 'existing_screenshot') self.high_quality = conf.get_boolean('ddp', 'hq_snapshot') self.paused = False self.recording = False self.currentMediaPackage = None self.currentProfile = None self.has_disconnected = False screen = Gdk.Screen.get_default() self._screen_width = screen.get_width() self._screen_height = screen.get_height() self.cardindex = None cam_available = conf.get('ddp', 'cam_available') or 0 if cam_available in ('True', 'true', True, '1', 1): self.cam_available = 1 elif cam_available in ('False', 'false', False, '0', 0): self.cam_available = 0 else: self.cam_available = int(cam_available) # Getting audiostream params. either using existing audiostreaming server like icecast or the audiostream plugin if conf.get('ddp', 'existing_stream_host'): self._stream_host = conf.get('ddp', 'existing_stream_host') else: self._stream_host = self.ip if conf.get_int('ddp', 'existing_stream_port'): self._audiostream_port = conf.get_int('ddp', 'existing_stream_port') else: self._audiostream_port = conf.get_int('audiostream', 'port') or 31337 if conf.get('ddp', 'existing_stream_key'): self.stream_key = conf.get('ddp', 'existing_stream_key') else: self.stream_key = uuid.uuid4().get_hex() if conf.get('ddp', 'extra_params'): self.extra_params_list = conf.get('ddp', 'extra_params').split(';') else: self.extra_params_list = [] logger.info( 'audiostream URI: {}'.format('http://' + self._stream_host + ':' + str(self._audiostream_port) + '/' + self.stream_key)) dispatcher.connect('init', self.on_init) dispatcher.connect('recorder-vumeter', self.vumeter) dispatcher.connect('timer-short', self.update_vu) dispatcher.connect('timer-short', self.heartbeat) dispatcher.connect('recorder-started', self.on_start_recording) dispatcher.connect('recorder-stopped', self.on_stop_recording) dispatcher.connect('recorder-status', self.on_rec_status_update)
class Client: def __init__(self, username, password, ui): self.username = username self.password = password self.ui = ui self.ui.print_logo() self.now = mktime(datetime.now().timetuple())*1e3 self.resume_token = '' self.client = MeteorClient('wss://kwak.io/websocket') self.client.connect() self.client.login(self.username, self.password, token=self.resume_token, callback=self.logged_in) self.hot_channels = [] self.hot_channels_name = [] self.all_channels_name = [] self.current_channel = 'dev' self.client.call('getHotChannels', [], self.set_hot_channels_name) self.client.call('channelList', [], self.set_all_channels_name) self.client.on('connected', self.connected) self.client.on('added', self.added) """ Not usable right now """ """self.client.update('users', {'username': self.username}, {'profile.chans': self.current_channel}, callback=self.update_callback) """ """ def update_callback(self, error, result): self.ui.chatbuffer_add("UPDATED !") self.ui.chatbuffer_add(str(error)) self.ui.chatbuffer_add(str(result)) """ def set_hot_channels_name(self, error, result): if error: self.ui.chatbuffer_add(error) return self.hot_channels_name = result self.ui.chanlist = self.hot_channels_name self.ui.redraw_ui() def set_all_channels_name(self, error, result): if error: self.ui.chatbuffer_add(error) return self.all_channels_name = result def subscribe_to_channel(self, channel): self.current_channel = channel try: self.client.unsubscribe('messages') except: pass self.ui.chatbuffer_add('* LISTENING TO CHANNEL {}'.format(channel)) self.ui.redraw_chathead(channel) self.client.subscribe('messages', [self.current_channel]) def subscribe_to_users(self, channel): self.client.subscribe('users', [[channel]]) def added(self, collection, id, fields): # only add new messages, not backlog if collection == 'messages' and fields['time'] > self.now: # fields : channel | time | text | user timestamp = int(fields['time']) // 1000 timestamp = datetime.fromtimestamp(timestamp).strftime('%H:%M') self.ui.chatbuffer_add('{} {}: {}'.format( timestamp, fields['user'], fields['text'])) elif collection == 'users': # fields : username | profile | color if len(fields['profile']) and bool(fields['profile'].get('online', False)): self.ui.userlist.append(fields['username']) self.ui.redraw_ui() def connected(self): self.ui.chatbuffer_add('* CONNECTED') def logged_in(self, error, data): if error: self.ui.chatbuffer_add('LOGIN ERROR {}'.format(error)) else: self.resume_token = data['token'] self.client.call('setOnline', []) self.ui.chatbuffer_add('* LOGGED IN') # add self.username in userlist when logged and fix duplicates names def logout(self): self.ui.chatbuffer_add('* BYE (LOVELY DUCK)')
def __init__(self, queue): self.run = None self.queue = queue self.thread = threading.Thread(target=self.work) self.client = MeteorClient('ws://127.0.0.1:3000/websocket') self.client.on('connected', self.connected_event) self.client.connect() self.configs = { # run 'start_run': { 'method': 'startRun', 'callback': self.handle_run_call }, # suites 'start_suite': {'method': 'startSuite'}, 'end_suite': {'method': 'endSuite'}, # tests 'start_test': {'method': 'startTest'}, 'end_test': {'method': 'endTest'}, # keywords 'start_keyword': {'method': 'startKeyword'}, 'end_keyword': {'method': 'endKeyword'}, # messages 'log_message': {'method': 'logMessage'} }