Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package ca.carleton.gcrc.couch.command;
  
  import java.io.File;
  import java.net.URL;
  import java.util.Stack;
 
 
 public class CommandConfig implements Command {
 	
 	final static private Pattern patternAtlasName = Pattern.compile("^[a-zA-Z][a-zA-Z0-9_]*$");
 	final static private Pattern patternDbName = Pattern.compile("^[a-z][a-z0-9]*$");
 
 	public String getCommandString() {
 		return "config";
 	}
 
 	public boolean matchesKeyword(String keyword) {
 		ifgetCommandString().equalsIgnoreCase(keyword) ) {
 			return true;
 		}
 		return false;
 	}
 
 	public boolean requiresAtlasDir() {
 		return true;
 	}
 
 	public void reportHelp(PrintStream ps) {
 		ps.println("Nunaliit2 Atlas Framework - Configuration Command");
 		ps.println();
 		ps.println("The configuration command allows a user to changes the parameters");
 		ps.println("used to access and update an atlas.");
 		ps.println();
 		ps.println("Command Syntax:");
 		ps.println("  nunaliit [<global-options>] config");
 		ps.println();
 		ps.println("Global Options");
 		CommandHelp.reportGlobalSettingAtlasDir(ps);
 	}
 
 	public void runCommand(
 		,Stack<StringargumentStack
 		) throws Exception {
 		
 		// Check that atlas directory exists
 		File atlasDir = gs.getAtlasDir();
 		
 		// Load up properties
 		AtlasProperties.readProperties(atlasDirprops);
 		
 		// Get user to enter properties
 		userInputProperties(gsprops);
 		
 		// Write properties
 		AtlasProperties.writeProperties(atlasDirprops);
 		writeExtras(gsatlasDirprops);
 	}
 	
 	private void userInputProperties(GlobalSettings gsProperties propsthrows Exception {
 		
 		// Atlas Name
 		{
 			String atlasName = null;
 			String defaultValue = props.getProperty("atlas.name");
 			ifnull == defaultValue || "".equals(defaultValue) ){
 				defaultValue = gs.getAtlasDir().getName();
 			}
 			whilenull == atlasName ) {
 				atlasName = getUserInput(gs"Enter the name of the atlas"defaultValue);
 				ifnull == atlasName ){
 					gs.getErrStream().println("An atlas name must be provided");
 				} else {
 					Matcher matcher = .matcher(atlasName);
 					iffalse == matcher.matches() ) {
 						gs.getErrStream().println("An atlas name must start with a letter and be composed alpha-numerical characters");
 						atlasName = null;
 					}
 				}
 			}
 			props.put("atlas.name"atlasName);
 		}
 		
 		// CouchDB protocol
 		{
 			URL url = null;
			String urlString = null;
			whilenull == url ) {
				urlString = getUserInput(gs"Enter the URL to CouchDB"props"couchdb.url");
				ifnull == urlString ){
					gs.getErrStream().println("A URL must be provided for CouchDB");
else {
					try {
						url = new URL(urlString);
catch(Exception e) {
						gs.getErrStream().println("An invalid URL was entered");
					}
				}
			}
			props.put("couchdb.url"urlString);
			props.put("couchdb.url.protocol"url.getProtocol());
			props.put("couchdb.url.port"""+url.getPort());
			props.put("couchdb.url.domain"url.getHost());
			props.put("couchdb.url.path"url.getPath());
		}
		// CouchDB database name
		{
			String dbName = null;
			String defaultValue = props.getProperty("couchdb.dbName");
			ifnull == defaultValue || "".equals(defaultValue) ){
				defaultValue = gs.getAtlasDir().getName();
			}
			whilenull == dbName ) {
				dbName = getUserInput(gs"Enter the name of the database where atlas resides"defaultValue);
				ifnull == dbName ){
					gs.getErrStream().println("A name for the database must be provided");
else {
					Matcher matcher = .matcher(dbName);
					iffalse == matcher.matches() ) {
						gs.getErrStream().println("An database name must start with a lowercase letter and be composed lowercase alpha-numerical characters");
						dbName = null;
					}
				}
			}
			props.put("couchdb.dbName"dbName);
		}
		// CouchDB admin name
		{
			String adminName = null;
			whilenull == adminName ) {
				adminName = getUserInput(gs"Enter the name of the admin user for CouchDB"props"couchdb.admin.user");
				ifnull == adminName ){
					gs.getErrStream().println("A name for the admin user must be provided");
				}
			}
			props.put("couchdb.admin.user"adminName);
		}
		// CouchDB admin password
		{
			String adminPassword = null;
			whilenull == adminPassword ) {
				adminPassword = getUserInput(gs"Enter the password for the admin user"props"couchdb.admin.password");
				ifnull == adminPassword ){
					gs.getErrStream().println("A password for the admin user must be provided");
				}
			}
			props.put("couchdb.admin.password"adminPassword);
		}
		// Servlet port
		{
			String portString = null;
			whilenull == portString ) {
				portString = getUserInput(gs"Enter the port where the atlas is served"props"servlet.url.port");
				ifnull == portString ){
					gs.getErrStream().println("A service port must be provided");
else {
					try {
						int port = Integer.parseInt(portString);
						if( 0 == port || port > 65535 ) {
							portString = null;
						}
catch(Exception e){
						portString = null;
					}
					ifnull == portString ) {
						gs.getErrStream().println("Invalid port. It must be a positive integer up to 65535");
					}
				}
			}
			props.put("servlet.url.port"portString);
		}
	}
	private String getUserInput(GlobalSettings gsString promptProperties propsString propNamethrows Exception {
		String defaultValue = props.getProperty(propName);
		return getUserInput(gspromptdefaultValue);
	}
	private String getUserInput(GlobalSettings gsString promptString defaultValuethrows Exception {
		BufferedReader reader = gs.getInReader();
		// Prompt user
		gs.getOutStream().print(prompt);
		ifnull != defaultValue ){
			gs.getOutStream().print(" [");
			gs.getOutStream().print(defaultValue);
		}
		gs.getOutStream().print(": ");
		// Read answer
		String line = null;
		try {
			line = reader.readLine();
catch(Exception e) {
			throw new Exception("Error while reading configuration information from user",e);
		}
		String atlasName = null;
		ifnull == line ) {
			// End of stream reached
			throw new Exception("End of input stream reached");
else {
			line = line.trim();
			if"".equals(line) ){
				atlasName = defaultValue;
else {
				atlasName = line;
			}
		}
		return atlasName;
	}
		Properties props = new Properties();
		return props;
	}
	private void writeExtras(GlobalSettings gsFile atlasDirProperties propsthrows Exception {
		CopyMachine copyMachine = new CopyMachine();
		File binDir = PathComputer.computeBinDir(gs.getInstallDir());
		ifnull != binDir ) {
			copyMachine.addTextConversion("NUNALIIT_BIN_DIR"binDir.getAbsolutePath());
		}
		copyMachine.addTextConversion("ATLAS_DIR"atlasDir.getAbsolutePath());
		copyMachine.addTextConversion("ATLAS_NAME"props.getProperty("atlas.name"));
		File templateDir = PathComputer.computeTemplatesDirgs.getInstallDir() );
		File sourceExtra = new File(templateDir"extra");
		File destExtra = new File(atlasDir"extra");
		copyMachine.copyDir(new FSEntryFile(sourceExtra), destExtra);
	}
New to GrepCode? Check out our FAQ X