Java tutorial
// Copyright (C) 2009 The Android Open Source Project // // Licensed 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 com.google.gerrit.pgm.init; import com.google.gerrit.pgm.util.Die; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.storage.file.FileBasedConfig; import org.eclipse.jgit.storage.file.LockFile; import org.eclipse.jgit.util.FS; import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.SystemReader; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.net.URI; import java.net.URISyntaxException; import java.net.UnknownHostException; import java.nio.ByteBuffer; import java.util.Arrays; /** Utility functions to help initialize a site. */ class InitUtil { static Die die(String why) { return new Die(why); } static Die die(String why, Throwable cause) { return new Die(why, cause); } static void savePublic(final FileBasedConfig sec) throws IOException { if (modified(sec)) { sec.save(); } } static void saveSecure(final FileBasedConfig sec) throws IOException { if (modified(sec)) { final byte[] out = Constants.encode(sec.toText()); final File path = sec.getFile(); final LockFile lf = new LockFile(path, FS.DETECTED); if (!lf.lock()) { throw new IOException("Cannot lock " + path); } try { chmod(0600, new File(path.getParentFile(), path.getName() + ".lock")); lf.write(out); if (!lf.commit()) { throw new IOException("Cannot commit write to " + path); } } finally { lf.unlock(); } } } private static boolean modified(FileBasedConfig cfg) throws IOException { byte[] curVers; try { curVers = IO.readFully(cfg.getFile()); } catch (FileNotFoundException notFound) { return true; } byte[] newVers = Constants.encode(cfg.toText()); return !Arrays.equals(curVers, newVers); } static void mkdir(final File path) { if (!path.isDirectory() && !path.mkdir()) { throw die("Cannot make directory " + path); } } static void chmod(final int mode, final File path) { path.setReadable(false, false /* all */); path.setWritable(false, false /* all */); path.setExecutable(false, false /* all */); path.setReadable((mode & 0400) == 0400, true /* owner only */); path.setWritable((mode & 0200) == 0200, true /* owner only */); if (path.isDirectory() || (mode & 0100) == 0100) { path.setExecutable(true, true /* owner only */); } if ((mode & 0044) == 0044) { path.setReadable(true, false /* all */); } if ((mode & 0011) == 0011) { path.setExecutable(true, false /* all */); } } static String version() { return com.google.gerrit.common.Version.getVersion(); } static String username() { return System.getProperty("user.name"); } static String hostname() { return SystemReader.getInstance().getHostname(); } static boolean isLocal(final String hostname) { try { return InetAddress.getByName(hostname).isLoopbackAddress(); } catch (UnknownHostException e) { return false; } } static String dnOf(String name) { if (name != null) { int p = name.indexOf("://"); if (0 < p) { name = name.substring(p + 3); } p = name.indexOf("."); if (0 < p) { name = name.substring(p + 1); name = "DC=" + name.replaceAll("\\.", ",DC="); } else { name = null; } } return name; } static String domainOf(String name) { if (name != null) { int p = name.indexOf("://"); if (0 < p) { name = name.substring(p + 3); } p = name.indexOf("."); if (0 < p) { name = name.substring(p + 1); } } return name; } static void extract(final File dst, final Class<?> sibling, final String name) throws IOException { final InputStream in = open(sibling, name); if (in != null) { ByteBuffer buf = IO.readWholeStream(in, 8192); copy(dst, buf); } } private static InputStream open(final Class<?> sibling, final String name) { final InputStream in = sibling.getResourceAsStream(name); if (in == null) { String pkg = sibling.getName(); int end = pkg.lastIndexOf('.'); if (0 < end) { pkg = pkg.substring(0, end + 1); pkg = pkg.replace('.', '/'); } else { pkg = ""; } System.err.println("warn: Cannot read " + pkg + name); return null; } return in; } static void copy(final File dst, final ByteBuffer buf) throws FileNotFoundException, IOException { // If the file already has the content we want to put there, // don't attempt to overwrite the file. // try { if (buf.equals(ByteBuffer.wrap(IO.readFully(dst)))) { return; } } catch (FileNotFoundException notFound) { // Fall through and write the file. } dst.getParentFile().mkdirs(); LockFile lf = new LockFile(dst, FS.DETECTED); if (!lf.lock()) { throw new IOException("Cannot lock " + dst); } try { final OutputStream out = lf.getOutputStream(); try { final byte[] tmp = new byte[4096]; while (0 < buf.remaining()) { int n = Math.min(buf.remaining(), tmp.length); buf.get(tmp, 0, n); out.write(tmp, 0, n); } } finally { out.close(); } if (!lf.commit()) { throw new IOException("Cannot commit " + dst); } } finally { lf.unlock(); } } static URI toURI(String url) throws URISyntaxException { final URI u = new URI(url); if (isAnyAddress(u)) { // If the URL uses * it means all addresses on this system, use the // current hostname instead in the returned URI. // final int s = url.indexOf('*'); url = url.substring(0, s) + hostname() + url.substring(s + 1); } return new URI(url); } static boolean isAnyAddress(final URI u) { return u.getHost() == null && (u.getAuthority().equals("*") || u.getAuthority().startsWith("*:")); } static int portOf(final URI uri) { int port = uri.getPort(); if (port < 0) { port = "https".equals(uri.getScheme()) ? 443 : 80; } return port; } private InitUtil() { } }