/* * Copyright (C) 2009, Constantine Plotnikov * Copyright (C) 2008-2009, Google Inc. * Copyright (C) 2008-2009, Robin Rosenberg * Copyright (C) 2009, Sasa Zivkov * Copyright (C) 2008, Shawn O. Pearce * and other copyright owners as documented in the project's IP log. * * This program and the accompanying materials are made available * under the terms of the Eclipse Distribution License v1.0 which * accompanies this distribution, is reproduced below, and is * available at http://www.eclipse.org/org/documents/edl-v10.php * * All rights reserved. * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * - Neither the name of the Eclipse Foundation, Inc. nor the * names of its contributors may be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package org.eclipse.jgit.transport; import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; import org.eclipse.jgit.errors.MissingBundlePrerequisiteException; import org.eclipse.jgit.errors.MissingObjectException; import org.eclipse.jgit.errors.PackProtocolException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.PackLock; import org.eclipse.jgit.lib.ProgressMonitor; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevFlag; import org.eclipse.jgit.revwalk.RevObject; import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.RawParseUtils; /** * Fetch connection for bundle based classes. It used by * instances of {@link TransportBundle} */ class BundleFetchConnection extends BaseFetchConnection { private final Transport transport; InputStream bin; final Map prereqs = new HashMap(); private String lockMessage; private PackLock packLock; BundleFetchConnection(Transport transportBundle, final InputStream src) throws TransportException { transport = transportBundle; bin = new BufferedInputStream(src, IndexPack.BUFFER_SIZE); try { switch (readSignature()) { case 2: readBundleV2(); break; default: throw new TransportException(transport.uri, "not a bundle"); } } catch (TransportException err) { close(); throw err; } catch (IOException err) { close(); throw new TransportException(transport.uri, err.getMessage(), err); } catch (RuntimeException err) { close(); throw new TransportException(transport.uri, err.getMessage(), err); } } private int readSignature() throws IOException { final String rev = readLine(new byte[1024]); if (TransportBundle.V2_BUNDLE_SIGNATURE.equals(rev)) return 2; throw new TransportException(transport.uri, "not a bundle"); } private void readBundleV2() throws IOException { final byte[] hdrbuf = new byte[1024]; final LinkedHashMap avail = new LinkedHashMap(); for (;;) { String line = readLine(hdrbuf); if (line.length() == 0) break; if (line.charAt(0) == '-') { ObjectId id = ObjectId.fromString(line.substring(1, 41)); String shortDesc = null; if (line.length() > 42) shortDesc = line.substring(42); prereqs.put(id, shortDesc); continue; } final String name = line.substring(41, line.length()); final ObjectId id = ObjectId.fromString(line.substring(0, 40)); final Ref prior = avail.put(name, new Ref(Ref.Storage.NETWORK, name, id)); if (prior != null) throw duplicateAdvertisement(name); } available(avail); } private PackProtocolException duplicateAdvertisement(final String name) { return new PackProtocolException(transport.uri, "duplicate advertisements of " + name); } private String readLine(final byte[] hdrbuf) throws IOException { bin.mark(hdrbuf.length); final int cnt = bin.read(hdrbuf); int lf = 0; while (lf < cnt && hdrbuf[lf] != '\n') lf++; bin.reset(); IO.skipFully(bin, lf); if (lf < cnt && hdrbuf[lf] == '\n') IO.skipFully(bin, 1); return RawParseUtils.decode(Constants.CHARSET, hdrbuf, 0, lf); } public boolean didFetchTestConnectivity() { return false; } @Override protected void doFetch(final ProgressMonitor monitor, final Collection want, final Set have) throws TransportException { verifyPrerequisites(); try { final IndexPack ip = newIndexPack(); ip.index(monitor); packLock = ip.renameAndOpenPack(lockMessage); } catch (IOException err) { close(); throw new TransportException(transport.uri, err.getMessage(), err); } catch (RuntimeException err) { close(); throw new TransportException(transport.uri, err.getMessage(), err); } } public void setPackLockMessage(final String message) { lockMessage = message; } public Collection getPackLocks() { if (packLock != null) return Collections.singleton(packLock); return Collections. emptyList(); } private IndexPack newIndexPack() throws IOException { final IndexPack ip = IndexPack.create(transport.local, bin); ip.setFixThin(true); ip.setObjectChecking(transport.isCheckFetchedObjects()); return ip; } private void verifyPrerequisites() throws TransportException { if (prereqs.isEmpty()) return; final RevWalk rw = new RevWalk(transport.local); final RevFlag PREREQ = rw.newFlag("PREREQ"); final RevFlag SEEN = rw.newFlag("SEEN"); final Map missing = new HashMap(); final List commits = new ArrayList(); for (final Map.Entry e : prereqs.entrySet()) { ObjectId p = e.getKey(); try { final RevCommit c = rw.parseCommit(p); if (!c.has(PREREQ)) { c.add(PREREQ); commits.add(c); } } catch (MissingObjectException notFound) { missing.put(p, e.getValue()); } catch (IOException err) { throw new TransportException(transport.uri, "Cannot read commit " + p.name(), err); } } if (!missing.isEmpty()) throw new MissingBundlePrerequisiteException(transport.uri, missing); for (final Ref r : transport.local.getAllRefs().values()) { try { rw.markStart(rw.parseCommit(r.getObjectId())); } catch (IOException readError) { // If we cannot read the value of the ref skip it. } } int remaining = commits.size(); try { RevCommit c; while ((c = rw.next()) != null) { if (c.has(PREREQ)) { c.add(SEEN); if (--remaining == 0) break; } } } catch (IOException err) { throw new TransportException(transport.uri, "Cannot read object", err); } if (remaining > 0) { for (final RevObject o : commits) { if (!o.has(SEEN)) missing.put(o, prereqs.get(o)); } throw new MissingBundlePrerequisiteException(transport.uri, missing); } } @Override public void close() { if (bin != null) { try { bin.close(); } catch (IOException ie) { // Ignore close failures. } finally { bin = null; } } } }