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

   1 /*
   2  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
   3  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
   4  * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
   5  *
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or
   9  * without modification, are permitted provided that the following
  10  * conditions are met:
  11  *
  12  * - Redistributions of source code must retain the above copyright
  13  *   notice, this list of conditions and the following disclaimer.
  14  *
  15  * - Redistributions in binary form must reproduce the above
  16  *   copyright notice, this list of conditions and the following
  17  *   disclaimer in the documentation and/or other materials provided
  18  *   with the distribution.
  19  *
  20  * - Neither the name of the Git Development Community nor the
  21  *   names of its contributors may be used to endorse or promote
  22  *   products derived from this software without specific prior
  23  *   written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  26  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  27  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  30  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  31  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  32  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  33  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  34  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  35  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  37  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 package org.spearce.jgit.transport;
  41
  42 import java.io.BufferedInputStream;
  43 import java.io.BufferedOutputStream;
  44 import java.io.EOFException;
  45 import java.io.IOException;
  46 import java.io.InputStream;
  47 import java.io.OutputStream;
  48 import java.util.HashSet;
  49 import java.util.LinkedHashMap;
  50 import java.util.Set;
  51
  52 import org.spearce.jgit.errors.NoRemoteRepositoryException;
  53 import org.spearce.jgit.errors.PackProtocolException;
  54 import org.spearce.jgit.errors.TransportException;
  55 import org.spearce.jgit.lib.ObjectId;
  56 import org.spearce.jgit.lib.Ref;
  57 import org.spearce.jgit.lib.Repository;
  58
  59 /**
  60  * Base helper class for pack-based operations implementations. Provides partial
  61  * implementation of pack-protocol - refs advertising and capabilities support,
  62  * and some other helper methods.
  63  *
  64  * @see BasePackFetchConnection
  65  * @see BasePackPushConnection
  66  */
  67 abstract class BasePackConnection extends BaseConnection {
  68
  69         /** The repository this transport fetches into, or pushes out of. */
  70         protected final Repository local;
  71
  72         /** Remote repository location. */
  73         protected final URIish uri;
  74
  75         /** A transport connected to {@link #uri}. */
  76         protected final PackTransport transport;
  77
  78         /** Buffered input stream reading from the remote. */
  79         protected InputStream in;
  80
  81         /** Buffered output stream sending to the remote. */
  82         protected OutputStream out;
  83
  84         /** Packet line decoder around {@link #in}. */
  85         protected PacketLineIn pckIn;
  86
  87         /** Packet line encoder around {@link #out}. */
  88         protected PacketLineOut pckOut;
  89
  90         /** Send {@link PacketLineOut#end()} before closing {@link #out}? */
  91         protected boolean outNeedsEnd;
  92
  93         /** Capability tokens advertised by the remote side. */
  94         private final Set<String> remoteCapablities = new HashSet<String>();
  95
  96         /** Extra objects the remote has, but which aren't offered as refs. */
  97         protected final Set<ObjectId> additionalHaves = new HashSet<ObjectId>();
  98
  99         BasePackConnection(final PackTransport packTransport) {
 100                 local = packTransport.local;
 101                 uri = packTransport.uri;
 102                 transport = packTransport;
 103         }
 104
 105         protected void init(final InputStream myIn, final OutputStream myOut) {
 106                 in = myIn instanceof BufferedInputStream ? myIn
 107                                 : new BufferedInputStream(myIn, IndexPack.BUFFER_SIZE);
 108                 out = myOut instanceof BufferedOutputStream ? myOut
 109                                 : new BufferedOutputStream(myOut);
 110
 111                 pckIn = new PacketLineIn(in);
 112                 pckOut = new PacketLineOut(out);
 113                 outNeedsEnd = true;
 114         }
 115
 116         protected void readAdvertisedRefs() throws TransportException {
 117                 try {
 118                         readAdvertisedRefsImpl();
 119                 } catch (TransportException err) {
 120                         close();
 121                         throw err;
 122                 } catch (IOException err) {
 123                         close();
 124                         throw new TransportException(err.getMessage(), err);
 125                 } catch (RuntimeException err) {
 126                         close();
 127                         throw new TransportException(err.getMessage(), err);
 128                 }
 129         }
 130
 131         private void readAdvertisedRefsImpl() throws IOException {
 132                 final LinkedHashMap<String, Ref> avail = new LinkedHashMap<String, Ref>();
 133                 for (;;) {
 134                         String line;
 135
 136                         try {
 137                                 line = pckIn.readString();
 138                         } catch (EOFException eof) {
 139                                 if (avail.isEmpty())
 140                                         throw noRepository();
 141                                 throw eof;
 142                         }
 143
 144                         if (avail.isEmpty()) {
 145                                 final int nul = line.indexOf('\0');
 146                                 if (nul >= 0) {
 147                                         // The first line (if any) may contain "hidden"
 148                                         // capability values after a NUL byte.
 149                                         for (String c : line.substring(nul + 1).split(" "))
 150                                                 remoteCapablities.add(c);
 151                                         line = line.substring(0, nul);
 152                                 }
 153                         }
 154
 155                         if (line.length() == 0)
 156                                 break;
 157
 158                         String name = line.substring(41, line.length());
 159                         if (avail.isEmpty() && name.equals("capabilities^{}")) {
 160                                 // special line from git-receive-pack to show
 161                                 // capabilities when there are no refs to advertise
 162                                 continue;
 163                         }
 164
 165                         final ObjectId id = ObjectId.fromString(line.substring(0, 40));
 166                         if (name.equals(".have")) {
 167                                 additionalHaves.add(id);
 168                         } else if (name.endsWith("^{}")) {
 169                                 name = name.substring(0, name.length() - 3);
 170                                 final Ref prior = avail.get(name);
 171                                 if (prior == null)
 172                                         throw new PackProtocolException(uri, "advertisement of "
 173                                                         + name + "^{} came before " + name);
 174
 175                                 if (prior.getPeeledObjectId() != null)
 176                                         throw duplicateAdvertisement(name + "^{}");
 177
 178                                 avail.put(name, new Ref(Ref.Storage.NETWORK, name, prior
 179                                                 .getObjectId(), id, true));
 180                         } else {
 181                                 final Ref prior;
 182                                 prior = avail.put(name, new Ref(Ref.Storage.NETWORK, name, id));
 183                                 if (prior != null)
 184                                         throw duplicateAdvertisement(name);
 185                         }
 186                 }
 187                 available(avail);
 188         }
 189
 190         /**
 191          * Create an exception to indicate problems finding a remote repository. The
 192          * caller is expected to throw the returned exception.
 193          *
 194          * Subclasses may override this method to provide better diagnostics.
 195          *
 196          * @return a TransportException saying a repository cannot be found and
 197          *         possibly why.
 198          */
 199         protected TransportException noRepository() {
 200                 return new NoRemoteRepositoryException(uri, "not found.");
 201         }
 202
 203         protected boolean isCapableOf(final String option) {
 204                 return remoteCapablities.contains(option);
 205         }
 206
 207         protected boolean wantCapability(final StringBuilder b, final String option) {
 208                 if (!isCapableOf(option))
 209                         return false;
 210                 b.append(' ');
 211                 b.append(option);
 212                 return true;
 213         }
 214
 215         private PackProtocolException duplicateAdvertisement(final String name) {
 216                 return new PackProtocolException(uri, "duplicate advertisements of "
 217                                 + name);
 218         }
 219
 220         @Override
 221         public void close() {
 222                 if (out != null) {
 223                         try {
 224                                 if (outNeedsEnd)
 225                                         pckOut.end();
 226                                 out.close();
 227                         } catch (IOException err) {
 228                                 // Ignore any close errors.
 229                         } finally {
 230                                 out = null;
 231                                 pckOut = null;
 232                         }
 233                 }
 234
 235                 if (in != null) {
 236                         try {
 237                                 in.close();
 238                         } catch (IOException err) {
 239                                 // Ignore any close errors.
 240                         } finally {
 241                                 in = null;
 242                                 pckIn = null;
 243                         }
 244                 }
 245         }
 246 }