Source Code for Module rospy.msproxy

  1  # Software License Agreement (BSD License) 
  2  # 
  3  # Copyright (c) 2008, Willow Garage, Inc. 
  4  # All rights reserved. 
  5  # 
  6  # Redistribution and use in source and binary forms, with or without 
  7  # modification, are permitted provided that the following conditions 
  8  # are met: 
  9  # 
 10  #  * Redistributions of source code must retain the above copyright 
 11  #    notice, this list of conditions and the following disclaimer. 
 12  #  * Redistributions in binary form must reproduce the above 
 13  #    copyright notice, this list of conditions and the following 
 14  #    disclaimer in the documentation and/or other materials provided 
 15  #    with the distribution. 
 16  #  * Neither the name of Willow Garage, Inc. nor the names of its 
 17  #    contributors may be used to endorse or promote products derived 
 18  #    from this software without specific prior written permission. 
 19  # 
 20  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 21  # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 22  # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 23  # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
 24  # COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
 25  # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
 26  # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
 27  # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
 28  # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 29  # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
 30  # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 31  # POSSIBILITY OF SUCH DAMAGE. 
 32  # 
 33  # Revision $Id$ 
 34  """ 
 35  Master/Slave XML-RPC Wrappers. 
 36   
 37  The L{MasterProxy} simplifies usage of master/slave 
 38  APIs by automatically inserting the caller ID and also adding python 
 39  dictionary accessors on the parameter server. 
 40  """ 
 41   
 42  from threading import Lock 
 43   
 44  import rospy.core 
 45  import rospy.exceptions 
 46  import rospy.names 
 47   
 48  import rospy.impl.paramserver 
 49  import rospy.impl.masterslave 
 50   
 51  _master_arg_remap = {  
 52      'deleteParam': [0], # remap key 
 53      'setParam': [0], # remap key 
 54      'getParam': [0], # remap key 
 55      'searchParam': [0], # remap key 
 56      'subscribeParam': [0], # remap key 
 57      'unsubscribeParam': [0], # remap key 
 58      'hasParam': [0], # remap key 
 59      'registerService': [0], # remap service 
 60      'lookupService': [0], # remap service 
 61      'unregisterService': [0], # remap service 
 62      'registerSubscriber': [0], # remap topic 
 63      'unregisterSubscriber': [0], # remap topic     
 64      'registerPublisher': [0], # remap topic    
 65      'unregisterPublisher': [0], # remap topic    
 66      'lookupNode': [0], # remap node 
 67      'getPublishedTopics': [0], # remap subgraph 
 68      } 
 69       
 70 -class MasterProxy(object): 
 71      """ 
 72      Convenience wrapper for ROS master API and XML-RPC 
 73      implementation. The Master API methods can be invoked on this 
 74      object and will be forwarded appropriately. Names in arguments 
 75      will be remapped according to current node settings. Provides 
 76      dictionary-like access to parameter server, e.g.:: 
 77       
 78        master[key] = value 
 79   
 80      All methods are thread-safe. 
 81      """ 
 82   
 83 -    def __init__(self, uri): 
 84          """ 
 85          Constructor for wrapping a remote master instance. 
 86          @param uri: XML-RPC URI of master 
 87          @type  uri: str 
 88          """ 
 89          self.target = rospy.core.xmlrpcapi(uri)         
 90          self._lock = Lock() 
 91   
 92 -    def __getattr__(self, key): #forward api calls to target 
 93          if key in _master_arg_remap: 
 94              remappings = _master_arg_remap[key] 
 95          else: 
 96              remappings = rospy.impl.masterslave.ROSHandler.remappings(key) 
 97          def wrappedF(*args, **kwds): 
 98              args = [rospy.names.get_caller_id(),]+list(args) 
 99              #print "Remap indicies", remappings 
