1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 from __future__ import with_statement
36
37 import sys
38
39 import roslib.message
40
41 import rosgraph.masterapi
42 import rosmsg
43 import rosservice
44 import rospy
45
46 from rosh.impl.exceptions import ROSHException
47 from rosh.impl.namespace import Namespace, Concept
48
49 -def Service(service_name, service_type, handler):
50 if type(service_name) == Namespace:
51 return rospy.Service(service_name._name, service_type, handler)
52 else:
53 return rospy.Service(service_name, service_type, handler)
54
56
57
58 type_name = rosservice.get_service_type(service_name)
59 if type_name:
60 val = roslib.message.get_service_class(type_name, reload_on_error=True)
61 if not val:
62 pkg, base_type = roslib.names.package_resource_name(type_name)
63 print >> sys.stderr, """Cannot retrieve type [%s].
64 Please type 'rosmake %s'
65 """%(type_name, pkg)
66 else:
67 return val
68
71 self.name, self.node, self.uri = name, node, uri
75 return "Name: %s\nNode: %s\nURI: %s"%(self.name, self.node, self.uri)
76
77
79 master = config.ctx.master
80 try:
81 uri = master.lookupService(name)
82 except rosgraph.masterapi.Error:
83 return None
84
85
86
87
88 _, _, srvs = master.getSystemState()
89 l = [nodelist for s, nodelist in srvs if s == name][0]
90 node_name = l[0]
91 node = config.ctx.nodes[node_name]
92 return ServiceInfo(name, node, uri)
93
95
97 """
98 ctor.
99 @param config: Namespace configuration instance. Safe to set
100 to None if self._config is initialize proper to calling any
101 methods.
102 @type config: L{NamespaceConfig}
103 """
104 super(ServiceNS, self).__init__(name, config)
105 self._type = self._service_info = None
106 self._init_type()
107 self._is_wait_for_service = True
108
110 """
111 info() API
112 """
113 if self._service_info is None:
114 self._service_info = service_info(self._config, self._name)
115 return self._service_info
116
118 """
119 Override Namespace._list()
120 """
121
122 return [s for s in rosservice.get_service_list(namespace=self._ns) if not s.startswith('/rosh_')]
123
125 "rostype() API"
126 return self._type
127
129 "rostype() API"
130 self._init_type(type_)
131
133 if self._type is not None and t is None:
134
135 return
136
137 if t is None:
138 try:
139 self._type = get_service_class_by_service_name(self._name)
140 self._type_name = self._type._type
141 except:
142
143
144
145 self._type = self._type_name = None
146 else:
147 if type(t) == str:
148 t = roslib.message.get_service_class(t)
149 if t is None:
150 raise ValueError("cannot load service type: %s"%(t))
151 else:
152 if not type(t) == type:
153 raise ValueError("invalid service type: %s"%(type(t)))
154 if not issubclass(t, roslib.message.ServiceDefinition):
155 raise ValueError("invalid service type: %s"%(t.__class__.__name__))
156 self._type = t
157 self._type_name = t._type
158
161
163 if self._type is None:
164 self._init_type()
165 if self._type is None:
166 return self._ns
167 else:
168 return rosmsg.get_srv_text(self._type._type)
169
171 return ['wait_for_service']
172
174 self._is_wait_for_service = val
175
177 """
178 Call service
179 """
180
181 if self._type is None:
182 self._init_type()
183 if self._type is None:
184 raise ROSHException("cannot call service [%s]: unknown type"%(self._ns))
185
186
187 if self._is_wait_for_service:
188 rospy.wait_for_service(self._ns)
189 request = self._type._request_class(*args, **kwds)
190 return rospy.ServiceProxy(self._ns, self._type)(request)
191
196