/FileExtraction/Java_unseen/dlitz_resin/modules/resin/src/com/caucho/env/git/GitSystem.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.env.git;

import java.io.*;
import java.security.*;
import java.util.*;
import java.util.logging.*;
import java.util.zip.*;

import com.caucho.env.service.*;
import com.caucho.util.*;
import com.caucho.vfs.*;

/**
 * Top-level class for a repository
 */
public class GitSystem extends AbstractResinSubSystem 
{
  public static final int START_PRIORITY
  = RootDirectorySystem.START_PRIORITY_ROOT_DIRECTORY + 1; 

  private static final L10N L = new L10N(GitSystem.class);
  private static final Logger log = 
    Logger.getLogger(GitSystem.class.getName());
  
  private Path _root;
  
  public GitSystem(Path root)
  {
    _root = root;
  }
  
  public static GitSystem createAndAddService()
  {
    return createAndAddService(null);
  }

  public static GitSystem createAndAddService(Path root)
  {
    ResinSystem system = preCreate(GitSystem.class);
    
    GitSystem service = new GitSystem(root);
    system.addService(GitSystem.class, service);
    
    return service;
  }

  public static GitSystem getCurrent()
  {
    return ResinSystem.getCurrentService(GitSystem.class);
  }

  @Override
  public int getStartPriority()
  {
    return START_PRIORITY;
  }

  @Override
  public void start()
    throws IOException
  {
    if (_root == null)
      _root = RootDirectorySystem.getCurrentDataDirectory().lookup(".git");

    if (_root.lookup("HEAD").canRead())
      return;

    _root.mkdirs();

    _root.lookup("refs").mkdir();
    _root.lookup("refs/heads").mkdir();
    
    _root.lookup("objects").mkdir();
    _root.lookup("objects/info").mkdir();
    _root.lookup("objects/pack").mkdir();
    
    _root.lookup("branches").mkdir();
    
    _root.lookup("tmp").mkdir();

    WriteStream out = _root.lookup("HEAD").openWrite();
    try {
      out.println("ref: refs/heads/master");
    } finally {
      out.close();
    }
  }

  public String getMaster()
  {
    return getTag("heads/master");
  }

  /**
   * Returns the object type of the specified file.
   *
   * @param sha1 the sha1 hash identifier of the file
   *
   * @return "blob", "commit" or "tree"
   */
  public GitType objectType(String sha1)
    throws IOException
  {
    GitObjectStream is = open(sha1);

    try {
      return is.getType();
    } finally {
      is.close();
    }
  }
  
  public String getTag(String tag)
  {
    Path path = getRefPath(tag);

    synchronized (this) {
      if (! path.canRead())
        return null;

      ReadStream is = null;
      try {
        is = path.openRead();

        String hex = is.readLine();

        if (hex != null)
          return hex.trim();
        else
          return null;
      } catch (IOException e) {
        log.log(Level.FINE, e.toString(), e);

        return null;
      } finally {
        if (is != null)
          is.close();
      }
    }
  }

  public void writeTag(String tag, String hex)
  {
    Path path = getRefPath(tag);

    try {
      path.getParent().mkdirs();
    } catch (IOException e) {
      log.log(Level.FINEST, e.toString(), e);
    }

    synchronized (this) {
      WriteStream out = null;
      try {
        out = path.openWrite();

        out.println(hex);
      } catch (IOException e) {
        log.log(Level.FINE, e.toString(), e);
      } finally {
        try {
          if (out != null)
            out.close();
        } catch (Exception e) {
          log.log(Level.FINEST, e.toString(), e);
        }
      }
    }
  }

  public String []listRefs(String dir)
  {
    try {
      Path path = getRefPath(dir);

      if (path.isDirectory())
        return path.list();
      else
        return new String[0];
    } catch (IOException e) {
      log.log(Level.FINE, e.toString(), e);

      return new String[0];
    }
  }

  private Path getRefPath(String path)
  {
    return _root.lookup("refs").lookup(path);
  }

  /**
   * Parses and returns the commit file specified by the sha1 hash.
   *
   * @param sha1 the sha1 hash identifier of the commit file
   *
   * @return the parsed GitCommit structure
   */
  public GitCommit parseCommit(String sha1)
    throws IOException
  {
    GitObjectStream is = open(sha1);
    try {
      if (is.getType() != GitType.COMMIT)
        throw new IOException(L.l("'{0}' is an unexpected type, expected 'commit'",
                                  is.getType()));
      
      return is.parseCommit();
    } finally {
      is.close();
    }
  }

