org.spearce.jgit/src/org/spearce/jgit/transport/TransportLocal.java

   1 /*
   2  * Copyright (C) 2007, Dave Watson <dwatson@mimvista.com>
   3  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
   4  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
   5  * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
   6  *
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or
  10  * without modification, are permitted provided that the following
  11  * conditions are met:
  12  *
  13  * - Redistributions of source code must retain the above copyright
  14  *   notice, this list of conditions and the following disclaimer.
  15  *
  16  * - Redistributions in binary form must reproduce the above
  17  *   copyright notice, this list of conditions and the following
  18  *   disclaimer in the documentation and/or other materials provided
  19  *   with the distribution.
  20  *
  21  * - Neither the name of the Git Development Community nor the
  22  *   names of its contributors may be used to endorse or promote
  23  *   products derived from this software without specific prior
  24  *   written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  27  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  28  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  29  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  31  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  32  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  33  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  34  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  35  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  36  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  38  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  39  */
  40
  41 package org.spearce.jgit.transport;
  42
  43 import java.io.File;
  44 import java.io.IOException;
  45 import java.io.InputStream;
  46 import java.io.PipedInputStream;
  47 import java.io.PipedOutputStream;
  48
  49 import org.spearce.jgit.errors.NotSupportedException;
  50 import org.spearce.jgit.errors.TransportException;
  51 import org.spearce.jgit.lib.Repository;
  52 import org.spearce.jgit.util.FS;
  53
  54 /**
  55  * Transport to access a local directory as though it were a remote peer.
  56  * <p>
  57  * This transport is suitable for use on the local system, where the caller has
  58  * direct read or write access to the "remote" repository.
  59  * <p>
  60  * By default this transport works by spawning a helper thread within the same
  61  * JVM, and processes the data transfer using a shared memory buffer between the
  62  * calling thread and the helper thread. This is a pure-Java implementation
  63  * which does not require forking an external process.
  64  * <p>
  65  * However, during {@link #openFetch()}, if the Transport has configured
  66  * {@link Transport#getOptionUploadPack()} to be anything other than
  67  * <code>"git-upload-pack"</code> or <code>"git upload-pack"</code>, this
  68  * implementation will fork and execute the external process, using an operating
  69  * system pipe to transfer data.
  70  * <p>
  71  * Similarly, during {@link #openPush()}, if the Transport has configured
  72  * {@link Transport#getOptionReceivePack()} to be anything other than
  73  * <code>"git-receive-pack"</code> or <code>"git receive-pack"</code>, this
  74  * implementation will fork and execute the external process, using an operating
  75  * system pipe to transfer data.
  76  */
  77 class TransportLocal extends Transport implements PackTransport {
  78         private static final String PWD = ".";
  79
  80         static boolean canHandle(final URIish uri) {
  81                 if (uri.getHost() != null || uri.getPort() > 0 || uri.getUser() != null
  82                                 || uri.getPass() != null || uri.getPath() == null)
  83                         return false;
  84
  85                 if ("file".equals(uri.getScheme()) || uri.getScheme() == null)
  86                         return FS.resolve(new File(PWD), uri.getPath()).isDirectory();
  87                 return false;
  88         }
  89
  90         private final File remoteGitDir;
  91
  92         TransportLocal(final Repository local, final URIish uri) {
  93                 super(local, uri);
  94
  95                 File d = FS.resolve(new File(PWD), uri.getPath()).getAbsoluteFile();
  96                 if (new File(d, ".git").isDirectory())
  97                         d = new File(d, ".git");
  98                 remoteGitDir = d;
  99         }
 100
 101         @Override
 102         public FetchConnection openFetch() throws TransportException {
 103                 final String up = getOptionUploadPack();
 104                 if ("git-upload-pack".equals(up) || "git upload-pack".equals(up))
 105                         return new InternalLocalFetchConnection();
 106                 return new ForkLocalFetchConnection();
 107         }
 108
 109         @Override
 110         public PushConnection openPush() throws NotSupportedException,
 111                         TransportException {
 112                 final String rp = getOptionReceivePack();
 113                 if ("git-receive-pack".equals(rp) || "git receive-pack".equals(rp))
 114                         return new InternalLocalPushConnection();
 115                 return new ForkLocalPushConnection();
 116         }
 117
 118         @Override
 119         public void close() {
 120                 // Resources must be established per-connection.
 121         }
 122
 123         protected Process startProcessWithErrStream(final String cmd)
 124                         throws TransportException {
 125                 try {
 126                         final String[] args;
 127                         final Process proc;
 128
 129                         if (cmd.startsWith("git-")) {
 130                                 args = new String[] { "git", cmd.substring(4), PWD };
 131                         } else {
 132                                 final int gitspace = cmd.indexOf("git ");
 133                                 if (gitspace >= 0) {
 134                                         final String git = cmd.substring(0, gitspace + 3);
 135                                         final String subcmd = cmd.substring(gitspace + 4);
 136                                         args = new String[] { git, subcmd, PWD };
 137                                 } else {
 138                                         args = new String[] { cmd, PWD };
 139                                 }
 140                         }
 141
 142                         proc = Runtime.getRuntime().exec(args, null, remoteGitDir);
 143                         new StreamRewritingThread(cmd, proc.getErrorStream()).start();
 144                         return proc;
 145                 } catch (IOException err) {
 146                         throw new TransportException(uri, err.getMessage(), err);
 147                 }
 148         }
 149
 150         class InternalLocalFetchConnection extends BasePackFetchConnection {
 151                 private Thread worker;
 152
 153                 InternalLocalFetchConnection() throws TransportException {
 154                         super(TransportLocal.this);
 155
 156                         final Repository dst;
 157                         try {
 158                                 dst = new Repository(remoteGitDir);
 159                         } catch (IOException err) {
 160                                 throw new TransportException(uri, "not a git directory");
 161                         }
 162
 163                         final PipedInputStream in_r;
 164                         final PipedOutputStream in_w;
 165
 166                         final PipedInputStream out_r;
 167                         final PipedOutputStream out_w;
 168                         try {
 169                                 in_r = new PipedInputStream();
 170                                 in_w = new PipedOutputStream(in_r);
 171
 172                                 out_r = new PipedInputStream() {
 173                                         // The client (BasePackFetchConnection) can write
 174                                         // a huge burst before it reads again. We need to
 175                                         // force the buffer to be big enough, otherwise it
 176                                         // will deadlock both threads.
 177                                         {
 178                                                 buffer = new byte[MAX_CLIENT_BUFFER];
 179                                         }
 180                                 };
 181                                 out_w = new PipedOutputStream(out_r);
 182                         } catch (IOException err) {
 183                                 dst.close();
 184                                 throw new TransportException(uri, "cannot connect pipes", err);
 185                         }
 186
 187                         worker = new Thread("JGit-Upload-Pack") {
 188                                 public void run() {
 189                                         try {
 190                                                 final UploadPack rp = new UploadPack(dst);
 191                                                 rp.upload(out_r, in_w, null);
 192                                         } catch (IOException err) {
 193                                                 // Client side of the pipes should report the problem.
 194                                                 err.printStackTrace();
 195                                         } catch (RuntimeException err) {
 196                                                 // Clients side will notice we went away, and report.
 197                                                 err.printStackTrace();
 198                                         } finally {
 199                                                 try {
 200                                                         out_r.close();
 201                                                 } catch (IOException e2) {
 202                                                         // Ignore close failure, we probably crashed above.
 203                                                 }
 204
 205                                                 try {
 206                                                         in_w.close();
 207                                                 } catch (IOException e2) {
 208                                                         // Ignore close failure, we probably crashed above.
 209                                                 }
 210
 211                                                 dst.close();
 212                                         }
 213                                 }
 214                         };
 215                         worker.start();
 216
 217                         init(in_r, out_w);
 218                         readAdvertisedRefs();
 219                 }
 220
 221                 @Override
 222                 public void close() {
 223                         super.close();
 224
 225                         if (worker != null) {
 226                                 try {
 227                                         worker.join();
 228                                 } catch (InterruptedException ie) {
 229                                         // Stop waiting and return anyway.
 230                                 } finally {
 231                                         worker = null;
 232                                 }
 233                         }
 234                 }
 235         }
 236
 237         class ForkLocalFetchConnection extends BasePackFetchConnection {
 238                 private Process uploadPack;
 239
 240                 ForkLocalFetchConnection() throws TransportException {
 241                         super(TransportLocal.this);
 242                         uploadPack = startProcessWithErrStream(getOptionUploadPack());
 243                         init(uploadPack.getInputStream(), uploadPack.getOutputStream());
 244                         readAdvertisedRefs();
 245                 }
 246
 247                 @Override
 248                 public void close() {
 249                         super.close();
 250
 251                         if (uploadPack != null) {
 252                                 try {
 253                                         uploadPack.waitFor();
 254                                 } catch (InterruptedException ie) {
 255                                         // Stop waiting and return anyway.
 256                                 } finally {
 257                                         uploadPack = null;
 258                                 }
 259                         }
 260                 }
 261         }
 262
 263         class InternalLocalPushConnection extends BasePackPushConnection {
 264                 private Thread worker;
 265
 266                 InternalLocalPushConnection() throws TransportException {
 267                         super(TransportLocal.this);
 268
 269                         final Repository dst;
 270                         try {
 271                                 dst = new Repository(remoteGitDir);
 272                         } catch (IOException err) {
 273                                 throw new TransportException(uri, "not a git directory");
 274                         }
 275
 276                         final PipedInputStream in_r;
 277                         final PipedOutputStream in_w;
 278
 279                         final PipedInputStream out_r;
 280                         final PipedOutputStream out_w;
 281                         try {
 282                                 in_r = new PipedInputStream();
 283                                 in_w = new PipedOutputStream(in_r);
 284
 285                                 out_r = new PipedInputStream();
 286                                 out_w = new PipedOutputStream(out_r);
 287                         } catch (IOException err) {
 288                                 dst.close();
 289                                 throw new TransportException(uri, "cannot connect pipes", err);
 290                         }
 291
 292                         worker = new Thread("JGit-Receive-Pack") {
 293                                 public void run() {
 294                                         try {
 295                                                 final ReceivePack rp = new ReceivePack(dst);
 296                                                 rp.receive(out_r, in_w, System.err);
 297                                         } catch (IOException err) {
 298                                                 // Client side of the pipes should report the problem.
 299                                         } catch (RuntimeException err) {
 300                                                 // Clients side will notice we went away, and report.
 301                                         } finally {
 302                                                 try {
 303                                                         out_r.close();
 304                                                 } catch (IOException e2) {
 305                                                         // Ignore close failure, we probably crashed above.
 306                                                 }
 307
 308                                                 try {
 309                                                         in_w.close();
 310                                                 } catch (IOException e2) {
 311                                                         // Ignore close failure, we probably crashed above.
 312                                                 }
 313
 314                                                 dst.close();
 315                                         }
 316                                 }
 317                         };
 318                         worker.start();
 319
 320                         init(in_r, out_w);
 321                         readAdvertisedRefs();
 322                 }
 323
 324                 @Override
 325                 public void close() {
 326                         super.close();
 327
 328                         if (worker != null) {
 329                                 try {
 330                                         worker.join();
 331                                 } catch (InterruptedException ie) {
 332                                         // Stop waiting and return anyway.
 333                                 } finally {
 334                                         worker = null;
 335                                 }
 336                         }
 337                 }
 338         }
 339
 340         class ForkLocalPushConnection extends BasePackPushConnection {
 341                 private Process receivePack;
 342
 343                 ForkLocalPushConnection() throws TransportException {
 344                         super(TransportLocal.this);
 345                         receivePack = startProcessWithErrStream(getOptionReceivePack());
 346                         init(receivePack.getInputStream(), receivePack.getOutputStream());
 347                         readAdvertisedRefs();
 348                 }
 349
 350                 @Override
 351                 public void close() {
 352                         super.close();
 353
 354                         if (receivePack != null) {
 355                                 try {
 356                                         receivePack.waitFor();
 357                                 } catch (InterruptedException ie) {
 358                                         // Stop waiting and return anyway.
 359                                 } finally {
 360                                         receivePack = null;
 361                                 }
 362                         }
 363                 }
 364         }
 365
 366         static class StreamRewritingThread extends Thread {
 367                 private final InputStream in;
 368
 369                 StreamRewritingThread(final String cmd, final InputStream in) {
 370                         super("JGit " + cmd + " Errors");
 371                         this.in = in;
 372                 }
 373
 374                 public void run() {
 375                         final byte[] tmp = new byte[512];
 376                         try {
 377                                 for (;;) {
 378                                         final int n = in.read(tmp);
 379                                         if (n < 0)
 380                                                 break;
 381                                         System.err.write(tmp, 0, n);
 382                                         System.err.flush();
 383                                 }
 384                         } catch (IOException err) {
 385                                 // Ignore errors reading errors.
 386                         } finally {
 387                                 try {
 388                                         in.close();
 389                                 } catch (IOException err2) {
 390                                         // Ignore errors closing the pipe.
 391                                 }
 392                         }
 393                 }
 394         }
 395 }