| // 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() { |
| } |
| } |