  /**
   * Parses and returns the tree (directory) specified by the sha1 hash.
   *
   * @param sha1 the sha1 hash identifier of the tree file
   *
   * @return the parsed GitTree structure
   */
  public GitTree parseTree(String sha1)
    throws IOException
  {
    GitObjectStream is = open(sha1);
    
    try {
      if (GitType.TREE != is.getType())
        throw new IOException(L.l("'{0}' is an unexpected type, expected 'tree'",
                                  is.getType()));
      
      return is.parseTree();
    } finally {
      is.close();
    }
  }

  /**
   * Returns an input stream to a blob
   */
  public InputStream openBlob(String sha1)
    throws IOException
  {
    GitObjectStream is = open(sha1);
    
    if (is.getType() != GitType.BLOB) {
      is.close();
      throw new IOException(L.l("'{0}' is an unexpected type, expected 'blob'",
                                is.getType()));
    }
      
    return is;
  }

  public void expandToPath(Path path, String sha1)
    throws IOException
  {
    long now = Alarm.getCurrentTime();
    
    expandToPath(path, sha1, now);
  }
  
  public void expandToPath(Path path, String sha1, long now)
    throws IOException
  {
    GitObjectStream is = open(sha1);

    try {
      if (GitType.TREE == is.getType()) {
        GitTree tree = is.parseTree();
        is.close();

        expandTreeToPath(path, tree, now);
      }
      else if (GitType.BLOB == is.getType()) {
        WriteStream os = path.openWrite();

        try {
          os.writeStream(is.getInputStream());
        } finally {
          os.close();
        }

        // #3839
        path.setLastModified(now);
      }
      else
        throw new IOException(L.l("'{0}' is an unexpected type, expected 'blob' or 'tree'",
                                  is.getType()));
    } finally {
      is.close();
    }
  }

  private void expandTreeToPath(Path path, GitTree tree, long now)
    throws IOException
  {
    path.mkdirs();
    
    for (GitTree.Entry entry : tree.entries()) {
      String name = entry.getName();

      expandToPath(path.lookup(name), entry.getSha1(), now);
    }
  }

  public void copyToFile(Path path, String sha1)
    throws IOException
  {
    GitObjectStream is = open(sha1);
    
    try {
      if (GitType.BLOB != is.getType())
        throw new IOException(L.l("'{0}' is an unexpected type, expected 'blob'",
                                  is.getType()));

      WriteStream os = path.openWrite();

      try {
        os.writeStream(is.getInputStream());
      } finally {
        os.close();
      }
    } finally {
      is.close();
    }
  }

  public boolean contains(String hash)
  {
    String prefix = hash.substring(0, 2);
    String suffix = hash.substring(2);

    Path path = _root.lookup("objects").lookup(prefix).lookup(suffix);

    return path.exists();
  }

  /**
   * Opens an object file specified by a sha1 hash.
   *
   * @param sha1 the sha1 hash identifier for the file
   *
   * @return an opened GitObjectStream to the file
   */
  public GitObjectStream open(String sha1)
    throws IOException
  {
    String prefix = sha1.substring(0, 2);
    String suffix = sha1.substring(2);

    Path path = _root.lookup("objects").lookup(prefix).lookup(suffix);

    return new GitObjectStream(path);
  }

  /**
   * Writes a file to the repository
   */
  public String writeFile(Path path)
    throws IOException
  {
    InputStream is = path.openRead();
    
    try {
      TempOutputStream os = new TempOutputStream();
      String type = "blob";

      String hex = writeData(os, type, is, path.getLength());

      return writeFile(os, hex);
    } finally {
      is.close();
    }
  }

  /**
   * Writes a file to the repository
   */
  public String writeInputStream(InputStream is)
    throws IOException
  {
    TempStream tempOs = new TempStream();

    WriteStream out = new WriteStream(tempOs);

    out.writeStream(is);

    out.close();

    int length = tempOs.getLength();

    String type = "blob";

    TempOutputStream os = new TempOutputStream();

    String sha1 = writeData(os, type, tempOs.getInputStream(), length);

    return writeFile(os, sha1);
  }

