KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > cli > commands > StartDomainCommand


1 /*
2  * The contents of this file are subject to the terms
3  * of the Common Development and Distribution License
4  * (the License). You may not use this file except in
5  * compliance with the License.
6  *
7  * You can obtain a copy of the license at
8  * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9  * glassfish/bootstrap/legal/CDDLv1.0.txt.
10  * See the License for the specific language governing
11  * permissions and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL
14  * Header Notice in each file and include the License file
15  * at glassfish/bootstrap/legal/CDDLv1.0.txt.
16  * If applicable, add the following below the CDDL Header,
17  * with the fields enclosed by brackets [] replaced by
18  * you own identifying information:
19  * "Portions Copyrighted [year] [name of copyright owner]"
20  *
21  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22  */

23
24 package com.sun.enterprise.cli.commands;
25
26 import com.sun.enterprise.cli.framework.CommandValidationException;
27 import com.sun.enterprise.cli.framework.CommandException;
28 import com.sun.enterprise.cli.framework.CLILogger;
29
30 import com.sun.enterprise.util.ProcessExecutor;
31 import com.sun.enterprise.util.RelativePathResolver;
32 import com.sun.enterprise.security.store.PasswordAdapter;
33 import com.sun.enterprise.admin.servermgmt.pe.PEFileLayout;
34 import com.sun.enterprise.admin.servermgmt.RepositoryManager;
35 import com.sun.enterprise.admin.servermgmt.DomainsManager;
36 import com.sun.enterprise.admin.servermgmt.DomainConfig;
37 import com.sun.enterprise.admin.servermgmt.DomainException;
38 import com.sun.enterprise.admin.servermgmt.InstancesManager;
39 import com.sun.enterprise.admin.common.Status;
40 import com.sun.enterprise.util.SystemPropertyConstants;
41 import com.sun.enterprise.util.io.FileUtils;
42 import java.io.*;
43
44 import javax.xml.parsers.DocumentBuilder JavaDoc;
45 import javax.xml.parsers.DocumentBuilderFactory JavaDoc;
46 import org.w3c.dom.Document JavaDoc;
47
48 import java.io.File JavaDoc;
49 import java.lang.reflect.Method JavaDoc;
50 import java.util.BitSet JavaDoc;
51 /**
52  * This is a sample Deploy command
53  * @version $Revision: 1.12 $
54  */

