def resolve(self, definitions): """ Resolve named references to other WSDL objects. @param definitions: A definitions object. @type definitions: L{Definitions} """ for op in self.operations.values(): if op.input is None: op.input = Message(Element("no-input"), definitions) else: qref = qualify(op.input, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % (op.input,)) op.input = msg if op.output is None: op.output = Message(Element("no-output"), definitions) else: qref = qualify(op.output, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % (op.output,)) op.output = msg for f in op.faults: qref = qualify(f.message, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % (f.message,)) f.message = msg
def resolve(self, definitions): """ Resolve named references to other WSDL objects. @param definitions: A definitions object. @type definitions: L{Definitions} """ for op in self.operations.values(): if op.input is None: op.input = Message(Element("no-input"), definitions) else: qref = qualify(op.input, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % (op.input, )) op.input = msg if op.output is None: op.output = Message(Element("no-output"), definitions) else: qref = qualify(op.output, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % (op.output, )) op.output = msg for f in op.faults: qref = qualify(f.message, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % (f.message, )) f.message = msg
def query(self, name): """ blindly query the schema by name """ log.debug('searching schema for (%s)', name) schema = self.schema wsdl = self.wsdl() if wsdl is None: qref = qualify(name, schema.root, schema.tns) else: qref = qualify(name, wsdl.root, wsdl.tns) query = BlindQuery(qref) result = query.execute(schema) return (result, [])
def resolveheaders(self, definitions, op): """ Resolve SOAP header I{message} references. @param definitions: A definitions object. @type definitions: L{Definitions} @param op: An I{operation} object. @type op: I{operation} """ soap = op.soap headers = soap.input.headers + soap.output.headers for header in headers: mn = header.message ref = qualify(mn, self.root, definitions.tns) message = definitions.messages.get(ref) if message is None: raise Exception("message '%s', not-found" % (mn, )) pn = header.part for p in message.parts: if p.name == pn: header.part = p break if pn == header.part: raise Exception("message '%s' has not part named '%s'" % (ref, pn))
def __getref(self, a, tns): """ Get the qualified value of attribute named 'a'.""" s = self.root.get(a) if s is None: return s else: return qualify(s, self.root, tns)
def resolveheaders(self, definitions, op): """ Resolve SOAP header I{message} references. @param definitions: A definitions object. @type definitions: L{Definitions} @param op: An I{operation} object. @type op: I{operation} """ soap = op.soap headers = soap.input.headers + soap.output.headers for header in headers: mn = header.message ref = qualify(mn, self.root, definitions.tns) message = definitions.messages.get(ref) if message is None: raise Exception("message '%s', not-found" % (mn,)) pn = header.part for p in message.parts: if p.name == pn: header.part = p break if pn == header.part: raise Exception("message '%s' has not part named '%s'" % ( ref, pn))
def query(self, name, node): """ blindly query the schema by name """ log.debug('searching schema for (%s)', name) qref = qualify(name, node, node.namespace()) query = BlindQuery(qref) result = query.execute(self.schema) return (result, [])
def do_resolve(self, definitions): """ Resolve named references to other WSDL objects. Ports without SOAP bindings are discarded. @param definitions: A definitions object. @type definitions: L{Definitions} """ filtered = [] for p in self.ports: ref = qualify(p.binding, self.root, definitions.tns) binding = definitions.bindings.get(ref) if binding is None: raise Exception("binding '%s', not-found" % (p.binding,)) if binding.soap is None: log.debug("binding '%s' - not a SOAP binding, discarded", binding.name) continue # After we have been resolved, our caller will expect that the # binding we are referencing has been fully constructed, i.e. # resolved, as well. The only scenario where the operations binding # might possibly not have already resolved its references, and # where this explicit resolve() call is required, is if we are # dealing with a recursive WSDL import chain. binding.resolve(definitions) p.binding = binding filtered.append(p) self.ports = filtered
def do_resolve(self, definitions): """ Resolve named references to other WSDL objects. Ports without SOAP bindings are discarded. @param definitions: A definitions object. @type definitions: L{Definitions} """ filtered = [] for p in self.ports: ref = qualify(p.binding, self.root, definitions.tns) binding = definitions.bindings.get(ref) if binding is None: raise Exception("binding '%s', not-found" % (p.binding, )) if binding.soap is None: log.debug("binding '%s' - not a SOAP binding, discarded", binding.name) continue # After we have been resolved, our caller will expect that the # binding we are referencing has been fully constructed, i.e. # resolved, as well. The only scenario where the operations binding # might possibly not have already resolved its references, and # where this explicit resolve() call is required, is if we are # dealing with a recursive WSDL import chain. binding.resolve(definitions) p.binding = binding filtered.append(p) self.ports = filtered
def known(self, node): """ resolve type referenced by @xsi:type """ ref = node.get('type', Namespace.xsins) if ref is None: return None qref = qualify(ref, node, node.namespace()) query = BlindQuery(qref) return query.execute(self.schema)
def resolve(self, definitions): """ Resolve named references to other WSDL objects. @param definitions: A definitions object. @type definitions: L{Definitions} """ for op in self.operations.values(): qref = qualify(op.input, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % op.input) else: op.input = msg qref = qualify(op.output, self.root, definitions.tns) msg = definitions.messages.get(qref) if msg is None: raise Exception("msg '%s', not-found" % op.output) else: op.output = msg
def resolveoppolicies(self, definitions, msg): policies = [] for policy_name in msg.policies: ref = qualify(policy_name, self.root, definitions.tns) policy = definitions.policies.get(ref) if policy is None: raise Exception("policy '%s', not-found" % policy_name) else: policies.append(policy) msg.policies = policies
def resolveport(self, definitions): """ Resolve port_type reference. @param definitions: A definitions object. @type definitions: L{Definitions} """ ref = qualify(self.type, self.root, definitions.tns) port_type = definitions.port_types.get(ref) if port_type is None: raise Exception("portType '%s', not-found" % self.type) else: self.type = port_type
def qualify(self, name): """ Qualify the name as either: - plain name - ns prefixed name (eg: ns0:Person) - fully ns qualified name (eg: {http://myns-uri}Person) @param name: The name of an object in the schema. @type name: str @return: A qualifed name. @rtype: qname """ m = self.altp.match(name) if m is None: return qualify(name, self.wsdl.root, self.wsdl.tns) else: return (m.group(4), m.group(2))
def resolve(self, definitions): """ Resolve named references to other WSDL objects. Ports without soap bindings are discarded. @param definitions: A definitions object. @type definitions: L{Definitions} """ filtered = [] for p in self.ports: ref = qualify(p.binding, self.root, definitions.tns) binding = definitions.bindings.get(ref) if binding is None: raise Exception("binding '%s', not-found" % p.binding) if binding.soap is None: log.debug('binding "%s" - not a soap, discarded', binding.name) continue p.binding = binding filtered.append(p) self.ports = filtered
def qualify(self): """ Convert attribute values, that are references to other objects, into I{qref}. Qualfied using default document namespace. Since many wsdls are written improperly: when the document does not define a default namespace, the schema target namespace is used to qualify references. """ defns = self.root.defaultNamespace() if Namespace.none(defns): defns = self.schema.tns for a in self.autoqualified(): ref = getattr(self, a) if ref is None: continue if isqref(ref): continue qref = qualify(ref, self.root, defns) log.debug('%s, convert %s="%s" to %s', self.id, a, ref, qref) setattr(self, a, qref)
def _filter_faults(document, operation, operation_bindings, message_qrefs, tns): filtered_faults = {} for fault in operation.getChildren('fault', wsdl.wsdlns): fault_message = fault.get('message') qref = xsd.qualify(fault_message, document, tns) if qref not in message_qrefs: filtered_faults[fault.get('name')] = fault for fault in filtered_faults.values(): operation.remove(fault) if filtered_faults: for binding in operation_bindings: filtered_binding_faults = [] faults = binding[operation.get('name')].getChildren( 'fault', wsdl.wsdlns) for binding_fault in faults: if binding_fault.get('name') in filtered_faults: filtered_binding_faults.append(binding_fault) for binding_fault in filtered_binding_faults: binding[operation.get('name')].remove(binding_fault)
def __resolveport(self, definitions): """ Resolve port_type reference. @param definitions: A definitions object. @type definitions: L{Definitions} """ ref = qualify(self.type, self.root, definitions.tns) port_type = definitions.port_types.get(ref) if port_type is None: raise Exception("portType '%s', not-found" % (self.type, )) # Later on we will require access to the message data referenced by # this port_type instance, and in order for those data references to be # available, port_type first needs to dereference its message # identification string. The only scenario where the port_type might # possibly not have already resolved its references, and where this # explicit resolve() call is required, is if we are dealing with a # recursive WSDL import chain. port_type.resolve(definitions) self.type = port_type
def __resolveport(self, definitions): """ Resolve port_type reference. @param definitions: A definitions object. @type definitions: L{Definitions} """ ref = qualify(self.type, self.root, definitions.tns) port_type = definitions.port_types.get(ref) if port_type is None: raise Exception("portType '%s', not-found" % (self.type,)) # Later on we will require access to the message data referenced by # this port_type instance, and in order for those data references to be # available, port_type first needs to dereference its message # identification string. The only scenario where the port_type might # possibly not have already resolved its references, and where this # explicit resolve() call is required, is if we are dealing with a # recursive WSDL import chain. port_type.resolve(definitions) self.type = port_type
def find(self, name, resolved=True): """ Get the definition object for the schema object by name. @param name: The name of a schema object. @type name: str @param resolved: A flag indicating that the fully resolved type should be returned. @type resolved: boolean @return: The found schema I{type} @rtype: L{xsd.sxbase.SchemaObject} """ log.debug('searching schema for (%s)', name) qref = qualify(name, self.schema.root, self.schema.tns) query = BlindQuery(qref) result = query.execute(self.schema) if result is None: log.error('(%s) not-found', name) return None log.debug('found (%s) as (%s)', name, Repr(result)) if resolved: result = result.resolve() return result
def resolveheaders(self, definitions): """ Resolve soap header I{message} references. @param definitions: A definitions object. @type definitions: L{Definitions} """ for op in self.operations.values(): soap = op.soap headers = soap.input.headers + soap.output.headers for header in headers: mn = header.message ref = qualify(mn, self.root, definitions.tns) message = definitions.messages.get(ref) if message is None: raise Exception("message'%s', not-found" % mn) header.message = SFactory.object('Message') header.message.name = message.name header.message.qname = message.qname header.message.parts = [] for p in message.parts: if p.name == header.part: header.message.parts.append(p) break