| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License") + you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.openmeetings.cli; |
| |
| import static org.apache.openmeetings.utils.UserHelper.getMinPasswdLength; |
| import static org.apache.openmeetings.utils.UserHelper.invalidPassword; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.InputStreamReader; |
| import java.util.Date; |
| import java.util.Map; |
| |
| import javax.mail.internet.AddressException; |
| import javax.mail.internet.InternetAddress; |
| import javax.servlet.ServletContextEvent; |
| |
| import org.apache.commons.cli.CommandLine; |
| import org.apache.commons.cli.OptionGroup; |
| import org.apache.commons.cli.Options; |
| import org.apache.commons.cli.ParseException; |
| import org.apache.commons.cli.Parser; |
| import org.apache.commons.cli.PosixParser; |
| import org.apache.commons.transaction.util.FileHelper; |
| import org.apache.openjpa.jdbc.conf.JDBCConfiguration; |
| import org.apache.openjpa.jdbc.conf.JDBCConfigurationImpl; |
| import org.apache.openjpa.jdbc.schema.SchemaTool; |
| import org.apache.openjpa.lib.log.Log; |
| import org.apache.openjpa.lib.log.LogFactoryImpl.LogImpl; |
| import org.apache.openmeetings.data.basic.dao.ConfigurationDao; |
| import org.apache.openmeetings.data.file.dao.FileExplorerItemDao; |
| import org.apache.openmeetings.data.flvrecord.FlvRecordingDao; |
| import org.apache.openmeetings.data.user.dao.UsersDao; |
| import org.apache.openmeetings.documents.InstallationDocumentHandler; |
| import org.apache.openmeetings.installation.ImportInitvalues; |
| import org.apache.openmeetings.installation.InstallationConfig; |
| import org.apache.openmeetings.persistence.beans.files.FileExplorerItem; |
| import org.apache.openmeetings.persistence.beans.flvrecord.FlvRecording; |
| import org.apache.openmeetings.persistence.beans.user.User; |
| import org.apache.openmeetings.servlet.outputhandler.BackupExport; |
| import org.apache.openmeetings.servlet.outputhandler.BackupImportController; |
| import org.apache.openmeetings.utils.ImportHelper; |
| import org.apache.openmeetings.utils.OMContextListener; |
| import org.apache.openmeetings.utils.OmFileHelper; |
| import org.apache.openmeetings.utils.mail.MailUtil; |
| import org.apache.openmeetings.utils.math.CalendarPatterns; |
| import org.red5.logging.Red5LoggerFactory; |
| import org.slf4j.Logger; |
| import org.springframework.context.support.ClassPathXmlApplicationContext; |
| import org.springframework.scheduling.quartz.SchedulerFactoryBean; |
| |
| public class Admin { |
| private static final Logger log = Red5LoggerFactory.getLogger(Admin.class); |
| |
| private boolean verbose = false; |
| private InstallationConfig cfg = null; |
| private Options opts = null; |
| private CommandLine cmdl = null; |
| private ClassPathXmlApplicationContext ctx = null; |
| private final static String PERSISTENCE_NAME = "classes/META-INF/persistence.xml"; |
| |
| private Admin() { |
| cfg = new InstallationConfig(); |
| opts = buildOptions(); |
| } |
| |
| private Options buildOptions() { |
| Options options = new Options(); |
| OptionGroup group = new OptionGroup() |
| .addOption(new OmOption("h", 0, "h", "help", false, "prints this message")) |
| .addOption(new OmOption("b", 1, "b", "backup", false, "Backups OM")) |
| .addOption(new OmOption("r", 2, "r", "restore", false, "Restores OM")) |
| .addOption(new OmOption("i", 3, "i", "install", false, "Fill DB table, and make OM usable")) |
| .addOption(new OmOption("l", 3, "l", "languages", false, "Reimport All language files into DB")) |
| .addOption(new OmOption("f", 4, "f", "files", false, "File operations - statictics/cleanup")); |
| group.setRequired(true); |
| options.addOptionGroup(group); |
| //general |
| options.addOption(new OmOption(null, "v", "verbose", false, "verbose error messages")); |
| //backup/restore |
| options.addOption(new OmOption("b", null, "exclude-files", false, "should backup exclude files [default: include]", true)); |
| options.addOption(new OmOption("b,r,i", "file", null, true, "file used for backup/restore/install", "b")); |
| //install |
| options.addOption(new OmOption("i", "user", null, true, "Login name of the default user, minimum " + InstallationConfig.USER_LOGIN_MINIMUM_LENGTH + " characters (mutually exclusive with 'file')")); |
| options.addOption(new OmOption("i", "email", null, true, "Email of the default user (mutually exclusive with 'file')")); |
| options.addOption(new OmOption("i", "group", null, true, "The name of the default user group (mutually exclusive with 'file')")); |
| options.addOption(new OmOption("i", "tz", null, true, "Default server time zone, and time zone for the selected user (mutually exclusive with 'file')")); |
| options.addOption(new OmOption("i", null, "password", true, "Password of the default user, minimum " + InstallationConfig.USER_PASSWORD_MINIMUM_LENGTH + " characters (will be prompted if not set)", true)); |
| options.addOption(new OmOption("i", null, "system-email-address", true, "System e-mail address [default: " + cfg.mailReferer + "]", true)); |
| options.addOption(new OmOption("i", null, "smtp-server", true, "SMTP server for outgoing e-mails [default: " + cfg.smtpServer + "]", true)); |
| options.addOption(new OmOption("i", null, "smtp-port", true, "SMTP server for outgoing e-mails [default: " + cfg.smtpPort + "]", true)); |
| options.addOption(new OmOption("i", null, "email-auth-user", true, "Email auth username (anonymous connection will be used if not set)", true)); |
| options.addOption(new OmOption("i", null, "email-auth-pass", true, "Email auth password (anonymous connection will be used if not set)", true)); |
| options.addOption(new OmOption("i", null, "email-use-tls", false, "Is secure e-mail connection [default: no]", true)); |
| options.addOption(new OmOption("i", null, "skip-default-rooms", false, "Do not create default rooms [created by default]", true)); |
| options.addOption(new OmOption("i", null, "disable-frontend-register", false, "Do not allow front end register [allowed by default]", true)); |
| |
| options.addOption(new OmOption("i", null, "db-type", true, "The type of the DB to be used", true)); |
| options.addOption(new OmOption("i", null, "db-host", true, "DNS name or IP address of database", true)); |
| options.addOption(new OmOption("i", null, "db-port", true, "Database port", true)); |
| options.addOption(new OmOption("i", null, "db-name", true, "The name of Openmeetings database", true)); |
| options.addOption(new OmOption("i", null, "db-user", true, "User with write access to the DB specified", true)); |
| options.addOption(new OmOption("i", null, "db-pass", true, "Password of the user with write access to the DB specified", true)); |
| options.addOption(new OmOption("i", null, "drop", false, "Drop database before installation", true)); |
| options.addOption(new OmOption("i", null, "force", false, "Install without checking the existence of old data in the database.", true)); |
| //languages |
| options.addOption(new OmOption("l", "lang", "language", true, "Single language to be imported (id or name)", true)); |
| //files |
| options.addOption(new OmOption("f", null, "cleanup", false, "Should intermediate files be clean up", true)); |
| |
| return options; |
| } |
| |
| private enum Command { |
| install |
| , backup |
| , restore |
| , languages |
| , files |
| , usage |
| } |
| |
| private void usage() { |
| OmHelpFormatter formatter = new OmHelpFormatter(); |
| formatter.setWidth(100); |
| formatter.printHelp("admin", "Please specify one of the required parameters.", opts, "Examples:\n" + |
| "\t./admin.sh -b\n" + |
| "\t./admin.sh -i -v -file backup_31_07_2012_12_07_51.zip --drop\n" + |
| "\t./admin.sh -i -v -user admin -email someemail@gmail.com -tz \"Asia/Tehran\" -group \"yourgroup\" --db-type mysql --db-host localhost"); |
| } |
| |
| private void handleError(String msg, Exception e) { |
| handleError(msg, e, false); |
| } |
| |
| private void handleError(String msg, Exception e, boolean printUsage) { |
| if (printUsage) { |
| usage(); |
| } |
| if (verbose) { |
| log.error(msg, e); |
| } else { |
| log.error(msg + " " + e.getMessage()); |
| } |
| System.exit(1); |
| } |
| |
| private ClassPathXmlApplicationContext getApplicationContext(final String ctxName) { |
| if (ctx == null) { |
| OMContextListener omcl = new OMContextListener(); |
| omcl.contextInitialized(new ServletContextEvent(new DummyServletContext(ctxName))); |
| try { |
| ctx = new ClassPathXmlApplicationContext("openmeetings-applicationContext.xml"); |
| } catch (Exception e) { |
| handleError("Unable to obtain application context", e); |
| } |
| SchedulerFactoryBean sfb = ctx.getBean(SchedulerFactoryBean.class); |
| try { |
| sfb.getScheduler().shutdown(false); |
| } catch (Exception e) { |
| handleError("Unable to shutdown schedulers", e); |
| } |
| } |
| return ctx; |
| } |
| |
| private void process(String[] args) { |
| String ctxName = System.getProperty("context", "openmeetings"); |
| File home = new File(System.getenv("RED5_HOME")); |
| OmFileHelper.setOmHome(new File(new File(home, "webapps"), ctxName)); |
| |
| Parser parser = new PosixParser(); |
| try { |
| cmdl = parser.parse(opts, args); |
| } catch (ParseException e) { |
| System.out.println(e.getMessage()); |
| usage(); |
| System.exit(1); |
| } |
| verbose = cmdl.hasOption('v'); |
| |
| Command cmd = Command.usage; |
| if (cmdl.hasOption('i')) { |
| cmd = Command.install; |
| } else if (cmdl.hasOption('b')) { |
| cmd = Command.backup; |
| } else if (cmdl.hasOption('r')) { |
| cmd = Command.restore; |
| } else if (cmdl.hasOption('l')) { |
| cmd = Command.languages; |
| } else if (cmdl.hasOption('f')) { |
| cmd = Command.files; |
| } |
| |
| String file = cmdl.getOptionValue("file", ""); |
| switch(cmd) { |
| case install: |
| try { |
| if (cmdl.hasOption("file") && (cmdl.hasOption("user") || cmdl.hasOption("email") || cmdl.hasOption("group"))) { |
| System.out.println("Please specify even 'file' option or 'admin user'."); |
| System.exit(1); |
| } |
| boolean force = cmdl.hasOption("force"); |
| if (cmdl.hasOption("skip-default-rooms")) { |
| cfg.createDefaultRooms = "0"; |
| } |
| if (cmdl.hasOption("disable-frontend-register")) { |
| cfg.allowFrontendRegister = "0"; |
| } |
| if (cmdl.hasOption("system-email-address")) { |
| cfg.mailReferer = cmdl.getOptionValue("system-email-address"); |
| } |
| if (cmdl.hasOption("smtp-server")) { |
| cfg.smtpServer = cmdl.getOptionValue("smtp-server"); |
| } |
| if (cmdl.hasOption("smtp-port")) { |
| cfg.smtpPort = cmdl.getOptionValue("smtp-port"); |
| } |
| if (cmdl.hasOption("email-auth-user")) { |
| cfg.mailAuthName = cmdl.getOptionValue("email-auth-user"); |
| } |
| if (cmdl.hasOption("email-auth-pass")) { |
| cfg.mailAuthPass = cmdl.getOptionValue("email-auth-pass"); |
| } |
| if (cmdl.hasOption("email-use-tls")) { |
| cfg.mailUseTls = "1"; |
| } |
| ConnectionProperties connectionProperties = new ConnectionProperties(); |
| File conf = new File(OmFileHelper.getWebinfDir(), PERSISTENCE_NAME); |
| if (!conf.exists() || cmdl.hasOption("db-type") || cmdl.hasOption("db-host") || cmdl.hasOption("db-port") || cmdl.hasOption("db-name") || cmdl.hasOption("db-user") || cmdl.hasOption("db-pass")) { |
| String dbType = cmdl.getOptionValue("db-type", "derby"); |
| File srcConf = new File(OmFileHelper.getWebinfDir(), "classes/META-INF/" + dbType + "_persistence.xml"); |
| ConnectionPropertiesPatcher.getPatcher(dbType, connectionProperties).patch( |
| srcConf |
| , conf |
| , cmdl.getOptionValue("db-host", "localhost") |
| , cmdl.getOptionValue("db-port", null) |
| , cmdl.getOptionValue("db-name", null) |
| , cmdl.getOptionValue("db-user", null) |
| , cmdl.getOptionValue("db-pass", null) |
| ); |
| } else { |
| //get properties from existent persistence.xml |
| connectionProperties = ConnectionPropertiesPatcher.getConnectionProperties(conf); |
| } |
| if (cmdl.hasOption("file")) { |
| File backup = checkRestoreFile(file); |
| dropDB(connectionProperties); |
| |
| ImportInitvalues importInit = getApplicationContext(ctxName).getBean(ImportInitvalues.class); |
| importInit.loadSystem(cfg, force); |
| restoreOm(ctxName, backup); |
| } else { |
| checkAdminDetails(ctxName); |
| dropDB(connectionProperties); |
| |
| ImportInitvalues importInit = getApplicationContext(ctxName).getBean(ImportInitvalues.class); |
| importInit.loadAll(cfg, force); |
| } |
| |
| InstallationDocumentHandler.createDocument(3); |
| } catch(Exception e) { |
| handleError("Install failed", e); |
| } |
| break; |
| case backup: |
| try { |
| File f; |
| if (!cmdl.hasOption("file")) { |
| file = "backup_" + CalendarPatterns.getTimeForStreamId(new Date()) + ".zip"; |
| f = new File(home, file); |
| System.out.println("File name was not specified, '" + file + "' will be used"); |
| } else { |
| f = new File(file); |
| } |
| boolean includeFiles = Boolean.parseBoolean(cmdl.getOptionValue("exclude-files", "true")); |
| File backup_dir = new File(OmFileHelper.getUploadTempDir(), "" + System.currentTimeMillis()); |
| backup_dir.mkdirs(); |
| |
| BackupExport export = getApplicationContext(ctxName).getBean(BackupExport.class); |
| export.performExport(f, backup_dir, includeFiles); |
| FileHelper.removeRec(backup_dir); |
| backup_dir.delete(); |
| } catch (Exception e) { |
| handleError("Backup failed", e); |
| } |
| break; |
| case restore: |
| try { |
| restoreOm(ctxName, checkRestoreFile(file)); |
| } catch (Exception e) { |
| handleError("Restore failed", e); |
| } |
| break; |
| case languages: |
| System.out.println("All language files will be reimported"); |
| try { |
| ImportInitvalues importInit = getApplicationContext(ctxName).getBean(ImportInitvalues.class); |
| if (cmdl.hasOption("lang")) { |
| String lang = cmdl.getOptionValue("lang"); |
| System.out.println("Only '" + lang + "' language will be reimported"); |
| try { |
| int id = Integer.parseInt(lang); |
| importInit.loadLanguagesFile(id); |
| } catch (NumberFormatException e) { |
| importInit.loadLanguagesFile(lang); |
| } |
| } else { |
| System.out.println("All language files will be reimported"); |
| importInit.loadLanguagesFiles(); |
| } |
| } catch (Exception e) { |
| handleError("Language reimport failed", e); |
| } |
| break; |
| case files: |
| try { |
| boolean cleanup = cmdl.hasOption("cleanup"); |
| if (cleanup) { |
| System.out.println("WARNING: all intermadiate files will be clean up!"); |
| } |
| StringBuilder report = new StringBuilder(); |
| report.append("Temporary files allocates: ").append(OmFileHelper.getHumanSize(OmFileHelper.getUploadTempDir())).append("\n"); |
| { //UPLOAD |
| long sectionSize = OmFileHelper.getSize(OmFileHelper.getUploadDir()); |
| report.append("Upload totally allocates: ").append(OmFileHelper.getHumanSize(sectionSize)).append("\n"); |
| //Profiles |
| File profiles = OmFileHelper.getUploadProfilesDir(); |
| long invalid = 0; |
| long deleted = 0; |
| ClassPathXmlApplicationContext ctx = getApplicationContext(ctxName); |
| UsersDao udao = ctx.getBean(UsersDao.class); |
| for (File profile : profiles.listFiles()) { |
| long pSize = OmFileHelper.getSize(profile); |
| long userId = getUserIdByProfile(profile.getName()); |
| User u = udao.get(userId); |
| if (profile.isFile() || userId < 0 || u == null) { |
| if (cleanup) { |
| FileHelper.removeRec(profile); |
| } else { |
| invalid += pSize; |
| } |
| } else if (u.getDeleted()) { |
| if (cleanup) { |
| FileHelper.removeRec(profile); |
| } else { |
| deleted += pSize; |
| } |
| } |
| } |
| long missing = 0; |
| for (User u : udao.getAllUsersDeleted()) { |
| if (!u.getDeleted() && u.getPictureuri() != null && !new File(OmFileHelper.getUploadProfilesUserDir(u.getUser_id()), u.getPictureuri()).exists()) { |
| missing++; |
| } |
| } |
| long size = OmFileHelper.getSize(profiles); |
| long restSize = sectionSize - size; |
| report.append("\t\tprofiles: ").append(OmFileHelper.getHumanSize(size)).append("\n"); |
| report.append("\t\t\tinvalid: ").append(OmFileHelper.getHumanSize(invalid)).append("\n"); |
| report.append("\t\t\tdeleted: ").append(OmFileHelper.getHumanSize(deleted)).append("\n"); |
| report.append("\t\t\tmissing count: ").append(missing).append("\n"); |
| size = OmFileHelper.getSize(OmFileHelper.getUploadImportDir()); |
| restSize -= size; |
| report.append("\t\timport: ").append(OmFileHelper.getHumanSize(size)).append("\n"); |
| size = OmFileHelper.getSize(OmFileHelper.getUploadBackupDir()); |
| restSize -= size; |
| report.append("\t\tbackup: ").append(OmFileHelper.getHumanSize(size)).append("\n"); |
| //Files |
| File files = OmFileHelper.getUploadFilesDir(); |
| size = OmFileHelper.getSize(files); |
| restSize -= size; |
| FileExplorerItemDao fileDao = ctx.getBean(FileExplorerItemDao.class); |
| invalid = 0; |
| deleted = 0; |
| for (File f : files.listFiles()) { |
| long fSize = OmFileHelper.getSize(f); |
| FileExplorerItem item = fileDao.getFileExplorerItemsByHash(f.getName()); |
| if (item == null) { |
| if (cleanup) { |
| FileHelper.removeRec(f); |
| } else { |
| invalid += fSize; |
| } |
| } else if (item.getDeleted()) { |
| if (cleanup) { |
| FileHelper.removeRec(f); |
| } else { |
| deleted += fSize; |
| } |
| } |
| } |
| missing = 0; |
| for (FileExplorerItem item : fileDao.getFileExplorerItems()) { |
| if (!item.getDeleted() && !new File(files, item.getFileHash()).exists()) { |
| missing++; |
| } |
| } |
| report.append("\t\tfiles: ").append(OmFileHelper.getHumanSize(size)).append("\n"); |
| report.append("\t\t\tinvalid: ").append(OmFileHelper.getHumanSize(invalid)).append("\n"); |
| report.append("\t\t\tdeleted: ").append(OmFileHelper.getHumanSize(deleted)).append("\n"); |
| report.append("\t\t\tmissing count: ").append(missing).append("\n"); |
| report.append("\t\trest: ").append(OmFileHelper.getHumanSize(restSize)).append("\n"); |
| } |
| { //STREAMS |
| File streamsDir = OmFileHelper.getStreamsDir(); |
| File hibernateDir = OmFileHelper.getStreamsHibernateDir(); |
| if (cleanup) { |
| String hiberPath = hibernateDir.getCanonicalPath(); |
| for (File f : streamsDir.listFiles()) { |
| if (!f.getCanonicalPath().equals(hiberPath)) { |
| FileHelper.removeRec(f); |
| } |
| } |
| } |
| long sectionSize = OmFileHelper.getSize(streamsDir); |
| report.append("Recordings allocates: ").append(OmFileHelper.getHumanSize(sectionSize)).append("\n"); |
| long size = OmFileHelper.getSize(hibernateDir); |
| long restSize = sectionSize - size; |
| FlvRecordingDao recordDao = ctx.getBean(FlvRecordingDao.class); |
| long[] params = {0, 0}; // [0] == deleted [1] == missing |
| for (FlvRecording rec : recordDao.getAllFlvRecordings()) { |
| checkRecordingFile(hibernateDir, rec.getFileHash(), rec.getDeleted(), params, cleanup); |
| checkRecordingFile(hibernateDir, rec.getAlternateDownload(), rec.getDeleted(), params, cleanup); |
| checkRecordingFile(hibernateDir, rec.getPreviewImage(), rec.getDeleted(), params, cleanup); |
| } |
| long invalid = 0; |
| for (File f : hibernateDir.listFiles()) { |
| if (f.isFile() && f.getName().endsWith(".flv")) { |
| FlvRecording rec = recordDao.getRecordingByHash(f.getName()); |
| if (rec == null) { |
| if (cleanup) { |
| FileHelper.removeRec(f); |
| } else { |
| invalid += f.length(); |
| } |
| String name = f.getName().substring(0, f.getName().length() - 5); |
| File rfa = new File(hibernateDir, name + ".avi"); |
| if (rfa.exists()) { |
| if (cleanup) { |
| FileHelper.removeRec(rfa); |
| } else { |
| invalid += rfa.length(); |
| } |
| } |
| File rfj = new File(hibernateDir, name + ".jpg"); |
| if (rfj.exists()) { |
| if (cleanup) { |
| FileHelper.removeRec(rfj); |
| } else { |
| invalid += rfj.length(); |
| } |
| } |
| } |
| } |
| } |
| report.append("\t\tfinal: ").append(OmFileHelper.getHumanSize(size)).append("\n"); |
| report.append("\t\t\tinvalid: ").append(OmFileHelper.getHumanSize(invalid)).append("\n"); |
| report.append("\t\t\tdeleted: ").append(OmFileHelper.getHumanSize(params[0])).append("\n"); |
| report.append("\t\t\tmissing count: ").append(params[1]).append("\n"); |
| report.append("\t\trest: ").append(OmFileHelper.getHumanSize(restSize)).append("\n"); |
| } |
| System.out.println(report); |
| } catch (Exception e) { |
| handleError("Files failed", e); |
| } |
| break; |
| case usage: |
| default: |
| usage(); |
| break; |
| } |
| |
| System.out.println("... Done"); |
| System.exit(0); |
| } |
| |
| private void checkRecordingFile(File hibernateDir, String name, boolean deleted, long[] params, boolean cleanup) { |
| File flv = name != null ? new File(hibernateDir, name) : null; |
| if (flv != null) { |
| if (flv.exists() && flv.isFile()) { |
| if (deleted) { |
| params[0] += flv.length(); |
| if (cleanup) { |
| FileHelper.removeRec(flv); |
| } |
| } |
| } else { |
| params[1]++; |
| } |
| } |
| } |
| |
| private long getUserIdByProfile(String name) { |
| long result = -1; |
| if (name.startsWith(OmFileHelper.profilesPrefix)) { |
| try { |
| result = Long.parseLong(name.substring(OmFileHelper.profilesPrefix.length())); |
| } catch (Exception e) { |
| //noop |
| } |
| } |
| return result; |
| } |
| |
| private void checkAdminDetails(String ctxName) throws Exception { |
| cfg.username = cmdl.getOptionValue("user"); |
| cfg.email = cmdl.getOptionValue("email"); |
| cfg.group = cmdl.getOptionValue("group"); |
| if (cfg.username == null || cfg.username.length() < InstallationConfig.USER_LOGIN_MINIMUM_LENGTH) { |
| System.out.println("User login was not provided, or too short, should be at least " + InstallationConfig.USER_LOGIN_MINIMUM_LENGTH + " character long."); |
| System.exit(1); |
| } |
| |
| try { |
| if (!MailUtil.matches(cfg.email)) { |
| throw new AddressException("Invalid address"); |
| } |
| new InternetAddress(cfg.email, true); |
| } catch (AddressException ae) { |
| System.out.println("Please provide non-empty valid email: '" + cfg.email + "' is not valid."); |
| System.exit(1); |
| } |
| if (cfg.group == null || cfg.group.length() < 1) { |
| System.out.println("User group was not provided, or too short, should be at least 1 character long: " + cfg.group); |
| System.exit(1); |
| } |
| cfg.password = cmdl.getOptionValue("password"); |
| ConfigurationDao cfgDao = getApplicationContext(ctxName).getBean(ConfigurationDao.class); |
| if (invalidPassword(cfg.password, cfgDao)) { |
| System.out.print("Please enter password for the user '" + cfg.username + "':"); |
| cfg.password = new BufferedReader(new InputStreamReader(System.in)).readLine(); |
| if (invalidPassword(cfg.password, cfgDao)) { |
| System.out.println("Password was not provided, or too short, should be at least " + getMinPasswdLength(cfgDao) + " character long."); |
| System.exit(1); |
| } |
| } |
| ImportInitvalues importInit = getApplicationContext(ctxName).getBean(ImportInitvalues.class); |
| Map<String, String> tzMap = ImportHelper.getAllTimeZones(importInit.getTimeZones()); |
| cfg.ical_timeZone = null; |
| if (cmdl.hasOption("tz")) { |
| cfg.ical_timeZone = cmdl.getOptionValue("tz"); |
| cfg.ical_timeZone = tzMap.containsKey(cfg.ical_timeZone) ? cfg.ical_timeZone : null; |
| } |
| if (cfg.ical_timeZone == null) { |
| System.out.println("Please enter timezone, Possible timezones are:"); |
| |
| for (String tzIcal : tzMap.keySet()) { |
| System.out.println(String.format("%1$-25s%2$s", "\"" + tzIcal + "\"", tzMap.get(tzIcal))); |
| } |
| System.exit(1); |
| } |
| } |
| |
| public static void dropDB() throws Exception { |
| File conf = new File(OmFileHelper.getWebinfDir(), PERSISTENCE_NAME); |
| ConnectionProperties connectionProperties = ConnectionPropertiesPatcher.getConnectionProperties(conf); |
| immediateDropDB(connectionProperties); |
| } |
| |
| private void dropDB(ConnectionProperties props) throws Exception { |
| if(cmdl.hasOption("drop")) { |
| immediateDropDB(props); |
| } |
| } |
| |
| private static LogImpl getLogImpl(JDBCConfiguration conf) { |
| return (LogImpl)conf.getLog(JDBCConfiguration.LOG_SCHEMA); |
| } |
| |
| private static void immediateDropDB(ConnectionProperties props) throws Exception { |
| JDBCConfigurationImpl conf = new JDBCConfigurationImpl(); |
| try { |
| conf.setPropertiesFile(new File(OmFileHelper.getWebinfDir(), PERSISTENCE_NAME)); |
| conf.setConnectionDriverName(props.getDriver()); |
| conf.setConnectionURL(props.getURL()); |
| conf.setConnectionUserName(props.getLogin()); |
| conf.setConnectionPassword(props.getPassword()); |
| //HACK to suppress all warnings |
| getLogImpl(conf).setLevel(Log.INFO); |
| SchemaTool st = new SchemaTool(conf, SchemaTool.ACTION_DROPDB); |
| st.setIgnoreErrors(true); |
| st.setOpenJPATables(true); |
| st.setIndexes(false); |
| st.setPrimaryKeys(false); |
| st.run(); |
| } finally { |
| conf.close(); |
| } |
| } |
| |
| private File checkRestoreFile(String file) { |
| File backup = new File(file); |
| if (!cmdl.hasOption("file") || !backup.exists() || !backup.isFile()) { |
| System.out.println("File should be specified, and point the existent zip file"); |
| usage(); |
| System.exit(1); |
| } |
| |
| return backup; |
| } |
| |
| private void restoreOm(String ctxName, File backup) { |
| try { |
| BackupImportController importCtrl = getApplicationContext(ctxName).getBean(BackupImportController.class); |
| importCtrl.performImport(new FileInputStream(backup)); |
| } catch (Exception e) { |
| handleError("Restore failed", e); |
| } |
| } |
| |
| public static void main(String[] args) { |
| new Admin().process(args); |
| } |
| } |