55 public class StartDomainCommand extends BaseLifeCycleCommand
56 {
57
58     private static final String JavaDoc SERVER_LOG_FILE_NAME = "server.log";
59     private static final String JavaDoc LOGS_DIR = "logs";
60     private static final String JavaDoc VERBOSE = "verbose";
61     private static final String JavaDoc APPLICATION_SERVER_8_0 = "Application Server 8.0";
62     private static final String JavaDoc DTD_FILE_8_0 = "sun-domain_1_0";
63     private static final String JavaDoc DTD_FILE_8_1 = "sun-domain_1_1";
64     private static final long UPGRADE_TIMEOUT = 1200000; //20min
65
private static final String JavaDoc ADDONINSTALLER = "com.sun.enterprise.addon.AddonInstaller";
66     private static final String JavaDoc INSTALLERMETHOD = "installAllAddons";
67     private String JavaDoc domainName;
68     private DomainConfig config;
69     private DomainsManager mgr;
70     private String JavaDoc adminPwdAlias;
71     private BitSet JavaDoc flags;
72     
73     // backup message: tells user about the backup file. This is not wanted in many
74
// cases -- e.g. domain is already running, bad password.
75
// note: as of Sept 26,2005 the backup of domain.xml has been deprecated.
76
// Thus, this variable does nothing. It can all be turned back on by setting
77
// the enableBackups boolean
78
private boolean doBackupMessage = true;
79     private final static boolean enableBackups = false;
80     
81     /**
82      * An abstract method that validates the options
83      * on the specification in the xml properties file
84      * This method verifies for the correctness of number of
85      * operands and if all the required options are supplied by the client.
86      * @return boolean returns true if success else returns false
87      */

88     public boolean validateOptions() throws CommandValidationException
89     {
90         return super.validateOptions();
91     }
92     public void startDomain(String JavaDoc DomainName)
93         throws CommandException, CommandValidationException
94     {
95         domainName = DomainName;
96         long start = System.currentTimeMillis();
97         
98         try
99         {
100             doBackupMessage = false;
101             init();
102             checkIfRunning();
103             checkIfStopping();
104     
105             doBackupMessage = true;
106             validateDomain();
107             doBackupMessage = false;
108             validateAdminPassword();
109             validateMasterPassword();
110             saveExtraPasswordOptions();
111             doBackupMessage = true;
112             installAddons();
113             checkAndExecuteUpgrade(domainName);
114             mgr.startDomain(config);
115                         
116             if(enableBackups)
117             {
118                 saveCopyOfConfig(config);
119             }
120
121             if (flags.get(DomainConfig.K_FLAG_START_DOMAIN_NEEDS_ADMIN_USER)) {
122                 CLILogger.getInstance().printDetailMessage(getLocalizedString("DomainStarted",
123                                              new Object JavaDoc[] {domainName}));
124             } else {
125                 CLILogger.getInstance().printDetailMessage(getLocalizedString("DomainReady",
126                                              new Object JavaDoc[] {domainName}));
127             }
128             final boolean terse = getBooleanOption(TERSE);
129             new DomainReporter(config, terse).report();
130             long msec = System.currentTimeMillis() - start;
131
132             /* convert milliseconds duration to xxx.y seconds, where y is rounded off properly.
133              * E.g.
134                 27999 -> 28.0
135                 27449 --> 27.4
136                 27450 -> 27.5
137              */

138             double sec = ((double)Math.round( ((double)msec) / 100.0)) / 10.0;
139             CLILogger.getInstance().printDebugMessage(getLocalizedString("DomainStartTime",
140                                              new Object JavaDoc[] { sec }));
141         }
142         catch(Exception JavaDoc e)
143         {
144             CLILogger.getInstance().printDetailMessage(e.getLocalizedMessage());
145             
146             if(enableBackups)
147             {
148                 if(doBackupMessage)
149                     checkOnBackup(config);
150             }
151             
152             throw new CommandException(getLocalizedString("CannotStartDomain",
153                        new Object JavaDoc[] {domainName}), e);
154         }
155     }
156    
157     
158     /**
159      * An abstract method that Executes the command
160      * @throws CommandException
161      */

162     public void runCommand() throws CommandException, CommandValidationException
163     {
164         if (!validateOptions())
165             throw new CommandValidationException("Validation is false");
166         
167         String JavaDoc domainName = null;
168         try {
169             domainName = getDomainName();
170         } catch(Exception JavaDoc e)
171         {
172             CLILogger.getInstance().printDetailMessage(e.getLocalizedMessage());
173             domainName = domainName==null?getLocalizedString("Undefined"):domainName;
174             throw new CommandException(getLocalizedString("CannotStartDomain",
175                        new Object JavaDoc[] {domainName}), e);
176         }
177         startDomain(domainName);
178     }
179
180
181         /**
182          * This api checks and executes the upgrade commands.
183          * This api invokes checkIfVersion80(). If version is 8.0, then it will
184          * try to invoke asupgrade command.
185          * @domainName -- name of domain, this parameter is required to
186          * figure out the version of domain.
187          * @throws CommandException if error invoking asupgrade
188          **/

189     private void checkAndExecuteUpgrade(String JavaDoc domainName) throws CommandException
190     {
191         final String JavaDoc domainDir = getDomainsRoot();
192         CLILogger.getInstance().printDebugMessage("domainDir = " + domainDir);
193         final String JavaDoc installDir = System.getProperty(SystemPropertyConstants.INSTALL_ROOT_PROPERTY);
194         CLILogger.getInstance().printDebugMessage("installDir = " + installDir);
195         CLILogger.getInstance().printDebugMessage("domainName = " + domainName);
196         if (checkIfVersion80(domainName, domainDir, installDir)) {
197                 //if 8.0 or 8.1 version, then invoke asupgrade
198
try {
199                 final String JavaDoc sPasswordFile = createPasswordFileText();
200                 final String JavaDoc[] upgradeCmd = new String JavaDoc[] {installDir + File.separator +
201                                                       "bin" + File.separator +
202                                                       "asupgrade", "-c", "-s",
203                                                       domainDir+File.separator+domainName,
204                                                       "-t", installDir, "--passwordfile",
205                                                       sPasswordFile, "-noprompt" };
206
207                 ProcessExecutor pe = new ProcessExecutor(upgradeCmd, UPGRADE_TIMEOUT);
208                 pe.execute(); // timeout in 600sec or 10min
209
Process JavaDoc process = pe.getSubProcess();
210                 int exitValue = process.waitFor();
211                 if (exitValue != 0) {
212                     System.out.println("Please exeucte asupgrade manually to upgrade the configuration");
213                     throw new CommandException(getLocalizedString("UpgradeFailed"));
214                 }
215             }
216             catch (Exception JavaDoc e) {
217                     //e.printStackTrace();
218
throw new CommandException(getLocalizedString("UpgradeFailed"), e);
219             }
220         }
221     }
222     
223
224     /**
225      * This api check if the domain version is 8.0 or 8.1.
226      * @domainName - domain name to figure out the version
227      * @domainDir - domain directory
228      * @installDir - install directory
229      * @throws CommandExcpetion if error finding version
230      **/

231     private boolean checkIfVersion80(String JavaDoc domainName, String JavaDoc domainDir,
232                                      String JavaDoc installDir) throws CommandException
233     {
234         final PEFileLayout layout = new PEFileLayout(config);
235         final File JavaDoc domainFile = layout.getDomainConfigFile();
236
237         DocumentBuilderFactory JavaDoc factory = DocumentBuilderFactory.newInstance();
238
239         factory.setNamespaceAware(true);
240
241         try {
242
243             DocumentBuilder JavaDoc builder = factory.newDocumentBuilder();
244             builder.setEntityResolver((org.xml.sax.helpers.DefaultHandler JavaDoc)Class.forName
245                                       ("com.sun.enterprise.config.serverbeans.ServerValidationHandler").newInstance());
246             Document JavaDoc adminServerDoc = builder.parse(domainFile);
247             String JavaDoc publicID = adminServerDoc.getDoctype().getPublicId();
248             String JavaDoc systemID = adminServerDoc.getDoctype().getSystemId();
249             CLILogger.getInstance().printDebugMessage("publicID = " + publicID);
250             CLILogger.getInstance().printDebugMessage("systemID = " + systemID);
251                 //if domain.xml systemID=sun-domain_1_0 then the version is 8.0
252
//if domain.xml systemID=sun-domain_1_1 then the version is 8.1
253
if (publicID.indexOf(APPLICATION_SERVER_8_0) != -1 &&
254                 (systemID.indexOf(DTD_FILE_8_0) != -1 ||
255                  systemID.indexOf(DTD_FILE_8_1) != -1 )) {
256                 return true;
257             } else {
258                 return false;
259             }
260         }
261         catch (Exception JavaDoc e)
262         {
263                 //do nothing for now
264
//e.printStackTrace();
265
}
266         return false;
267     }
268
269         /**
270          * create a temporary passwordfile.txt that contains
271          * admin password and master password that is passed
272          * to asupgrade command.
273          */

274     private String JavaDoc createPasswordFileText() throws Exception JavaDoc
275     {
276         //create a temp passwordfile
277
final File JavaDoc fPasswordFile = File.createTempFile("passwordfile", null);
278         fPasswordFile.deleteOnExit();
279         PrintWriter out = new PrintWriter(new BufferedWriter(
280                                           new FileWriter(fPasswordFile.toString())));
281         out.println("AS_ADMIN_PASSWORD = " + (String JavaDoc)config.get(DomainConfig.K_PASSWORD));
282         out.println("AS_ADMIN_MASTERPASSWORD = " + (String JavaDoc)config.get(DomainConfig.K_MASTER_PASSWORD));
283         out.close();
284         return fPasswordFile.toString();
285     }
286     
287     
288
289     /**
290      * Returns the log file location for a domain
291      * @throws CommandException
292      */

293     private String JavaDoc getDomainLogFile(String JavaDoc domainName) throws CommandException
294     {
295         String JavaDoc logFile = getDomainsRoot() + File.separator + domainName +
296                          File.separator + LOGS_DIR + File.separator + SERVER_LOG_FILE_NAME;
297         return logFile;
298     }
299
300     private boolean isNotRunning(DomainsManager mgr, DomainConfig cfg) throws Exception JavaDoc
301     {
302         // note that checking for kInstanceRunningCode is not desired here
303

304         InstancesManager im = mgr.getInstancesManager(cfg);
305         int state = im.getInstanceStatus();
306
307         return state == Status.kInstanceNotRunningCode;
308     }
309
310     private boolean isStopping(DomainsManager mgr, DomainConfig cfg) throws Exception JavaDoc
311     {
312         InstancesManager im = mgr.getInstancesManager(cfg);
313         int state = im.getInstanceStatus();
314
315         return state == Status.kInstanceStoppingCode;
316     }
317
318     private void checkOnBackup(DomainConfig config)
319     {
320         // the try/catch is extra protection because we're being
321
// called from inside a catch block.
322

323         if(config == null)
324             return; // nothing we can do here...
325

326         try
327         {
328             File JavaDoc domainsRoot = new File JavaDoc(config.getRepositoryRoot());
329             File JavaDoc domainRoot = new File JavaDoc(domainsRoot, config.getDomainName());
330             File JavaDoc configDir = new File JavaDoc(domainRoot, "config");
331             File JavaDoc domainxml = new File JavaDoc(configDir, "domain.xml");
332             File JavaDoc backup = new File JavaDoc(configDir, "domain_bu.xml");
333         
334             if(backup.exists())
335                 pr("NoStartAdvice", backup.getAbsolutePath(), domainxml.getAbsolutePath());
336         }
337         catch(Exception JavaDoc e)
338         {
339         }
340     }
341
342     private void init() throws CommandException
343     {
344         mgr = getFeatureFactory().getDomainsManager();
345         CLILogger.getInstance().printDetailMessage(getLocalizedString("StartingDomain",
346                                          new Object JavaDoc[] {domainName}));
347         if (!getBooleanOption(VERBOSE))
348         {
349             CLILogger.getInstance().printDetailMessage(getLocalizedString("LogRedirectedTo",
350                 new Object JavaDoc[] {getDomainLogFile(domainName)}));
351         }
352         config = getDomainConfig(domainName);
353     }
354     
355     private void installAddons() {
356         try {
357             Class JavaDoc main = Class.forName(ADDONINSTALLER);
358             Object JavaDoc obj = main.newInstance();
359             Class JavaDoc[] types = new Class JavaDoc[] { String JavaDoc.class, String JavaDoc.class};
360             Method JavaDoc method = main.getMethod(INSTALLERMETHOD, types);
361             String JavaDoc installDir = System.getProperty(SystemPropertyConstants.INSTALL_ROOT_PROPERTY);
362             String JavaDoc domainInstanceRoot = getDomainsRoot() + File.separator + getDomainName();
363             Object JavaDoc[] args1 = new Object JavaDoc[] { installDir, domainInstanceRoot };
364             method.invoke(obj,args1);
365         }catch(Exception JavaDoc ex) {
366             CLILogger.getInstance().printDetailMessage(ex.getLocalizedMessage());
367         }
368     
369     }
370     
371     private void checkIfRunning() throws Exception JavaDoc
372     {
373         // note that isNotRunning declares 'throws Exception' !!!
374

375         if(!isNotRunning(mgr, config))
376         {
377             // bnevins Oct 2004
378
// This has officially been defined as an error. So we have to throw an Exception.
379

380             // bnevins Sept 2005
381
// we don't want to print a message saying that they should try
382
// using the backup config for this situation.
383
throw new CommandException(getLocalizedString("CannotStartDomainAlreadyRunning",
384                    new Object JavaDoc[] {domainName}));
385         }
386     }
387
388     private void checkIfStopping() throws Exception JavaDoc
389     {
390         if(isStopping(mgr, config))
391         {
392             throw new CommandException(getLocalizedString("CannotStartStoppingDomain",
393                    new Object JavaDoc[] {domainName}));
394         }
395     }
396
397     private void validateDomain() throws DomainException
398     {
399         // if the next line throws -- print backup availability message
400
mgr.validateDomain(config, true);
401     }
402     private void validateAdminPassword() throws CommandValidationException, DomainException, CommandException
403     {
404         //In PE, the admin user and password are options that are not needed and as
405
//such are ignored.
406
flags = mgr.getDomainFlags();
407         
408         if (flags.get(DomainConfig.K_FLAG_START_DOMAIN_NEEDS_ADMIN_USER)) {
409             config.put(DomainConfig.K_USER, getUser());
410             config.put(DomainConfig.K_PASSWORD, getPassword());
411             //Validate the admin user and password that was provided.
412
if (getOption(S1ASCommand.PASSWORDFILE) != null )
413                 adminPwdAlias = RelativePathResolver.getAlias( (String JavaDoc)config.get(DomainConfig.K_PASSWORD));
414             if (adminPwdAlias==null) {
415                 mgr.validateAdminUserAndPassword(config);
416             }
417         }
418     }
419
420     private void validateMasterPassword() throws Exception JavaDoc
421     {
422         final String JavaDoc masterPassword = getMasterPassword(new RepositoryManager(), config);
423         config.put(DomainConfig.K_MASTER_PASSWORD, masterPassword);
424
425         mgr.validateMasterPassword(config);
426         if (adminPwdAlias!=null) {
427             String JavaDoc domainsRoot = (String JavaDoc)config.get(DomainConfig.K_DOMAINS_ROOT);
428             String JavaDoc keyStoreFile= domainsRoot+ File.separator + domainName + File.separator + "config" + File.separator +
429                       PasswordAdapter.PASSWORD_ALIAS_KEYSTORE;
430             PasswordAdapter p =
431                 new PasswordAdapter(keyStoreFile, masterPassword.toCharArray());
432             String JavaDoc clearPwd = p.getPasswordForAlias(adminPwdAlias);
433             config.put(DomainConfig.K_PASSWORD, clearPwd);
434             mgr.validateAdminUserAndPassword(config);
435         }
436     }
437     private void saveExtraPasswordOptions() throws CommandValidationException, CommandException, DomainException
438     {
439             String JavaDoc[] extraPasswordOptions = mgr.getExtraPasswordOptions(config);
440             if (extraPasswordOptions != null) {
441                 config.put(DomainConfig.K_EXTRA_PASSWORDS, getExtraPasswords(extraPasswordOptions));
442             }
443     }
444
445     private void saveCopyOfConfig(DomainConfig config)
446     {
447         File JavaDoc domainsRoot = new File JavaDoc(config.getRepositoryRoot());
448         File JavaDoc domainRoot = new File JavaDoc(domainsRoot, config.getDomainName());
449         File JavaDoc configDir = new File JavaDoc(domainRoot, "config");
450         File JavaDoc domainxml = new File JavaDoc(configDir, "domain.xml");
451         File JavaDoc backup = new File JavaDoc(configDir, "domain_bu.xml");
452
453         try
454         {
455             FileUtils.copy(domainxml.getAbsolutePath(), backup.getAbsolutePath());
456             pr("ConfigBackedupOK", backup.getAbsolutePath());
457         }
458         catch(Exception JavaDoc e)
459         {
460             pr("ConfigBackedupNot", domainxml.getAbsolutePath(), backup.getAbsolutePath());
461         }
462     }
463     
464     private void pr(String JavaDoc id, Object JavaDoc o)
465     {
466         String JavaDoc s = getLocalizedString(id, new Object JavaDoc[]{ o } );
467         CLILogger.getInstance().printDetailMessage(s);
468     }
469
470     private void pr(String JavaDoc id, Object JavaDoc o1, Object JavaDoc o2)
471     {
472         String JavaDoc s = getLocalizedString(id, new Object JavaDoc[]{ o1, o2 } );
473         CLILogger.getInstance().printDetailMessage(s);
474     }
475 }
476
Popular Tags