KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > websvc > core > jaxws > nodes > ClientHandlerButtonListener


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19 package org.netbeans.modules.websvc.core.jaxws.nodes;
20
21 import java.awt.event.ActionEvent JavaDoc;
22 import java.awt.event.ActionListener JavaDoc;
23 import java.io.BufferedReader JavaDoc;
24 import java.io.BufferedWriter JavaDoc;
25 import java.io.File JavaDoc;
26 import java.io.IOException JavaDoc;
27 import java.io.InputStream JavaDoc;
28 import java.io.InputStreamReader JavaDoc;
29 import java.io.OutputStream JavaDoc;
30 import java.io.OutputStreamWriter JavaDoc;
31 import java.net.URI JavaDoc;
32 import java.util.Collection JavaDoc;
33 import javax.swing.DefaultListModel JavaDoc;
34 import javax.swing.ListModel JavaDoc;
35 import org.netbeans.modules.websvc.api.jaxws.client.JAXWSClientSupport;
36 import org.netbeans.modules.websvc.core.jaxws.bindings.model.BindingsComponentFactory;
37 import org.netbeans.modules.websvc.core.jaxws.bindings.model.BindingsHandler;
38 import org.netbeans.modules.websvc.core.jaxws.bindings.model.BindingsHandlerChain;
39 import org.netbeans.modules.websvc.core.jaxws.bindings.model.BindingsHandlerChains;
40 import org.netbeans.modules.websvc.core.jaxws.bindings.model.BindingsHandlerClass;
41 import org.netbeans.modules.websvc.core.jaxws.bindings.model.BindingsModel;
42 import org.netbeans.modules.websvc.core.jaxws.bindings.model.BindingsModelFactory;
43 import org.netbeans.modules.websvc.core.jaxws.bindings.model.DefinitionsBindings;
44 import org.netbeans.modules.websvc.core.jaxws.bindings.model.GlobalBindings;
45 import org.netbeans.modules.websvc.core.webservices.ui.panels.MessageHandlerPanel;
46 import org.netbeans.modules.websvc.api.jaxws.project.config.Binding;
47 import org.netbeans.modules.websvc.api.jaxws.project.config.Client;
48 import org.netbeans.modules.websvc.api.jaxws.project.config.JaxWsModel;
49 import org.netbeans.modules.xml.xam.ModelSource;
50 import org.netbeans.modules.xml.retriever.catalog.Utilities;
51 import org.openide.ErrorManager;
52 import org.openide.NotifyDescriptor;
53 import org.openide.cookies.SaveCookie;
54 import org.openide.filesystems.FileLock;
55 import org.openide.filesystems.FileObject;
56 import org.openide.filesystems.FileSystem;
57 import org.openide.filesystems.FileUtil;
58 import org.openide.filesystems.Repository;
59 import org.openide.loaders.DataObject;
60 import org.openide.nodes.Node;
61
62 /**
63  *
64  * @author Roderico Cruz
65  */

