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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
/*******************************************************************************
* Copyright (c) 2004 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.ws.internal.explorer.platform.wsdl.actions;
import org.eclipse.wst.ws.internal.explorer.platform.perspective.*;
import org.eclipse.wst.ws.internal.explorer.platform.util.*;
import org.eclipse.wst.ws.internal.explorer.platform.wsdl.constants.*;
import org.eclipse.wst.ws.internal.explorer.platform.wsdl.datamodel.*;
import org.eclipse.wst.ws.internal.explorer.platform.wsdl.fragment.*;
import org.eclipse.wst.ws.internal.explorer.platform.wsdl.perspective.*;
import org.eclipse.wst.ws.internal.explorer.platform.wsdl.transport.HTTPException;
import org.eclipse.wst.ws.internal.explorer.platform.wsdl.transport.HTTPTransport;
import org.eclipse.wst.ws.internal.explorer.platform.wsdl.util.*;
import org.eclipse.wst.ws.internal.parser.discovery.*;
import org.apache.axis.Constants;
import org.w3c.dom.*;
import javax.xml.parsers.*;
import javax.wsdl.*;
import javax.wsdl.extensions.ExtensibilityElement;
import javax.wsdl.extensions.soap.SOAPBody;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
import java.io.*;
public abstract class InvokeWSDLSOAPOperationAction extends WSDLPropertiesFormAction
{
public InvokeWSDLSOAPOperationAction(Controller controller)
{
super(controller);
}
protected boolean processParsedResults(MultipartFormDataParser parser) throws MultipartFormDataException
{
super.processParsedResults(parser);
String endPoint = parser.getParameter(WSDLActionInputs.END_POINT);
InvokeWSDLOperationTool invokeWSDLOperationTool = (InvokeWSDLOperationTool)(getSelectedNavigatorNode().getCurrentToolManager().getSelectedTool());
invokeWSDLOperationTool.setEndPoint(endPoint);
return true;
}
protected final void addRPCWrapper(Vector bodyEntries,WSDLElement wsdlElement,WSDLOperationElement operElement,Hashtable soapEnvelopeNamespaceTable) throws ParserConfigurationException
{
// Must be RPC style.
String encodingNamespaceURI = null;
/*
* WS-I: In a rpc-literal SOAP binding, the serialized child element of the
* soap:Body element consists of a wrapper element, whose namespace is the value
* of the namespace attribute of the soapbind:body element and whose local name is
* either the name of the operation or the name of the operation suffixed
* with "Response". The namespace attribute is required, as opposed to being
* optional, to ensure that the children of the soap:Body element are namespace-
* qualified.
*/
BindingOperation bindingOperation = operElement.getBindingOperation();
if (bindingOperation != null)
{
BindingInput bindingInput = bindingOperation.getBindingInput();
if (bindingInput != null)
{
List extElements = bindingInput.getExtensibilityElements();
for (Iterator it = extElements.iterator(); it.hasNext();)
{
ExtensibilityElement extElement = (ExtensibilityElement)it.next();
if (extElement instanceof SOAPBody)
{
encodingNamespaceURI = ((SOAPBody)extElement).getNamespaceURI();
break;
}
}
}
}
// If the namespace of the soapbind:body element is not set, get it from the operation element
if (encodingNamespaceURI == null)
encodingNamespaceURI = operElement.getEncodingNamespace();
// If the namespace of the operation element is not set, get it from the definition element
if (encodingNamespaceURI == null)
{
Definition definition = wsdlElement.getDefinition();
encodingNamespaceURI = definition.getTargetNamespace();
}
// Generate an RPC style wrapper element.
Document doc = XMLUtils.createNewDocument(null);
String encodingStyle = (operElement.isUseLiteral() ? null : operElement.getEncodingStyle());
Element wrapperElement = SoapHelper.createRPCWrapperElement(doc,soapEnvelopeNamespaceTable,encodingNamespaceURI,operElement.getOperation().getName(),encodingStyle);
for (int i=0;i<bodyEntries.size();i++)
wrapperElement.appendChild(doc.importNode((Element)bodyEntries.elementAt(i),true));
bodyEntries.removeAllElements();
bodyEntries.addElement(wrapperElement);
}
/**
* Generate a Vector of the elements inside the Soap Body.
* @param soapEnvelopeNamespaceTable - Hashtable containing a map of the namespace URIs to prefixes.
* @param operElement - WSDLOperationElement encapsulating the WSDL operation.
*/
protected Vector getBodyEntries(Hashtable soapEnvelopeNamespaceTable,WSDLOperationElement operElement,WSDLBindingElement bindingElement,WSDLServiceElement serviceElement) throws ParserConfigurationException,Exception
{
Vector bodyEntries = new Vector();
boolean isUseLiteral = operElement.isUseLiteral();
String encodingStyle = operElement.getEncodingStyle();
boolean addEncodingStyle = (!isUseLiteral && !Constants.URI_SOAP11_ENC.equals(encodingStyle));
Iterator it = operElement.getOrderedBodyParts().iterator();
while (it.hasNext())
{
Part part = (Part)it.next();
IXSDFragment frag = (IXSDFragment)operElement.getFragment(part);
Element[] instanceDocuments = frag.genInstanceDocumentsFromParameterValues(!isUseLiteral,soapEnvelopeNamespaceTable, XMLUtils.createNewDocument(null));
for (int j=0;j<instanceDocuments.length;j++)
{
if (instanceDocuments[j] == null)
continue;
if (addEncodingStyle)
instanceDocuments[j].setAttribute("soapenv:encodingStyle",encodingStyle);
bodyEntries.addElement(instanceDocuments[j]);
}
}
if (!operElement.isDocumentStyle())
{
try
{
addRPCWrapper(bodyEntries,(WSDLElement)serviceElement.getParentElement(),operElement,soapEnvelopeNamespaceTable);
}
catch (ParserConfigurationException e)
{
throw e;
}
}
return bodyEntries;
}
protected Element getSOAPEnvelope(Hashtable soapEnvelopeNamespaceTable, Vector bodyEntries) throws ParserConfigurationException
{
DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document doc = XMLUtils.createNewDocument(docBuilder);
Element soapEnvelopeElement = SoapHelper.createSoapEnvelopeElement(doc,soapEnvelopeNamespaceTable);
Element soapBodyElement = SoapHelper.createSoapBodyElement(doc);
for (int i=0;i<bodyEntries.size();i++)
soapBodyElement.appendChild(doc.importNode((Element)bodyEntries.elementAt(i),true));
soapEnvelopeElement.appendChild(soapBodyElement);
return soapEnvelopeElement;
}
private final void recordSoapRequest(SOAPMessageQueue soapRequestQueue,Hashtable soapEnvelopeNamespaceTable,Element soapEnvelope) throws ParserConfigurationException,IOException
{
soapRequestQueue.clear();
soapRequestQueue.addMessage(XMLUtils.serialize(soapEnvelope,false));
}
private final void recordSOAPResponse(SOAPMessageQueue soapResponseQueue,BufferedReader responseReader) throws IOException
{
soapResponseQueue.clear();
if (responseReader != null)
{
String line = null;
while ((line = responseReader.readLine()) != null)
soapResponseQueue.addMessage(line);
responseReader.close();
}
}
public boolean run()
{
String soapAddressLocation = (String)propertyTable_.get(WSDLActionInputs.END_POINT);
WSDLPerspective wsdlPerspective = controller_.getWSDLPerspective();
MessageQueue messageQueue = wsdlPerspective.getMessageQueue();
WSDLOperationElement operElement = (WSDLOperationElement)getSelectedNavigatorNode().getTreeElement();
WSDLBindingElement bindingElement = (WSDLBindingElement)operElement.getParentElement();
WSDLServiceElement serviceElement = (WSDLServiceElement)bindingElement.getParentElement();
operElement.setPropertyAsObject(WSDLActionInputs.SOAP_RESPONSE_CACHED, new Boolean(false));
try
{
// Generate the SOAP envelope and its children. We need to create a DOM element version to display and the object version to execute.
// <SOAP-ENV:Envelope
// xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
// xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
// xmlns:xsd="http://www.w3.org/2001/XMLSchema">
// ...
Hashtable soapEnvelopeNamespaceTable = new Hashtable();
SoapHelper.addDefaultSoapEnvelopeNamespaces(soapEnvelopeNamespaceTable);
Vector bodyEntries = getBodyEntries(soapEnvelopeNamespaceTable,operElement,bindingElement,serviceElement);
Element soapEnvelope = getSOAPEnvelope(soapEnvelopeNamespaceTable, bodyEntries);
recordSoapRequest(wsdlPerspective.getSOAPRequestQueue(),soapEnvelopeNamespaceTable,soapEnvelope);
// Execute the SOAP operation.
if (soapAddressLocation != null)
{
// Send the message and record the SOAP Response Envelope.
HTTPTransport transport = createTransport(bindingElement, soapAddressLocation);
transport.send(NetUtils.createURL(soapAddressLocation),operElement.getSoapAction(),XMLUtils.serialize(soapEnvelope, true));
recordSOAPResponse(wsdlPerspective.getSOAPResponseQueue(),transport.receive());
wsdlPerspective.setOperationNode(getSelectedNavigatorNode());
return true;
}
throw new IOException(wsdlPerspective.getMessage("MSG_ERROR_UNABLE_TO_CONNECT",soapAddressLocation));
}
catch (ParserConfigurationException e)
{
handleUnexpectedException(wsdlPerspective,messageQueue,"ParserConfigurationException",e);
}
catch (IOException e)
{
handleUnexpectedException(wsdlPerspective,messageQueue,"IOException",e);
}
catch (HTTPException httpe)
{
throwHTTPException(bindingElement, soapAddressLocation, httpe);
}
catch (Exception e)
{
handleUnexpectedException(wsdlPerspective,messageQueue,"Exception",e);
}
return false;
}
private void throwHTTPException(WSDLBindingElement bindingElement, String endpointString, HTTPException httpException) throws HTTPException
{
if (httpException.getStatusCode() == HttpServletResponse.SC_UNAUTHORIZED)
{
Endpoint endpoint = bindingElement.getEndpoint(endpointString);
if (endpoint != null)
{
endpoint.setRequireHTTPBasicAuth(true);
endpoint.setHttpBasicAuthUsername(null);
endpoint.setHttpBasicAuthPassword(null);
}
}
throw httpException;
}
private HTTPTransport createTransport(WSDLBindingElement bindingElement, String endpointString)
{
HTTPTransport transport = new HTTPTransport();
Endpoint endpoint = bindingElement.getEndpoint(endpointString);
if (endpoint != null)
{
if (endpoint.isRequireHTTPBasicAuth())
{
String httpBasicAuthUsername = endpoint.getHttpBasicAuthUsername();
String httpBasicAuthPassword = endpoint.getHttpBasicAuthPassword();
if (httpBasicAuthUsername == null || httpBasicAuthPassword == null)
{
httpBasicAuthUsername = (String)propertyTable_.get(WSDLActionInputs.HTTP_BASIC_AUTH_USERNAME);
httpBasicAuthPassword = (String)propertyTable_.get(WSDLActionInputs.HTTP_BASIC_AUTH_PASSWORD);
endpoint.setHttpBasicAuthUsername(httpBasicAuthUsername);
endpoint.setHttpBasicAuthPassword(httpBasicAuthPassword);
}
if (httpBasicAuthUsername != null && httpBasicAuthPassword != null)
{
transport.setHttpBasicAuthUsername(httpBasicAuthUsername);
transport.setHttpBasicAuthPassword(httpBasicAuthPassword);
}
}
}
return transport;
}
}
|
