Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package divconq.tool.release;
  
  import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 
 public class Main implements ILocalCommandLine {
 	public void run(Scanner scanApiSession api) {
 		Path relpath = null;
 		Path gitpath = null;
 		Path wikigitpath = null;
 		
 		XElement fldset = ..getConfig().selectFirst("CommandLine/Settings");
 		
 		if (fldset != null) {
 			relpath = Paths.get(fldset.getAttribute("ReleasePath"));			
 			gitpath = Paths.get(fldset.getAttribute("GitPath"));
 			wikigitpath = Paths.get(fldset.getAttribute("WikiGitPath"));
 		}
 		
 		boolean running = true;
 		
 		while(running) {
 			try {
 				..println("-----------------------------------------------");
 				..println("   Release Builder Menu");
 				..println("-----------------------------------------------");
 				..println("0)  Exit");
 				
 				if (relpath != null)
 					..println("1)  Build release package from Settings File");
 				
 				..println("2)  Build custom release package [under construction]");
 				
 				..println("4)  Pack the .jar files");
 				
 				if (gitpath != null)
 					..println("5)  Copy Source to GitHub folder");
 
 				String opt = scan.nextLine();
 				
 				Long mopt = StringUtil.parseInt(opt);
 				
 				if (mopt == null)
 					continue;
 				
 				switch (mopt.intValue()) {
 				case 0:
 					running = false;
 					break;
 					
 				case 1: {
 					if (relpath == null) {
 						..println("Release path not defined");
 						break;
 					}
 						
 					FuncResult<XElementxres = XmlReader.loadFile(relpath.resolve("release.xml"), false);
 					
 					if (xres.hasErrors()) {
 						..println("Release settings file is not present or has bad xml structure");
 						break;
 					}
					List<XElementrellist = xres.getResult().selectAll("Release");
					..println("Select a release to build");
					..println("0) None");
					for (int i = 0; i < rellist.size(); i++)
						..println((i+1) + ") " + rellist.get(i).getAttribute("Name"));
					..println("Option #: ");
					opt = scan.nextLine();
					mopt = StringUtil.parseInt(opt);
					if (mopt == null)
						break;
					if (mopt < 0 || mopt > rellist.size()) {
						..println("Invalid option");
						break;
					}
					if (mopt == 0) 
						break;
					XElement relchoice = rellist.get(mopt.intValue() - 1);
					boolean includeinstaller = Struct.objectToBooleanOrFalse(relchoice.getAttribute("IncludeInstaller"));
					String prinpackage = relchoice.getAttribute("PrincipalPackage");
					int pspos = prinpackage.lastIndexOf('/');
					String prinpackagenm = (pspos != -1) ? prinpackage.substring(pspos + 1) : prinpackage;
					Set<Stringinstpkgs = new HashSet<>(); 
					instpkgs.add(prinpackage);
					if (includeinstaller)
						instpkgs.add("dc/dcInstall");
					Set<Stringrelopts = new HashSet<>(); 
					if (relchoice.hasAttribute("Options"))
						relopts.addAll(Arrays.asList(relchoice.getAttribute("Options").split(",")));
					relchoice.selectAll("Package").stream().forEach(pkg -> instpkgs.add(pkg.getAttribute("Name")));
					..println("Selected packages: " + instpkgs);
					Path pkgspath = Paths.get("./packages");
					Map<StringXElementavailpackages = new HashMap<>();
					Files.walkFileTree(pkgspathnew SimpleFileVisitor<Path>() {
							Path pkgdesc = path.resolve("package.xml");
							if (Files.exists(pkgdesc)) {
								FuncResult<XElementxres = XmlReader.loadFile(path.resolve("package.xml"), false);
								if (xres.hasErrors()) 
									..println("package.xml found, but not usable: " + path);
								else 
									availpackages.put(pkgspath.relativize(path).toString().replace('\\''/'), xres.getResult());
							}
						}
					});
					..println("Available packages: " + availpackages.keySet());
					AtomicBoolean errored = new AtomicBoolean(false); 
					String[] coreinst = instpkgs.toArray(new String[instpkgs.size()]);
					for (int i = 0; i < coreinst.lengthi++)
						this.collectPackageDependencies(instpkgsavailpackagesreloptscoreinst[i], errored);
					if (errored.get()) {
						..println("Error with package dependencies");
						break;
					}
					..println("All release packages: " + instpkgs);
					XElement prindesc = availpackages.get(prinpackage);
					XElement prininst = prindesc.find("Install");
					if (prininst == null) {
						..println("Principle package: " + prinpackage + " cannot be released directly, it must be part of another package.");
						break;
					}
					String relvers = prindesc.getAttribute("Version");
					..println("Building release version " + relvers);
					if (prindesc.hasAttribute("LastVersion"))
						..println("Previous release version " + prindesc.getAttribute("LastVersion"));
					String rname = relchoice.getAttribute("Name");
					Path destpath = relpath.resolve(rname + "/" + rname + "-" + relvers + "-bin.zip");
					if (Files.exists(destpath)) {
						..println("Version " + relvers + " already exists, overwrite? (y/n): ");
						if (!scan.nextLine().toLowerCase().startsWith("y"))
							break;
						Files.delete(destpath);
					}
					..println("Preparing zip files");
					Path tempfolder = FileUtil.allocateTempFolder2();
					ListStruct ignorepaths = new ListStruct();
					Set<Stringnolongerdepends = new HashSet<>();
					Set<Stringdependson = new HashSet<>();
					// put all the release files into a temp folder
					instpkgs.forEach(pname -> {
						availpackages.get(pname)
							.selectAll("DependsOn").stream()
							.filter(doel -> !doel.hasAttribute("Option") || relopts.contains(doel.getAttribute("Option")))
							.forEach(doel -> {
								// copy all libraries we rely on
								doel.selectAll("Library").forEach(libel -> {
									dependson.add(libel.getAttribute("File"));
									Path src = Paths.get("./lib/" + libel.getAttribute("File"));
									Path dest = tempfolder.resolve("lib/" + libel.getAttribute("File"));
									try {
										if (Files.notExists(dest))
									catch (Exception x) {
										errored.set(true);
										..println("Unable to copy file: " + src);
									}
								});
								// copy all files we rely on
								doel.selectAll("File").forEach(libel -> {
									Path src = Paths.get("./" + libel.getAttribute("Path"));
									Path dest = tempfolder.resolve(libel.getAttribute("Path"));
									try {
										if (Files.notExists(dest))
									catch (Exception x) {
										errored.set(true);
										..println("Unable to copy file: " + src);
									}
								});
								// copy all folders we rely on
								doel.selectAll("Folder").forEach(libel -> {
									Path src = Paths.get("./" + libel.getAttribute("Path"));
									Path dest = tempfolder.resolve(libel.getAttribute("Path"));
									try {
									catch (Exception x) {
										errored.set(true);
										..println("Unable to copy file: " + src);
									}
									OperationResult cres = FileUtil.copyFileTree(srcdest);
									if (cres.hasErrors())
										errored.set(true);
								});
							});
						availpackages.get(pname)
							.selectAll("IgnorePaths/Ignore")
							.forEach(doel -> ignorepaths.addItem(doel.getAttribute("Path")));
						// NoLongerDependsOn functionally currently only applies to libraries
						availpackages.get(pname)
							.selectAll("NoLongerDependsOn/Library")
							.forEach(doel -> nolongerdepends.add(doel.getAttribute("File")));
						// copy the released packages folders
						Path src = Paths.get("./packages/" + pname);
						Path dest = tempfolder.resolve("packages/" + pname);
						try {
						catch (Exception x) {
							errored.set(true);
							..println("Unable to copy file: " + src);
						}
						// we may wish to enhance filter to allow .JAR sometimes, but this is meant to prevent copying of packages/pname/lib/abc.lib.jar files 
						OperationResult cres = FileUtil.copyFileTree(srcdestpath -> !path.toString().endsWith(".jar"));
						if (cres.hasErrors())
							errored.set(true);
						// copy the released packages libraries
						Path libsrc = Paths.get("./packages/" + pname + "/lib");
						Path libdest = tempfolder.resolve("lib");
						if (Files.exists(libsrc)) {
							cres = FileUtil.copyFileTree(libsrclibdest);
							if (cres.hasErrors())
								errored.set(true);
						}
					});
					if (errored.get()) {
						..println("Error with assembling package");
						break;
					}
					// copy the principle config
					Path csrc = Paths.get("./packages/" + prinpackage + "/config");
					Path cdest = tempfolder.resolve("config/" + prinpackagenm);
					if (Files.exists(csrc)) {
						Files.createDirectories(cdest);
						OperationResult cres = FileUtil.copyFileTree(csrccdest);
						if (cres.hasErrors()) {
							..println("Error with prepping config");
							break;
						}
					}
					boolean configpassed = true;
					// copy packages with config = true
					for (XElement pkg : relchoice.selectAll("Package")) {
						if (!"true".equals(pkg.getAttribute("Config")))
							break;
						String pname = pkg.getAttribute("Name");
						pspos = pname.lastIndexOf('/');
						String pnm = (pspos != -1) ? pname.substring(pspos + 1) : pname;
						csrc = Paths.get("./packages/" + pname + "/config");
						cdest = tempfolder.resolve("config/" + pnm);
						if (Files.exists(csrc)) {
							Files.createDirectories(cdest);
							OperationResult cres = FileUtil.copyFileTree(csrccdest);
							if (cres.hasErrors()) {
								..println("Error with prepping extra config");
								configpassed = false;
								break;
							}
						}
					}
					if (!configpassed)
						break;
					// also copy installer config if being used
					if (includeinstaller) {
						csrc = Paths.get("./packages/dc/dcInstall/config");
						cdest = tempfolder.resolve("config/dcInstall");
						if (Files.exists(csrc)) {
							Files.createDirectories(cdest);
							OperationResult cres = FileUtil.copyFileTree(csrccdest);
							if (cres.hasErrors()) {
								..println("Error with prepping install config");
								break;
							}
						}
					}
					// write out the deployed file
					RecordStruct deployed = new RecordStruct();
					deployed.setField("Version"relvers);
					deployed.setField("PackageFolder"relpath.resolve(rname));
					deployed.setField("PackagePrefix"rname);
					OperationResult d1res = IOUtil.saveEntireFile(tempfolder.resolve("config/deployed.json"), deployed.toPrettyString()); 
					if (d1res.hasErrors()) {
						..println("Error with prepping deployed");
						break;
					}
					RecordStruct deployment = new RecordStruct();
					deployment.setField("Version"relvers);
					if (prindesc.hasAttribute("LastVersion"))
						deployment.setField("DependsOn"prindesc.getAttribute("LastVersion"));
					deployment.setField("UpdateMessage""This update is complete, you may accept this update as runnable.");
					nolongerdepends.removeAll(dependson);
					ListStruct deletefiles = new ListStruct();
					nolongerdepends.forEach(fname -> deletefiles.addItem("lib/" + fname));
					deployment.setField("DeleteFiles"deletefiles);
					deployment.setField("IgnorePaths"ignorepaths);
					d1res = IOUtil.saveEntireFile(tempfolder.resolve("deployment.json"), deployment.toPrettyString()); 
					if (d1res.hasErrors()) {
						..println("Error with prepping deployment");
						break;
					}
					// write env file
					d1res = IOUtil.saveEntireFile(tempfolder.resolve("env.bat"), 
							"set mem=" + relchoice.getAttribute("Memory""2048") + "\r\n"
"SET project=" + prinpackagenm + "\r\n"
"SET service=" + relchoice.getAttribute("Service"prinpackagenm) + "\r\n"
"SET servicename=" + relchoice.getAttribute("ServiceName"prinpackagenm + " Service") + "\r\n");			
					if (d1res.hasErrors()) {
						..println("Error with prepping env");
						break;
					}
					..println("Packing Release file.");
					Path relbin = relpath.resolve(rname + "/" + rname + "-" + relvers + "-bin.zip");
					if (Files.notExists(relbin.getParent()))
			        try {
						        new SimpleFileVisitor<Path>() {
						            @Override
						            public FileVisitResult visitFile(Path fileBasicFileAttributes attrs)
						                throws IOException
						            {
										ZipArchiveEntry entry = new ZipArchiveEntry(tempfolder.relativize(file).toString());
										entry.setSize(Files.size(file));
										zipout.putArchiveEntry(entry);
										zipout.write(Files.readAllBytes(file));
						                
						                return .;
						            }
						        });
			        catch (IOException x) {
						..println("Error building zip: " + x);
					}
					zipout.close();
					..println("Release file written");
					FileUtil.deleteDirectory(tempfolder);
					break;
				}	// end case 1
				case 3: {
					..println("Note these utilities are only good from the main console,");
					..println("if you are using a remote connection then the encryption will");
					..println("not work as expected.  [we do not have access the master keys]");
					Foreground.utilityMenu(scan);
					break;
				}
				case 4: {
					..println("Packing jar library files.");
					String[] packlist = new String[] {	
							"divconq.core""divconq.interchange""divconq.web",
							"divconq.tasks""divconq.tasks.api""ncc.uploader.api"
							"ncc.uploader.core""ncc.workflow""sd.core" };
					String[] packnames = new String[] {	
							"dcCore""dcInterchange""dcWeb"
							"dcTasks""dcTasksApi""nccUploaderApi"
							"nccUploader""nccWorkflow""sd/sdBackend" };
					for (int i = 0; i < packlist.lengthi++) {
						String lib = packlist[i];
						String pname = packnames[i]; 
						Path relbin = Paths.get("./ext/" + lib + ".jar");
						Path srcbin = Paths.get("./" + lib + "/bin");
						Path packbin = Paths.get("./packages/" + pname + "/lib/" + lib + ".jar");
						if (Files.notExists(relbin.getParent()))
						Files.deleteIfExists(relbin);
				        try {
							        new SimpleFileVisitor<Path>() {
							            @Override
							            public FileVisitResult visitFile(Path fileBasicFileAttributes attrs)
							                throws IOException
							            {
											ZipArchiveEntry entry = new ZipArchiveEntry(srcbin.relativize(file).toString());
											entry.setSize(Files.size(file));
											zipout.putArchiveEntry(entry);
											zipout.write(Files.readAllBytes(file));
							                
							                return .;
							            }
							        });
				        catch (IOException x) {
							..println("Error building zip: " + x);
						}
				        
				        zipout.close();
						Files.copy(relbinpackbin.);
					}
					break;
				}
				case 5: {
					..println("Copying Source Files");
					..println("Cleaning folders");
					OperationResult or = FileUtil.deleteDirectory(gitpath.resolve("divconq.core/src/main/java"));
					if (or.hasErrors()) {
						..println("Error deleting files");
						break;
					}
					or = FileUtil.deleteDirectory(gitpath.resolve("divconq.core/src/main/resources"));
					if (or.hasErrors()) {
						..println("Error deleting files");
						break;
					}
					or = FileUtil.deleteDirectory(gitpath.resolve("divconq.interchange/src/main/java"));
					if (or.hasErrors()) {
						..println("Error deleting files");
						break;
					}
					or = FileUtil.deleteDirectory(gitpath.resolve("divconq.tasks/src/main/java"));
					if (or.hasErrors()) {
						..println("Error deleting files");
						break;
					}
					or = FileUtil.deleteDirectory(gitpath.resolve("divconq.tasks.api/src/main/java"));
					if (or.hasErrors()) {
						..println("Error deleting files");
						break;
					}
					or = FileUtil.deleteDirectory(gitpath.resolve("divconq.web/src/main/java"));
					if (or.hasErrors()) {
						..println("Error deleting files");
						break;
					}
					or = FileUtil.deleteDirectory(gitpath.resolve("packages"));
					if (or.hasErrors()) {
						..println("Error deleting files");
						break;
					}
					or = FileUtil.deleteDirectoryContent(wikigitpath".git");
					if (or.hasErrors()) {
						..println("Error deleting wiki files");
						break;
					}
					..println("Copying folders");
					..println("Copy tree ./divconq.core/src");
					or = FileUtil.copyFileTree(Paths.get("./divconq.core/src/divconq"), gitpath.resolve("divconq.core/src/main/java/divconq"), new Predicate<Path>() {
						public boolean test(Path file) {
							return file.getFileName().toString().endsWith(".java");
						}
					});
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					or = FileUtil.copyFileTree(Paths.get("./divconq.core/src/localize"), gitpath.resolve("divconq.core/src/main/resources/localize"), new Predicate<Path>() {
						public boolean test(Path file) {
							return file.getFileName().toString().endsWith(".xml");
						}
					});
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./divconq.interchange/src");
					or = FileUtil.copyFileTree(Paths.get("./divconq.interchange/src"), gitpath.resolve("divconq.interchange/src/main/java"));					
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./divconq.tasks/src");
					or = FileUtil.copyFileTree(Paths.get("./divconq.tasks/src"), gitpath.resolve("divconq.tasks/src/main/java"));					
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./divconq.tasks.api/src");
					or = FileUtil.copyFileTree(Paths.get("./divconq.tasks.api/src"), gitpath.resolve("divconq.tasks.api/src/main/java"));					
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./divconq.web/src");
					or = FileUtil.copyFileTree(Paths.get("./divconq.web/src"), gitpath.resolve("divconq.web/src/main/java"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcCore");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcCore"), gitpath.resolve("packages/dcCore"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcCorePublic");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcCorePublic"), gitpath.resolve("packages/dcCorePublic"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcInterchange");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcInterchange"), gitpath.resolve("packages/dcInterchange"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcTasks");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcTasks"), gitpath.resolve("packages/dcTasks"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcTasksApi");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcTasksApi"), gitpath.resolve("packages/dcTasksApi"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcTasksWeb");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcTasksWeb"), gitpath.resolve("packages/dcTasksWeb"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcTest");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcTest"), gitpath.resolve("packages/dcTest"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./packages/dcWeb");
					or = FileUtil.copyFileTree(Paths.get("./packages/dcWeb"), gitpath.resolve("packages/dcWeb"));
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copy tree ./divconq.wiki/public");
					or = FileUtil.copyFileTree(Paths.get("./divconq.wiki/public"), wikigitpath);
					if (or.hasErrors()) {
						..println("Error copying files");
						break;
					}
					..println("Copying files");
					Files.copy(Paths.get("./README.md"), gitpath.resolve("README.md"), ..);
					Files.copy(Paths.get("./RELEASE_NOTES.md"), gitpath.resolve("RELEASE_NOTES.md"), ..);
					Files.copy(Paths.get("./NOTICE.txt"), gitpath.resolve("NOTICE.txt"), ..);
					Files.copy(Paths.get("./LICENSE.txt"), gitpath.resolve("LICENSE.txt"), ..);
					break;
				}
				}
			}
			catch(Exception x) {
				..println("CLI error: " + x);
			}
		}		
	}
	protected void collectPackageDependencies(Set<StringinstpkgsMap<StringXElementavailpackagesSet<StringreloptsString pnameAtomicBoolean errored) {
		if (!availpackages.containsKey(pname)) {
			errored.set(true);
			..println("Required Package not found: " + pname);
			return;
		}
		// filter DependsOn by Option
		for (XElement doel : availpackages.get(pname).selectAll("DependsOn")) {
			if (doel.hasAttribute("Option") && !relopts.contains(doel.getAttribute("Option")))
				continue;
			 // copy all libraries we rely on
			for (XElement pkg : doel.selectAll("Package")) {
				String doname = pkg.getAttribute("Name");
				instpkgs.add(doname);
				this.collectPackageDependencies(instpkgsavailpackagesreloptsdonameerrored);
			}
		}
		return;
	}
New to GrepCode? Check out our FAQ X