66 public class ClientHandlerButtonListener implements ActionListener JavaDoc{
67     private MessageHandlerPanel panel;
68     private BindingsModel bindingsModel;
69     private Client client;
70     private Node node;
71     private JaxWsModel jaxWsModel;
72     private FileObject bindingHandlerFO;
73     private String JavaDoc wsdlRelativePath;
74     private String JavaDoc bindingsHandlerFile;
75     
76     
77     public ClientHandlerButtonListener(MessageHandlerPanel panel,
78             BindingsModel bindingsModel, Client client, Node node, JaxWsModel jaxWsModel){
79         
80         this.panel = panel;
81         this.bindingsModel = bindingsModel;
82         this.client = client;
83         this.node = node;
84         this.jaxWsModel = jaxWsModel;
85     }
86     public void actionPerformed(ActionEvent JavaDoc evt) {
87         if(evt.getSource() == NotifyDescriptor.OK_OPTION) {
88             try{
89                 FileObject srcRoot = (FileObject)node.getLookup().lookup(FileObject.class);
90                 JAXWSClientSupport support = JAXWSClientSupport.getJaxWsClientSupport(srcRoot);
91                 final FileObject bindingsFolder = support.getBindingsFolderForClient(node.getName(), true);
92                 Client client = (Client)node.getLookup().lookup(Client.class);
93                 assert client != null;
94                 bindingsHandlerFile = client.getHandlerBindingFile();
95                 if(bindingsHandlerFile == null){
96                     String JavaDoc baseBindingsHandlerFile = node.getName() + "_handler";
97                     bindingsHandlerFile = FileUtil.findFreeFileName(bindingsFolder, baseBindingsHandlerFile, "xml") +
98                             ".xml";
99                     client.setHandlerBindingFile(bindingsHandlerFile);
100                 }
101                 
102                 //if bindingsModel is null, create it
103
if(bindingsModel == null){
104                     final String JavaDoc bindingsContent = readResource(Repository.getDefault().getDefaultFileSystem().
105                             findResource("jax-ws/default-binding-handler.xml").getInputStream()); //NOI18N
106

107                     bindingsFolder.getFileSystem().runAtomicAction(new FileSystem.AtomicAction() {
108                         public void run() throws IOException JavaDoc {
109                             bindingHandlerFO =
110                                     FileUtil.createData(bindingsFolder, bindingsHandlerFile);//NOI18N
111
BufferedWriter JavaDoc bw = null;
112                             OutputStream JavaDoc os = null;
113                             OutputStreamWriter JavaDoc osw = null;
114                             FileLock lock = bindingHandlerFO.lock();
115                             try {
116                                 os = bindingHandlerFO.getOutputStream(lock);
117                                 osw = new OutputStreamWriter JavaDoc(os);
118                                 bw = new BufferedWriter JavaDoc(osw);
119                                 bw.write(bindingsContent);
120                             } finally {
121                                 try{
122                                     if(bw != null){
123                                         bw.close();
124                                     }
125                                     if(os != null) {
126                                         os.close();
127                                     }
128                                     if(osw != null){
129                                         osw.close();
130                                     }
131                                 }catch(IOException JavaDoc e){
132                                     ErrorManager.getDefault().notify(e);
133                                 }
134                                 
135                                 if(lock != null){
136                                     lock.releaseLock();
137                                 }
138                             }
139                         }
140                     });
141                     
142                     //now load the model and add the entry
143
ModelSource ms = Utilities.getModelSource(bindingHandlerFO, true);
144                     bindingsModel = BindingsModelFactory.getDefault().getModel(ms);
145                     //get the relative path of the wsdl
146
FileObject localWsdlFile =
147                             support.getLocalWsdlFolderForClient(client.getName(),false).getFileObject(client.getLocalWsdlFile());
148                     File JavaDoc f = FileUtil.toFile(bindingHandlerFO);
149                     String JavaDoc relativePath = Utilities.relativize(f.toURI(), new URI JavaDoc(localWsdlFile.getURL().toExternalForm()));
150                     GlobalBindings gb = bindingsModel.getGlobalBindings();
151                     bindingsModel.startTransaction();
152                     gb.setWsdlLocation(relativePath);
153                     bindingsModel.endTransaction();
154                     
155                 }//end if bindingsModel == null
156

157                 //get handler chain
158
DefaultListModel JavaDoc listModel = panel.getListModel();
159                 GlobalBindings gb = bindingsModel.getGlobalBindings();
160                 DefinitionsBindings db = gb.getDefinitionsBindings();
161                 BindingsHandlerChains bhc = db.getHandlerChains();
162                 BindingsHandlerChain chain = bhc.getHandlerChains().iterator().next();
163                 
164                 //add new handlers
165
BindingsComponentFactory factory = bindingsModel.getFactory();
166                 if(listModel.getSize() > 0){
167                     bindingsModel.startTransaction();
168                     for(int i = 0; i < listModel.getSize(); i++){
169                         String JavaDoc className = (String JavaDoc)listModel.getElementAt(i);
170                         if(isNewHandler(className, chain)){
171                             BindingsHandler handler = factory.createHandler();
172                             BindingsHandlerClass handlerClass = factory.createHandlerClass();
173                             handlerClass.setClassName(className);
174                             handler.setHandlerClass(handlerClass);
175                             chain.addHandler(handler);
176                         }
177                     }
178                     bindingsModel.endTransaction();
179                 }
180                 
181                 //reset bindingHandlerFO so we can save it
182
if(bindingHandlerFO == null){
183                     bindingHandlerFO = bindingsFolder.getFileObject(client.getHandlerBindingFile());
184                 }
185                 
186                 //remove handlers that have been deleted
187
Collection JavaDoc<BindingsHandler> handlers = chain.getHandlers();
188                 bindingsModel.startTransaction();
189                 for(BindingsHandler handler : handlers){
190                     String JavaDoc clsName = handler.getHandlerClass().getClassName();
191                     if(!isInModel(clsName, listModel)){
192                         chain.removeHandler(handler);
193                     }
194                 }
195                 bindingsModel.endTransaction();
196                 
197                 //save bindingshandler file
198
DataObject dobj = DataObject.find(bindingHandlerFO);
199                 if(dobj.isModified()){
200                     SaveCookie saveCookie = (SaveCookie)dobj.getCookie(SaveCookie.class);
201                     saveCookie.save();
202                 }
203                 
204                 if(listModel.getSize() > 0){
205                     Binding binding = client.getBindingByFileName(bindingsHandlerFile);
206                     if(binding == null){
207                         binding = client.newBinding();
208                         binding.setFileName(bindingsHandlerFile);
209                         client.addBinding(binding);
210                     }
211                 } else{
212                     Binding binding = client.getBindingByFileName(bindingsHandlerFile);
213                     if(binding != null){
214                         client.removeBinding(binding);
215                     }
216                 }
217                 //save the jaxws model
218
jaxWsModel.write();
219             }catch(Exception JavaDoc e){
220                 ErrorManager.getDefault().notify(e);
221             }
222         }
223     }
224     
225     private boolean isInModel(String JavaDoc className, ListModel JavaDoc model){
226         for(int i = 0; i < model.getSize(); i++){
227             String JavaDoc cls = (String JavaDoc)model.getElementAt(i);
228             if(className.equals(cls)){
229                 return true;
230             }
231         }
232         return false;
233     }
234     
235     private boolean isNewHandler(String JavaDoc className, BindingsHandlerChain handlerChain){
236         if(handlerChain != null){
237             Collection JavaDoc<BindingsHandler> handlers = handlerChain.getHandlers();
238             for(BindingsHandler handler : handlers){
239                 if (handler.getHandlerClass().getClassName().equals(className)){
240                     return false;
241                 }
242             }
243         }
244         return true;
245     }
246     
247     
248     //TODO: close all streams properly
249
private static String JavaDoc readResource(InputStream JavaDoc is) throws IOException JavaDoc {
250         // read the config from resource first
251
BufferedReader JavaDoc br= null;
252         StringBuilder JavaDoc sb = new StringBuilder JavaDoc();
253         try{
254             
255             String JavaDoc lineSep = System.getProperty("line.separator");//NOI18N
256
br = new BufferedReader JavaDoc(new InputStreamReader JavaDoc(is));
257             String JavaDoc line = br.readLine();
258             while (line != null) {
259                 sb.append(line);
260                 sb.append(lineSep);
261                 line = br.readLine();
262             }
263         }finally{
264             br.close();
265         }
266         return sb.toString();
267     }
268     
269 }
270
Popular Tags