mongodb_store.util module

mongodb_store.util.add_soma_fields(msg, doc)

For soma Object msgs adds the required fields as indexes to the mongodb object.

mongodb_store.util.check_connection_to_mongod(db_host, db_port, connection_string=None)

Check connection to mongod server

Returns:

bool : True on success, False if connection is not established.

mongodb_store.util.check_for_pymongo()

Checks for required version of pymongo python library.

Returns:

bool : True if found, otherwise Fale

mongodb_store.util.deserialise_message(serialised_message)

Create a ROS message from a mongodb_store_msgs/SerialisedMessage

Args:

serialised_message (mongodb_store_msgs.msg.SerialisedMessage): The message to deserialise

Returns:

ROS message: The message deserialised

mongodb_store.util.dictionary_to_message(dictionary, cls)

Create a ROS message from the given dictionary, using fill_message.

Args:

dictionary (dict): A dictionary containing all of the atributes of the message

cls (class): The python class of the ROS message type being reconstructed.

Returns:An instance of cls with the attributes filled.

Example:

>>> from geometry_msgs.msg import Pose
>>> d = {'orientation': {'w': 0.0, 'x': 0.0, 'y': 0.0, 'z': 0.0},
   'position': {'x': 27.0, 'y': 0.0, 'z': 0.0}}
>>> dictionary_to_message(d, Pose)
position:
  x: 27.0
  y: 0.0
  z: 0.0
orientation:
  x: 0.0
  y: 0.0
  z: 0.0
  w: 0.0

mongodb_store.util.document_to_msg(document, TYPE)

mongodb_store.util.document_to_msg_and_meta(document, TYPE)

mongodb_store.util.fill_message(message, document)

Fill a ROS message from a dictionary, assuming the slots of the message are keys in the dictionary.

Args:

message (ROS message): An instance of a ROS message that will be filled in

document (dict): A dicionary containing all of the message attributes

Example:

>>> from geometry_msgs.msg import Pose
>>> d = dcu.msg_to_document(Pose())
>>> d['position']['x']=27.0
>>> new_pose = Pose(
>>> fill_message(new_pose, d)
>>>  new_pose
position:
  x: 27.0
  y: 0.0
  z: 0.0
orientation:
  x: 0.0
  y: 0.0
  z: 0.0
  w: 0.0

mongodb_store.util.import_MongoClient()

mongodb_store.util.load_class(full_class_string)

Dynamically load a class from a string shamelessly ripped from: http://thomassileo.com/blog/2012/12/21/dynamically-load-python-modules-or-classes/

Args:

full_class_string (str): The python class to dynamically load

Returns:

class: the loaded python class.

mongodb_store.util.msg_to_document(msg)

Given a ROS message, turn it into a (nested) dictionary suitable for the datacentre.

>>> from geometry_msgs.msg import Pose
>>> msg_to_document(Pose())
{'orientation': {'w': 0.0, 'x': 0.0, 'y': 0.0, 'z': 0.0},
'position': {'x': 0.0, 'y': 0.0, 'z': 0.0}}

Args:

msg (ROS Message): An instance of a ROS message to convert

Returns:

dict : A dictionary representation of the supplied message.

mongodb_store.util.query_message(collection, query_doc, sort_query=[], projection_query={}, find_one=False, limit=0)

Peform a query for a stored messages, returning results in list.

Args:

collection (pymongo.Collection): The collection to query

query_doc (dict): The MongoDB query to execute

sort_query (list of tuple): The MongoDB query to sort

projection_query (dict): The projection query

find_one (bool): Returns one matching document if True, otherwise all matching.

limit (int): Limits number of return documents. 0 means no limit

Returns:

dict or list of dict: the MongoDB document(s) found by the query

mongodb_store.util.query_message_ids(collection, query_doc, find_one)

Peform a query for a stored message, returning a tuple of id strings

Args:

collection (pymongo.Collection): The collection to search

query_doc (dict): The MongoDB query to execute

find_one (bool): Find one matching document if True, otherwise all matching.

Returns:

tuple of strings: all ObjectIds of matching documents

mongodb_store.util.sanitize_value(attr, v, type)

De-rosify a msg.

Internal function used to convert ROS messages into dictionaries of pymongo insertable values.

Args:

attr(str): the ROS message slot name the value came from

v: the value from the message’s slot to make into a MongoDB able type

type (str): The ROS type of the value passed, as given by the ressage slot_types member.

Returns:

A sanitized version of v.

mongodb_store.util.serialise_message(message)

Create a mongodb_store_msgs/SerialisedMessage instance from a ROS message.

Args:

message (ROS message): The message to serialise

Returns:

mongodb_store_msgs.msg.SerialisedMessage: A serialies copy of message

mongodb_store.util.store_message(collection, msg, meta, oid=None)

Update ROS message into the DB

Args:

collection (pymongo.Collection): the collection to store the message in

msg (ROS message): an instance of a ROS message to store

meta (dict): Additional meta data to store with the ROS message

oid (str): An optional ObjectID for the MongoDB document created.

Returns:

str: ObjectId of the MongoDB document.

mongodb_store.util.store_message_no_meta(collection, msg)

Store a ROS message sans meta data.

Args:

collection (pymongo.Collection): The collection to store the message in

msg (ROS message): An instance of a ROS message to store

Returns:

str: The ObjectId of the MongoDB document created.

mongodb_store.util.string_pair_list_to_dictionary(spl)

Creates a dictionary from a mongodb_store_msgs/StringPairList which could contain JSON as a string. If the first entry in the supplied list is a JSON query then the returned dictionary is loaded from that.

Args:

spl (StringPairList): The list of (key, value) pairs to convert

Returns:

dict: resulting dictionary

mongodb_store.util.string_pair_list_to_dictionary_no_json(spl)

Covert a mongodb_store_msgs/StringPairList into a dictionary, ignoring content

Args:

spl (StringPairList): The list of (key, value) to pairs convert

Returns:

dict: resulting dictionary

mongodb_store.util.topic_name_to_collection_name(topic_name)

Converts the fully qualified name of a topic into legal mongodb collection name.

mongodb_store.util.type_to_class_string(type)

Takes a ROS msg type and turns it into a Python module and class name.

E.g

>>> type_to_class_string("geometry_msgs/Pose")
geometry_msgs.msg._Pose.Pose

Args:

type (str): The ROS message type to return class string

Returns:

str: A python class string for the ROS message type supplied

mongodb_store.util.update_message(collection, query_doc, msg, meta, upsert)

Update ROS message in the DB, return updated id and true if db altered.

Args:

collection (pymongo.Collection): The collection to update in

query_doc (dict): The MongoDB query to execute to select document for update

msg (ROS message): An instance of a ROS message to update to

meta (dict): New meta data to update the stored message with

upsert (bool): If message does not already exits, create if upsert==True.

Returns:

str, bool: the OjectId of the updated document and whether it was altered by the operation

mongodb_store.util.wait_for_mongo(timeout=60, ns='/datacentre')

Waits for the mongo server, as started through the mongodb_store/mongodb_server.py wrapper

Returns:

bool : True on success, False if server not even started.