  /**
   * Writes a file to the repository
   */
  public String writeInputStream(InputStream is, long length)
    throws IOException
  {
    String type = "blob";

    TempOutputStream os = new TempOutputStream();

    String sha1 = writeData(os, type, is, length);

    return writeFile(os, sha1);
  }

  /**
   * Writes a file to the repository
   */
  public String writeTree(GitTree tree)
    throws IOException
  {
    TempOutputStream treeOut = new TempOutputStream();

    tree.toData(treeOut);
    
    int treeLength = treeOut.getLength();
    
    InputStream is = treeOut.openRead();
    
    try {
      TempOutputStream os = new TempOutputStream();
      String type = "tree";

      String hex = writeData(os, type, is, treeLength);

      return writeFile(os, hex);
    } finally {
      is.close();
    }
  }

  /**
   * Writes a file to the repository
   */
  public String writeCommit(GitCommit commit)
    throws IOException
  {
    TempStream commitOut = new TempStream();
    WriteStream out = new WriteStream(commitOut);

    out.print("tree ");
    out.println(commit.getTree());

    String parent = commit.getParent();

    if (parent != null) {
      out.print("parent ");
      out.println(parent);
    }

    Map<String,String> attr = commit.getMetaData();
    if (attr != null) {
      ArrayList<String> keys = new ArrayList<String>(attr.keySet());
      Collections.sort(keys);

      for (String key : keys) {
        out.print(key);
        out.print(' ');
        out.print(attr.get(key));
        out.println();
      }
    }

    out.println();

    if (commit.getMessage() != null)
      out.println(commit.getMessage());
    
    out.close();
    
    int commitLength = commitOut.getLength();
    
    InputStream is = commitOut.openRead();
    
    try {
      TempOutputStream os = new TempOutputStream();
      String type = "commit";

      String hex = writeData(os, type, is, commitLength);

      return writeFile(os, hex);
    } finally {
      is.close();
    }
  }

  public String writeFile(TempOutputStream os, String hex)
    throws IOException
  {
    Path objectPath = lookupPath(hex);

    if (objectPath.exists())
      return hex;

    objectPath.getParent().mkdirs();
    
    Path tmpDir = _root.lookup("tmp");
    tmpDir.mkdirs();

    Path tmp = _root.lookup("tmp").lookup("tmp." + hex);

    WriteStream tmpOs = tmp.openWrite();
    try {
      tmpOs.writeStream(os.openRead());
    } finally {
      tmpOs.close();
    }

    tmp.renameTo(objectPath);
      
    return hex;
  }

  /**
   * Opens a stream to the raw git file.
   */
  public InputStream openRawGitFile(String sha1)
    throws IOException
  {
    Path objectPath = lookupPath(sha1);

    return objectPath.openRead();
  }

  /**
   * Writes a raw git file directly to the repository with an expected
   * sha1.  The write will verify that the stream matches the expected
   * content.
   */
  public String writeRawGitFile(String sha1, InputStream is)
    throws IOException
  {
    Path objectPath = lookupPath(sha1);

    if (objectPath.exists())
      return sha1;

    objectPath.getParent().mkdirs();
    
    Path tmpDir = _root.lookup("tmp");
    tmpDir.mkdirs();

    Path tmp = _root.lookup("tmp").lookup("tmp." + sha1);

    try {
      WriteStream tmpOut = tmp.openWrite();
      
      try {
        tmpOut.writeStream(is);
      } finally {
        tmpOut.close();
      }

      String newHex = validate(tmp);

      if (! sha1.equals(newHex))
        throw new RuntimeException(L.l("{0}: file validation failed because sha-1 hash '{0}' does not match expected '{1}'",
                                       newHex, sha1));

      tmp.renameTo(objectPath);
      
      if (log.isLoggable(Level.FINER))
        log.finer(this + " addRawGitFile " + sha1 + " " + objectPath);
    } catch (RuntimeException e) {
      throw e;
    } catch (Exception e) {
      throw new RuntimeException(e);
    } finally {
      tmp.remove();
    }
      
    return sha1;
  }