100              for i in remappings: 
101                  i = i + 1 #callerId does not count 
102                  #print "Remap %s => %s"%(args[i], rospy.names.resolve_name(args[i])) 
103                  args[i] = rospy.names.resolve_name(args[i]) 
104              with self._lock: 
105                  f = getattr(self.target, key) 
106                  return f(*args, **kwds) 
107          return wrappedF 
108   
109 -    def __getitem__(self, key): 
110          """ 
111          Fetch item from parameter server and subscribe to future updates so that 
112          values can be cached. 
113          @param key: parameter key 
114          @type key: str 
115          @raise KeyError: if key is not set 
116          """ 
117          #NOTE: remapping occurs here! 
118          resolved_key = rospy.names.resolve_name(key) 
119          if 1: # disable param cache 
120              with self._lock: 
121                  code, msg, value = self.target.getParam(rospy.names.get_caller_id(), resolved_key) 
122              if code != 1: #unwrap value with Python semantics 
123                  raise KeyError(key) 
124              return value 
125   
126          try: 
127              # check for value in the parameter server cache 
128              return rospy.impl.paramserver.get_param_server_cache().get(resolved_key) 
129          except KeyError: 
130              # first access, make call to parameter server 
131              with self._lock: 
132                  code, msg, value = self.target.subscribeParam(rospy.names.get_caller_id(), rospy.core.get_node_uri(), resolved_key) 
133              if code != 1: #unwrap value with Python semantics 
134                  raise KeyError(key) 
135              # set the value in the cache so that it's marked as subscribed 
136              rospy.impl.paramserver.get_param_server_cache().set(resolved_key, value) 
137              return value 
138           
139 -    def __setitem__(self, key, val): 
140          """ 
141          Set parameter value on Parameter Server 
142          @param key: parameter key 
143          @type key: str 
144          @param val: parameter value 
145          @type val: XMLRPC legal value 
146          """ 
147          with self._lock: 
148              self.target.setParam(rospy.names.get_caller_id(), rospy.names.resolve_name(key), val) 
149           
150 -    def search_param(self, key): 
151          """ 
152          Search for a parameter matching key on the parameter server 
153          @return: found key or None if search did not succeed 
154          @rtype: str 
155          @raise ROSException: if parameter server reports an error 
156          """ 
157          # #1810 searchParam has to use unresolved form of mappings 
158          mappings = rospy.names.get_mappings() 
159          if key in mappings: 
160              key = mappings[key] 
161          with self._lock: 
162              code, msg, val = self.target.searchParam(rospy.names.get_caller_id(), key) 
163          if code == 1: 
164              return val 
165          elif code == -1: 
166              return None 
167          else: 
168              raise rospy.exceptions.ROSException("cannot search for parameter: %s"%msg) 
169           
170 -    def __delitem__(self, key): 
171          """ 
172          Delete parameter key from the parameter server. 
173          @raise KeyError: if key is not set 
174          @raise ROSException: if parameter server reports an error 
175          """ 
176          resolved_key = rospy.names.resolve_name(key) 
177          with self._lock: 
178              code, msg, _ = self.target.deleteParam(rospy.names.get_caller_id(), resolved_key) 
179          if code == -1: 
180              raise KeyError(key) 
181          elif code != 1: 
182              raise rospy.exceptions.ROSException("cannot delete parameter: %s"%msg) 
183          elif 0: #disable parameter cache 
184              # set the value in the cache so that it's marked as subscribed 
185              rospy.impl.paramserver.get_param_server_cache().delete(resolved_key) 
186   
187 -    def __contains__(self, key): 
188          """ 
189          Check if parameter is set on Parameter Server 
190          @param key: parameter key 
191          @type key: str 
192          @raise ROSException: if parameter server reports an error 
193          """         
194          with self._lock: 
195              code, msg, value = self.target.hasParam(rospy.names.get_caller_id(), rospy.names.resolve_name(key)) 
196          if code != 1: 
197              raise rospy.exceptions.ROSException("cannot check parameter on server: %s"%msg) 
198          return value 
199           
200 -    def __iter__(self): 
201          """ 
202          @raise ROSException: if parameter server reports an error 
203          """ 
204          with self._lock: 
205              code, msg, value = self.target.getParamNames(rospy.names.get_caller_id()) 
206          if code == 1: 
207              return value.__iter__() 
208          else: 
209              raise rospy.exceptions.ROSException("cannot retrieve parameter names: %s"%msg) 
210