PlatformConfiguration


1   /*******************************************************************************
2    * Copyright (c) 2000, 2007 IBM Corporation and others.
3    * All rights reserved. This program and the accompanying materials
4    * are made available under the terms of the Eclipse Public License v1.0
5    * which accompanies this distribution, and is available at
6    * http://www.eclipse.org/legal/epl-v10.html
7    *
8    * Contributors:
9    *     IBM Corporation - initial API and implementation
10   *     James D Miles (IBM Corp.) - bug 176250, Configurator needs to handle more platform urls 
11   *******************************************************************************/
12  package org.eclipse.update.internal.configurator;
13  
14  import java.io.BufferedWriter  ;
15  import java.io.File  ;
16  import java.io.FileFilter  ;
17  import java.io.FileInputStream  ;
18  import java.io.FileOutputStream  ;
19  import java.io.IOException  ;
20  import java.io.OutputStream  ;
21  import java.io.OutputStreamWriter  ;
22  import java.io.SyncFailedException  ;
23  import java.io.UnsupportedEncodingException  ;
24  import java.lang.reflect.InvocationTargetException  ;
25  import java.net.MalformedURLException  ;
26  import java.net.URL  ;
27  import java.net.URLConnection  ;
28  import java.util.ArrayList  ;
29  import java.util.Date  ;
30  import java.util.HashMap  ;
31  import java.util.HashSet  ;
32  import java.util.Properties  ;
33  import java.util.Set  ;
34  
35  import javax.xml.parsers.DocumentBuilder  ;
36  import javax.xml.parsers.DocumentBuilderFactory  ;
37  
38  import org.eclipse.core.runtime.CoreException;
39  import org.eclipse.core.runtime.FileLocator;
40  import org.eclipse.osgi.service.datalocation.Location;
41  import org.eclipse.osgi.util.NLS;
42  import org.eclipse.update.configurator.IPlatformConfiguration;
43  import org.w3c.dom.Document  ;
44  import org.w3c.dom.Element  ;
45  
46  /**
47   * This class is responsible for providing the features and plugins (bundles) to 
48   * the runtime. Configuration data is stored in the configuration/org.eclipse.update/platform.xml file.
49   * When eclipse starts, it tries to load the config info from platform.xml.
50   * If the file does not exist, then it also tries to read it from a temp or backup file.
51   * If this does not succeed, a platform.xml is created by inspecting the eclipse 
52   * installation directory (its features and plugin folders).
53   * If platform.xml already exists, a check is made to see when it was last modified
54   * and whether there are any file system changes that are newer (users may manually unzip 
55   * features and plugins). In this case, the newly added features and plugins are picked up.
56   * A check for existence of features and plugins is also performed, to detect deletions.
57   */
58  public class PlatformConfiguration implements IPlatformConfiguration, IConfigurationConstants {
59  
60      private static PlatformConfiguration currentPlatformConfiguration = null;
61      //private static final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
62  //  private static final TransformerFactory transformerFactory = TransformerFactory.newInstance();
63      private static final String   XML_ENCODING = "UTF-8"; //$NON-NLS-1$
64  
65      private Configuration config;
66      private URL   configLocation;
67      private HashMap   externalLinkSites; // used to restore prior link site state
68      private long changeStamp;
69      private long featuresChangeStamp;
70      private boolean featuresChangeStampIsValid;
71      private long pluginsChangeStamp;
72      private boolean pluginsChangeStampIsValid;
73      //PAL nio optional
74      //private FileLock lock;
75      private Locker lock = null;
76      private static int defaultPolicy = DEFAULT_POLICY_TYPE;
77      private static boolean checkNio = false;
78      private static boolean useNio;
79  
80      private static final String   ECLIPSE = "eclipse"; //$NON-NLS-1$
81      private static final String   CONFIG_HISTORY = "history"; //$NON-NLS-1$
82      private static final String   PLATFORM_XML = "platform.xml"; //$NON-NLS-1$
83      private static final String   CONFIG_NAME = ConfigurationActivator.NAME_SPACE + "/" + PLATFORM_XML; //$NON-NLS-1$
84      private static final String   CONFIG_INI = "config.ini"; //NON-NLS-1$ //$NON-NLS-1$
85      private static final String   CONFIG_FILE_LOCK_SUFFIX = ".lock"; //$NON-NLS-1$
86      private static final String   CONFIG_FILE_TEMP_SUFFIX = ".tmp"; //$NON-NLS-1$
87      private static final String   LINKS = "links"; //$NON-NLS-1$
88      private static final String  [] BOOTSTRAP_PLUGINS = {}; 
89  
90      private static final String   DEFAULT_FEATURE_APPLICATION = "org.eclipse.ui.ide.workbench"; //$NON-NLS-1$
91  
92      private static final String   LINK_PATH = "path"; //$NON-NLS-1$
93      private static final String   LINK_READ = "r"; //$NON-NLS-1$
94      private static final String   LINK_READ_WRITE = "rw"; //$NON-NLS-1$
95      private static URL   installURL;
96      
97      private PlatformConfiguration(Location platformConfigLocation) throws CoreException, IOException   {
98  
99          this.externalLinkSites = new HashMap  ();
100         this.config = null;
101         
102         // initialize configuration
103         initializeCurrent(platformConfigLocation);
104         if(config != null)
105             setDefaultPolicy();
106 
107         // Detect external links. These are "soft link" to additional sites. The link
108         // files are usually provided by external installation programs. They are located
109         // relative to this configuration URL.
110         // Note: don't do it for self hosting
111         if (!isTransient())
112             configureExternalLinks();
113 
114         // Validate sites in the configuration. Causes any sites that do not exist to
115         // be removed from the configuration
116         validateSites();
117 
118         // compute differences between configuration and actual content of the sites
119         // (base sites and link sites)
120         // Note: when the config is transient (generated by PDE, etc.) we don't reconcile
121         if (isTransient())
122             return;
123         
124         // for 'osgi.clean' or osgi.checkConfiguration', force a refresh
125         boolean osgiClean = "true".equals(ConfigurationActivator.getBundleContext().getProperty("osgi.clean")); //$NON-NLS-1$ //$NON-NLS-2$
126         boolean osgiCheckConfiguration = "true".equals(ConfigurationActivator.getBundleContext().getProperty("osgi.checkConfiguration")); //$NON-NLS-1$ //$NON-NLS-2$
127         
128         if (osgiClean || osgiCheckConfiguration) {
129             // We have to call refresh() for features to be rescanned correctly
130             refresh();
131             reconcile();
132         }
133         else {
134             changeStamp = computeChangeStamp();
135             if (changeStamp > config.getDate().getTime())
136                 reconcile();
137         }
138     }
139 
140     PlatformConfiguration(URL   url) throws Exception   {
141         this.externalLinkSites = new HashMap  ();
142         initialize(url);
143     }
144 
145     private void setDefaultPolicy() {
146         // Assumption: If the configuration that we initialize with 
147         // has a MANAGED_ONLY policy, then all sites should have default policy 
148         // of MANAGED_ONLY.  
149         ISiteEntry[] sentries = getConfiguredSites();
150         if(sentries != null && sentries.length >0){
151             int policyType = sentries[0].getSitePolicy().getType();
152             if(policyType == ISitePolicy.MANAGED_ONLY){
153                 defaultPolicy = policyType;
154             }
155         }
156     }
157 
158     public static int getDefaultPolicy(){
159         return defaultPolicy;
160     }
161 
162     /*
163      * @see IPlatformConfiguration#createSiteEntry(URL, ISitePolicy)
164      */
165     public ISiteEntry createSiteEntry(URL   url, ISitePolicy policy) {
166         return new SiteEntry(url, policy);
167     }
168 
169     /*
170      * @see IPlatformConfiguration#createSitePolicy(int, String[])
171      */
172     public ISitePolicy createSitePolicy(int type, String  [] list) {
173         return new SitePolicy(type, list);
174     }
175 
176     /*
177      * @see IPlatformConfiguration#createFeatureEntry(String, String, String, boolean, String, URL)
178      */
179     public IFeatureEntry createFeatureEntry(String   id, String   version, String   pluginVersion, boolean primary, String   application, URL  [] root) {
180         return new FeatureEntry(id, version, pluginVersion, primary, application, root);
181     }
182 
183     /*
184      * @see IPlatformConfiguration#createFeatureEntry(String, String, String,
185      * String, boolean, String, URL)
186      */
187     public IFeatureEntry createFeatureEntry(String   id, String   version, String   pluginIdentifier, String   pluginVersion, boolean primary, String   application, URL  [] root) {
188         return new FeatureEntry(id, version, pluginIdentifier, pluginVersion, primary, application, root);
189     }
190 
191     /*
192      * @see IPlatformConfiguration#configureSite(ISiteEntry)
193      */
194     public void configureSite(ISiteEntry entry) {
195         configureSite(entry, false);
196     }
197 
198     /*
199      * @see IPlatformConfiguration#configureSite(ISiteEntry, boolean)
200      */
201     public synchronized void configureSite(ISiteEntry entry, boolean replace) {
202 
203         if (entry == null)
204             return;
205     
206         URL   url = entry.getURL();
207         if (url == null)
208             return;
209 
210         String   key = url.toExternalForm();
211         if (config.getSiteEntry(key) != null && !replace)
212             return;
213     
214         if (entry instanceof SiteEntry)
215             config.addSiteEntry(key, (SiteEntry)entry);
216     }
217 
218     /*
219      * @see IPlatformConfiguration#unconfigureSite(ISiteEntry)
220      */
221     public synchronized void unconfigureSite(ISiteEntry entry) {
222         if (entry == null)
223             return;
224 
225         URL   url = entry.getURL();
226         if (url == null)
227             return;
228         
229         String   key = url.toExternalForm();  
230         if (entry instanceof SiteEntry)
231             config.removeSiteEntry(key);
232     }
233 
234     /*
235      * @see IPlatformConfiguration#getConfiguredSites()
236      */
237     public ISiteEntry[] getConfiguredSites() {
238         if (config == null)
239             return new ISiteEntry[0];
240         
241         SiteEntry[] sites = config.getSites();
242         ArrayList   enabledSites = new ArrayList  (sites.length);
243         for (int i=0; i<sites.length; i++) {
244             if (sites[i].isEnabled())
245                 enabledSites.add(sites[i]);
246         }
247         return (ISiteEntry[])enabledSites.toArray(new ISiteEntry[enabledSites.size()]);
248     }
249 
250     /*
251      * @see IPlatformConfiguration#findConfiguredSite(URL)
252      */
253     public ISiteEntry findConfiguredSite(URL   url) {
254         return findConfiguredSite(url, true);
255     }
256     
257     /**
258      * 
259      * @param url site url
260      * @param checkPlatformURL if true, check for url format that is platform:/...
261      * @return
262      */
263     public SiteEntry findConfiguredSite(URL   url, boolean checkPlatformURL) {
264         if (url == null)
265             return null;
266         String   key = url.toExternalForm();
267 
268         SiteEntry result = config.getSiteEntry(key);    
269         if (result == null) { // retry with decoded URL string
270             try {
271                 //PAL foundation
272                 //key = URLDecoder.decode(key, "UTF-8"); //$NON-NLS-1$
273                 key = UpdateURLDecoder.decode(key, "UTF-8"); //$NON-NLS-1$
274             } catch (UnsupportedEncodingException   e) {
275                 // ignore
276             }
277             result = config.getSiteEntry(key);
278         }
279             
280         if (result == null && checkPlatformURL) {
281             try {
282                 result = findConfiguredSite(config.asPlatformURL(url), false);
283             } catch (Exception   e) {
284                 //ignore
285             }
286         }
287         return result;
288     }
289 
290     /*
291      * @see IPlatformConfiguration#configureFeatureEntry(IFeatureEntry)
292      */
293     public synchronized void configureFeatureEntry(IFeatureEntry entry) {
294         if (entry == null)
295             return;
296 
297         String   key = entry.getFeatureIdentifier();
298         if (key == null)
299             return;
300 
301         // we should check each site and find where the feature is
302         // located and then configure it
303         if (config == null)
304             config = new Configuration();
305 
306         SiteEntry[] sites = config.getSites();
307         for (int i=0; i<sites.length; i++) {
308             // find out what site contains the feature and configure it
309             try {
310                 URL   url = new URL  (sites[i].getURL(), FEATURES + "/" + entry.getFeatureIdentifier()+ "_" + entry.getFeatureVersion() + "/"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
311                 if (new File  (url.getFile()).exists())
312                     sites[i].addFeatureEntry(entry);
313                 else  {
314                     url = new URL  (sites[i].getURL(), FEATURES + "/" + entry.getFeatureIdentifier() + "/"); //$NON-NLS-1$ //$NON-NLS-2$
315                     if (new File  (url.getFile()).exists())
316                         sites[i].addFeatureEntry(entry);
317                 }
318             } catch (MalformedURLException   e) {
319             }
320         }
321     }
322 
323     /*
324      * @see IPlatformConfiguration#unconfigureFeatureEntry(IFeatureEntry)
325      */
326     public synchronized void unconfigureFeatureEntry(IFeatureEntry entry) {
327         if (entry == null)
328             return;
329 
330         String   key = entry.getFeatureIdentifier();
331         if (key == null)
332             return;
333 
334         config.unconfigureFeatureEntry(entry);
335     }
336 
337     /*
338      * @see IPlatformConfiguration#getConfiguredFeatureEntries()
339      */
340     public IFeatureEntry[] getConfiguredFeatureEntries() {
341         ArrayList   configFeatures = new ArrayList  ();
342         SiteEntry[] sites = config.getSites();
343         for (int i=0; i<sites.length; i++) {
344             FeatureEntry[] features = sites[i].getFeatureEntries();
345             for (int j=0; j<features.length; j++)
346                 configFeatures.add(features[j]);
347         }
348         return (IFeatureEntry[])configFeatures.toArray(new FeatureEntry[configFeatures.size()]);
349     }
350 
351     /*
352      * @see IPlatformConfiguration#findConfiguredFeatureEntry(String)
353      */
354     public IFeatureEntry findConfiguredFeatureEntry(String   id) {
355         if (id == null)
356             return null;
357 
358         SiteEntry[] sites = config.getSites();
359         for (int i=0; i<sites.length; i++) {
360             FeatureEntry f = sites[i].getFeatureEntry(id);
361             if (f != null)
362                 return f;
363         }
364         return null;
365     }
366 
367     /*
368      * @see IPlatformConfiguration#getConfigurationLocation()
369      */
370     public URL   getConfigurationLocation() {
371         return configLocation;
372     }
373 
374     /*
375      * @see IPlatformConfiguration#getChangeStamp()
376      */
377     public long getChangeStamp() {
378         if (config.getLinkedConfig() == null)
379             return config.getDate().getTime();
380         return Math.max(config.getDate().getTime(), config.getLinkedConfig().getDate().getTime());
381     }
382 
383     /*
384      * @see IPlatformConfiguration#getFeaturesChangeStamp()
385      * @deprecated Don't use this method
386      */
387     public long getFeaturesChangeStamp() {
388         return 0;
389     }
390 
391     /*
392      * @see IPlatformConfiguration#getPluginsChangeStamp()
393      * @deprecated Don't use this method
394      */
395     public long getPluginsChangeStamp() {
396         return 0;
397     }
398 
399 
400     public String   getApplicationIdentifier() {
401         // Return the app if defined in system properties
402         String   application = ConfigurationActivator.getBundleContext().getProperty(ECLIPSE_APPLICATION);
403         if (application != null)
404             return application;
405 
406         // Otherwise, try to get it from the primary feature (aka product)
407         String   feature = getPrimaryFeatureIdentifier();
408 
409         // lookup application for feature (specified or defaulted)
410         if (feature != null) {
411             IFeatureEntry fe = findConfiguredFeatureEntry(feature);
412             if (fe != null) {
413                 if (fe.getFeatureApplication() != null)
414                     return fe.getFeatureApplication();
415             }
416         }
417 
418         // return hardcoded default if we failed
419         return DEFAULT_FEATURE_APPLICATION;
420     }
421 
422     /*
423      * @see IPlatformConfiguration#getPrimaryFeatureIdentifier()
424      */
425     public String   getPrimaryFeatureIdentifier() {
426         // Return the product if defined in system properties
427         String   primaryFeatureId = ConfigurationActivator.getBundleContext().getProperty(ECLIPSE_PRODUCT);
428         if (primaryFeatureId != null) {
429             // check if feature exists
430             IFeatureEntry feature = findConfiguredFeatureEntry(primaryFeatureId);
431             if (feature != null && feature.canBePrimary())
432                 return primaryFeatureId;
433         }
434         return null;
435     }
436 
437     /*
438      * @see IPlatformConfiguration#getPluginPath()
439      */
440     public URL  [] getPluginPath() {
441         ArrayList   path = new ArrayList  ();
442         Utils.debug("computed plug-in path:"); //$NON-NLS-1$
443 
444         ISiteEntry[] sites = getConfiguredSites();
445         URL   pathURL;
446         for (int i = 0; i < sites.length; i++) {
447             String  [] plugins = sites[i].getPlugins();
448             for (int j = 0; j < plugins.length; j++) {
449                 try {
450                     pathURL = new URL  (((SiteEntry) sites[i]).getResolvedURL(), plugins[j]);
451                     path.add(pathURL);
452                     Utils.debug("   " + pathURL.toString()); //$NON-NLS-1$
453                 } catch (MalformedURLException   e) {
454                     // skip entry ...
455                     Utils.debug("   bad URL: " + e); //$NON-NLS-1$
456                 }
457             }
458         }
459         return (URL  []) path.toArray(new URL  [0]);
460     }
461     
462     public Set   getPluginPaths() {
463         
464         HashSet   paths = new HashSet  ();
465         ISiteEntry[] sites = getConfiguredSites();
466 
467         for (int i = 0; i < sites.length; i++) {
468             String  [] plugins = sites[i].getPlugins();
469             for (int j = 0; j < plugins.length; j++) {
470                     paths.add(plugins[j]);
471             }
472         }
473         
474         return paths;
475     }
476     
477 
478     /*
479      * A variation of the getPluginPath, but it returns the actual plugin entries
480      */
481     public PluginEntry[] getPlugins() {
482         ArrayList   allPlugins = new ArrayList  ();
483         Utils.debug("computed plug-ins:"); //$NON-NLS-1$
484 
485         ISiteEntry[] sites = getConfiguredSites();
486         for (int i = 0; i < sites.length; i++) {
487             if (!(sites[i] instanceof SiteEntry)) {
488                 Utils.debug("Site " + sites[i].getURL() + " is not a SiteEntry"); //$NON-NLS-1$ //$NON-NLS-2$
489                 continue;
490             }
491             PluginEntry[] plugins = ((SiteEntry)sites[i]).getPluginEntries();
492             for (int j = 0; j < plugins.length; j++) {
493                 allPlugins.add(plugins[j]);
494                 Utils.debug("   " + plugins[j].getURL()); //$NON-NLS-1$
495             }
496         }
497         return (PluginEntry[]) allPlugins.toArray(new PluginEntry[0]);
498     }
499     
500 
501     /*
502      * @see IPlatformConfiguration#getBootstrapPluginIdentifiers()
503      */
504     public String  [] getBootstrapPluginIdentifiers() {
505         return BOOTSTRAP_PLUGINS;
506     }
507 
508     /*
509      * @see IPlatformConfiguration#setBootstrapPluginLocation(String, URL)
510      */
511     public void setBootstrapPluginLocation(String   id, URL   location) {
512     }
513 
514     /*
515      * @see IPlatformConfiguration#isUpdateable()
516      */
517     public boolean isUpdateable() {
518         return true;
519     }
520 
521     /*
522      * @see IPlatformConfiguration#isTransient()
523      */
524     public boolean isTransient() {
525         return (config != null) ? config.isTransient() : false;
526     }
527 
528     /*
529      * @see IPlatformConfiguration#isTransient(boolean)
530      */
531     public void isTransient(boolean value) {
532         if (this != getCurrent() && config != null)
533             config.setTransient(value);
534     }
535 
536     /*
537      * @see IPlatformConfiguration#refresh()
538      */
539     public synchronized void refresh() {
540         // Reset computed values. Will be lazily refreshed
541         // on next access
542         ISiteEntry[] sites = getConfiguredSites();
543         for (int i = 0; i < sites.length; i++) {
544             if (sites[i].isUpdateable()) {
545                 // reset site entry
546                 ((SiteEntry) sites[i]).refresh();
547             }
548         }
549     }
550 
551     /*
552      * @see IPlatformConfiguration#save()
553      */
554     public void save() throws IOException   {
555         if (isUpdateable())
556             save(configLocation);
557     }
558 
559     /*
560      * @see IPlatformConfiguration#save(URL)
561      */
562     public synchronized void save(URL   url) throws IOException   {
563         if (url == null)
564             throw new IOException  (Messages.cfig_unableToSave_noURL); 
565 
566         OutputStream   os = null;
567         if (!url.getProtocol().equals("file")) { //$NON-NLS-1$
568             // not a file protocol - attempt to save to the URL
569             URLConnection   uc = url.openConnection();
570             uc.setDoOutput(true);
571             os = uc.getOutputStream();
572             try {
573                 saveAsXML(os);
574                 config.setDirty(false);
575             } catch (CoreException e) {
576                 Utils.log(e.getMessage());
577                 Utils.log(e.getStatus());
578                 throw new IOException  (NLS.bind(Messages.cfig_unableToSave, (new String  [] { url.toExternalForm() })));
579             } finally {
580                 os.close();
581             }
582         } else {
583             // file protocol - do safe i/o
584             File   cfigFile = new File  (url.getFile().replace('/', File.separatorChar));
585             if (!cfigFile.getName().equals(PLATFORM_XML)) {
586                 if (cfigFile.exists() && cfigFile.isFile()) {
587                     Utils.log(Messages.PlatformConfiguration_expectingPlatformXMLorDirectory + cfigFile.getName()); 
588                     cfigFile = cfigFile.getParentFile();
589                 }
590                 cfigFile = new File  (cfigFile, CONFIG_NAME);
591             }
592             File   workingDir = cfigFile.getParentFile();
593             if (workingDir != null && !workingDir.exists())
594                 workingDir.mkdirs();
595 
596             // Do safe i/o: 
597             //    - backup current config, by moving it to the history folder
598             //    - write new config to platform.xml.tmp file
599             //    - rename the temp file to platform.xml
600             File   cfigFileOriginal = new File  (cfigFile.getAbsolutePath());
601             File   cfigTmp = new File  (cfigFile.getAbsolutePath() + CONFIG_FILE_TEMP_SUFFIX);
602             
603             // Backup old file
604             if (cfigFile.exists()){
605                 File   backupDir = new File  (workingDir, CONFIG_HISTORY);
606                 if (!backupDir.exists())
607                     backupDir.mkdir();
608                 long timestamp = cfigFile.lastModified();
609                 File   preservedFile = new File  (backupDir, String.valueOf(timestamp)+".xml"); //$NON-NLS-1$
610                 // If the target file exists, increment the timestamp. Try at most 100 times.
611                 long increment = 1;
612                 while (preservedFile.exists() && increment < 100){
613                     preservedFile = new File  (backupDir, String.valueOf(timestamp+increment++)+".xml"); //$NON-NLS-1$
614                 }
615                 if (!preservedFile.exists()) {
616                     // try renaming current config to backup copy
617                     if (!cfigFile.renameTo(preservedFile))
618                         Utils.log(Messages.PlatformConfiguration_cannotBackupConfig); 
619                 }
620             }
621 
622             // first save the file as temp
623             os = new FileOutputStream  (cfigTmp);
624             
625             try {
626                 saveAsXML(os);
627                 // Try flushing any internal buffers, and synchronize with the disk
628                 try {
629                     os.flush();
630                     ((FileOutputStream  )os).getFD().sync();
631                 } catch (SyncFailedException   e2) {
632                     Utils.log(e2.getMessage());
633                 } catch (IOException   e2) {
634                     Utils.log(e2.getMessage());
635                 }
636                 try {
637                     os.close();
638                     os = null;
639                 } catch (IOException   e1) {
640                     Utils.log(Messages.PlatformConfiguration_cannotCloseStream + cfigTmp); 
641                     Utils.log(e1.getMessage());
642                 }
643                 // set file time stamp to match that of the config element
644                 cfigTmp.setLastModified(config.getDate().getTime());
645                 // set this on config, in case the value was rounded off
646                 config.setLastModified(cfigTmp.lastModified());
647                 // make the change stamp to be the same as the config file
648                 changeStamp = config.getDate().getTime();
649                 config.setDirty(false);
650             } catch (CoreException e) {
651                 throw new IOException  (NLS.bind(Messages.cfig_unableToSave, (new String  [] { cfigTmp.getAbsolutePath() })));
652             } finally {
653                 if (os != null)
654                     try {
655                         os.close();
656                     } catch (IOException   e1) {
657                         Utils.log(Messages.PlatformConfiguration_cannotCloseTempFile + cfigTmp); 
658                     }
659             }
660 
661             // at this point we have old config (if existed) as "bak" and the
662             // new config as "tmp".
663             boolean ok = cfigTmp.renameTo(cfigFileOriginal);
664             if (!ok) {
665                 // this codepath represents a tiny failure window. The load processing
666                 // on startup will detect missing config and will attempt to start
667                 // with "tmp" (latest), then "bak" (the previous). We can also end up
668                 // here if we failed to rename the current config to "bak". In that
669                 // case we will restart with the previous state.
670                 Utils.log(Messages.PlatformConfiguration_cannotRenameTempFile); 
671                 
672                 throw new IOException  (NLS.bind(Messages.cfig_unableToSave, (new String  [] { cfigTmp.getAbsolutePath() })));
673             }
674         }
675     }
676 
677 
678     public static PlatformConfiguration getCurrent() {
679         return currentPlatformConfiguration;
680     }
681 
682     /**
683      * Starts a platform installed at specified installURL using configuration located at platformConfigLocation.
684      */
685     public static synchronized void startup(URL   installURL, Location platformConfigLocation) throws Exception   {
686         PlatformConfiguration.installURL = installURL;
687     
688         // create current configuration
689         if (currentPlatformConfiguration == null) {
690             currentPlatformConfiguration = new PlatformConfiguration(platformConfigLocation);
691             if (currentPlatformConfiguration.config == null)
692                 throw new Exception  (Messages.PlatformConfiguration_cannotLoadConfig + platformConfigLocation.getURL()); 
693             if (currentPlatformConfiguration.config.isDirty())
694                 // If this is a transient config (generated by PDE),do nothing
695                 // otherwise, save the configuration with proper date
696                 if (!currentPlatformConfiguration.isTransient())
697                     currentPlatformConfiguration.save();
698         }
699     }
700 
701     public static synchronized void shutdown() throws IOException   {
702 
703         // save platform configuration
704         PlatformConfiguration config = getCurrent();
705         if (config != null) {
706             // only save if there are changes in the config
707             if (config.config.isDirty() && !config.isTransient()) {
708                 try {
709                     config.save();
710                 } catch (IOException   e) {
711                     Utils.debug("Unable to save configuration " + e.toString()); //$NON-NLS-1$
712                     // will recover on next startup
713                 }
714             }
715         }
716     }
717 
718 
719     private synchronized void initializeCurrent(Location platformConfigLocation) throws IOException   {
720 
721         // Configuration URL was is specified by the OSGi layer. 
722         // Default behavior is to look
723         // for configuration in the specified meta area. If not found, look
724         // for pre-initialized configuration in the installation location.