  /**
   * Validate and remove.
   */
  public void validateRawGitFile(String sha1)
  {
    Path objectPath = lookupPath(sha1);

    if (! objectPath.exists())
      return;
    
    boolean isValid = false;

    try {
      String newHex = validate(objectPath);

      if (sha1.equals(newHex))
        isValid = true;
      else {
        log.warning(L.l("{0}: file validation failed because sha-1 hash '{0}' does not match expected '{1}'",
                        newHex, sha1));
      }
    } catch (Exception e) {
      log.warning("git service " + sha1 + " " + e.toString());
    } finally {
      if (! isValid) {
        try {
          objectPath.remove();
        } catch (Exception e) {
          log.log(Level.FINER, e.toString(), e);
        }
      }
    }
  }
  
  private Path lookupPath(String sha1)
  {
    String prefix = sha1.substring(0, 2);
    String suffix = sha1.substring(2);
    
    return _root.lookup("objects").lookup(prefix).lookup(suffix);
  }
  
  public static GitType validate(String hash, InputStream is)
    throws IOException, NoSuchAlgorithmException
  {
    MessageDigest md = MessageDigest.getInstance("SHA-1");

    InflaterInputStream zin = new InflaterInputStream(is);
    DigestInputStream din = new DigestInputStream(zin, md);

    TempBuffer tBuf = TempBuffer.allocate();
    byte []buffer = tBuf.getBuffer();
    
    GitType gitType = null;
    int len;

    while ((len = din.read(buffer, 0, buffer.length)) >= 0) {
      if (gitType == null) {
        String value = new String(buffer, 0, len);
        
        if (value.startsWith("blob"))
          gitType = GitType.BLOB;
        else if (value.startsWith("tree"))
          gitType = GitType.TREE;
        else if (value.startsWith("commit"))
          gitType = GitType.COMMIT;
      }
      
    }

    TempBuffer.free(tBuf);

    din.close();

    byte []digest = md.digest();
    
    String digestHash = Hex.toHex(digest);
    
    if (! hash.equals(digestHash))
      throw new IOException(L.l("Git file corrupted.\n  expected: {0}\n actual: {1}",
                                hash, digestHash));

    
    return gitType;
  }

  private String validate(Path path)
    throws IOException, NoSuchAlgorithmException
  {
    ReadStream is = path.openRead();

    try {
      MessageDigest md = MessageDigest.getInstance("SHA-1");
      
      InflaterInputStream zin = new InflaterInputStream(is);
      DigestInputStream din = new DigestInputStream(zin, md);

      TempBuffer tBuf = TempBuffer.allocate();
      byte []buffer = tBuf.getBuffer();
      
      while (din.read(buffer, 0, buffer.length) >= 0) {
      }
      
      TempBuffer.free(tBuf);

      din.close();

      byte []digest = md.digest();

      return Hex.toHex(digest);
    } finally {
      is.close();
    }
  }

  public static String writeData(OutputStream os, String type,
                                 InputStream is, long length)
    throws IOException
  {
    TempBuffer buf = TempBuffer.allocate();

    try {
      // DeflaterOutputStream out = new DeflaterOutputStream(os);
      ResinDeflaterOutputStream out = new ResinDeflaterOutputStream(os);

      MessageDigest md = MessageDigest.getInstance("SHA-1");

      for (int i = 0; i < type.length(); i++) {
        int ch = type.charAt(i);
        out.write(ch);
        md.update((byte) ch);
      }

      out.write(' ');
      md.update((byte) ' ');
      
      String lengthString = String.valueOf(length);

      for (int i = 0; i < lengthString.length(); i++) {
        int ch = lengthString.charAt(i);
        out.write(ch);
        md.update((byte) ch);
      }
      
      out.write(0);
      md.update((byte) 0);

      long readLength = 0;
      
      int len;

      byte []buffer = buf.getBuffer();
      while ((len = is.read(buffer, 0, buffer.length)) > 0) {
        out.write(buffer, 0, len);
        md.update(buffer, 0, len);

        readLength += len;
      }

      out.close();

      if (readLength != length)
        throw new IOException(L.l("written length does not match data"));

      return Hex.toHex(md.digest());
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException(e);
    } finally {
      TempBuffer.free(buf);
    }
  }

  @Override
  public String toString()
  {
    return getClass().getSimpleName() + "[" + _root + "]";
  }
}
