Package org.locationtech.geogig.storage

Examples of org.locationtech.geogig.storage.ObjectDatabase


        }

        if (getProgressListener().isCanceled()) {
            return null;
        }
        final ObjectDatabase objectDb = objectDatabase();
        objectDb.put(commit);
        // set the HEAD pointing to the new commit
        final Optional<Ref> branchHead = command(UpdateRef.class).setName(currentBranch)
                .setNewValue(commit.getId()).call();
        checkState(commit.getId().equals(branchHead.get().getObjectId()));
View Full Code Here


            RevCommit commit = (RevCommit) object.get();

            FilteredDiffIterator changes = getFilteredChanges(commit);

            GraphDatabase graphDatabase = localRepository.graphDatabase();
            ObjectDatabase objectDatabase = localRepository.objectDatabase();
            graphDatabase.put(commit.getId(), commit.getParentIds());

            RevTree rootTree = RevTree.EMPTY;

            if (commit.getParentIds().size() > 0) {
                // Map this commit to the last "sparse" commit in my ancestry
                ObjectId mappedCommit = graphDatabase.getMapping(commit.getParentIds().get(0));
                graphDatabase.map(commit.getId(), mappedCommit);
                Optional<ObjectId> treeId = localRepository.command(ResolveTreeish.class)
                        .setTreeish(mappedCommit).call();
                if (treeId.isPresent()) {
                    rootTree = localRepository.getTree(treeId.get());
                }

            } else {
                graphDatabase.map(commit.getId(), ObjectId.NULL);
            }

            Iterator<DiffEntry> it = Iterators.filter(changes, new Predicate<DiffEntry>() {
                @Override
                public boolean apply(DiffEntry e) {
                    return true;
                }
            });

            if (it.hasNext()) {
                // Create new commit
                WriteTree writeTree = localRepository.command(WriteTree.class)
                        .setOldRoot(Suppliers.ofInstance(rootTree))
                        .setDiffSupplier(Suppliers.ofInstance((Iterator<DiffEntry>) it));

                if (changes.isAutoIngesting()) {
                    // the iterator already ingests objects into the ObjectDatabase
                    writeTree.dontMoveObjects();
                }

                ObjectId newTreeId = writeTree.call();

                CommitBuilder builder = new CommitBuilder(commit);
                List<ObjectId> newParents = new LinkedList<ObjectId>();
                for (ObjectId parentCommitId : commit.getParentIds()) {
                    newParents.add(graphDatabase.getMapping(parentCommitId));
                }
                builder.setParentIds(newParents);
                builder.setTreeId(newTreeId);

                RevCommit mapped = builder.build();
                objectDatabase.put(mapped);

                if (changes.wasFiltered()) {
                    graphDatabase.setProperty(mapped.getId(), GraphDatabase.SPARSE_FLAG, "true");
                }

                graphDatabase.map(mapped.getId(), commit.getId());
                // Replace the old mapping with the new commit Id.
                graphDatabase.map(commit.getId(), mapped.getId());
            } else if (allowEmpty) {
                CommitBuilder builder = new CommitBuilder(commit);
                List<ObjectId> newParents = new LinkedList<ObjectId>();
                for (ObjectId parentCommitId : commit.getParentIds()) {
                    newParents.add(graphDatabase.getMapping(parentCommitId));
                }
                builder.setParentIds(newParents);
                builder.setTreeId(rootTree.getId());
                builder.setMessage(PLACEHOLDER_COMMIT_MESSAGE);

                RevCommit mapped = builder.build();
                objectDatabase.put(mapped);

                graphDatabase.setProperty(mapped.getId(), GraphDatabase.SPARSE_FLAG, "true");

                graphDatabase.map(mapped.getId(), commit.getId());
                // Replace the old mapping with the new commit Id.
View Full Code Here

        if (fetch) {
            Repository tmp = to;
            to = from;
            from = tmp;
        }
        final ObjectDatabase fromDb = from.objectDatabase();
        final ObjectDatabase toDb = to.objectDatabase();

        final RevObject object = fromDb.get(newHeadId);

        RevCommit commit = null;
        RevTag tag = null;

        if (object.getType().equals(TYPE.COMMIT)) {
            commit = (RevCommit) object;
        } else if (object.getType().equals(TYPE.TAG)) {
            tag = (RevTag) object;
            commit = fromDb.getCommit(tag.getCommitId());
        }
        if (commit != null) {
            final RevTree newTree = fromDb.getTree(commit.getTreeId());
            List<ObjectId> parentIds = new ArrayList<>(commit.getParentIds());
            if (parentIds.isEmpty()) {
                parentIds.add(ObjectId.NULL);
            }
            RevTree oldTree = RevTree.EMPTY;
            // the diff against each parent is not working. For some reason some buckets that are
            // equal between the two ends of the comparison never get transferred (at some point
            // they shouldn't be equal and so the Consumer notified of it/them). Yet with the target
            // databse exists check for each tree the performance is good enough.
            // for (ObjectId parentId : parentIds) {
            // if (!parentId.isNull()) {
            // RevCommit parent = fromDb.getCommit(parentId);
            // oldTree = fromDb.getTree(parent.getTreeId());
            // }
            copyNewObjects(oldTree, newTree, fromDb, toDb, progress);
            // }
            Preconditions.checkState(toDb.exists(newTree.getId()));

            toDb.put(commit);
        }
        if (tag != null) {
            toDb.put(tag);
        }
    }
View Full Code Here

     * @param changes the changes to write
     * @throws IOException
     * @return the number of objects written
     */
    public long write(OutputStream out, Iterator<DiffEntry> changes) throws IOException {
        final ObjectDatabase objectDatabase = repository.objectDatabase();
        out = new CountingOutputStream(out);

        // avoids sending the same metadata object multiple times
        Set<ObjectId> writtenMetadataIds = new HashSet<ObjectId>();

        // buffer to avoid ObjectId cloning its internal state for each object
        byte[] oidbuffer = new byte[ObjectId.NUM_BYTES];

        long objectCount = 0;

        while (changes.hasNext()) {
            DiffEntry diff = changes.next();

            if (diff.isDelete()) {
                out.write(CHUNK_TYPE.DIFF_ENTRY.value());
            } else {
                // its a change or an addition, new object is guaranteed to be present
                NodeRef newObject = diff.getNewObject();
                ObjectId metadataId = newObject.getMetadataId();
                if (writtenMetadataIds.contains(metadataId)) {
                    out.write(CHUNK_TYPE.OBJECT_AND_DIFF_ENTRY.value());
                } else {
                    out.write(CHUNK_TYPE.METADATA_OBJECT_AND_DIFF_ENTRY.value());
                    RevObject metadata = objectDatabase.get(metadataId);
                    writeObjectId(metadataId, out, oidbuffer);
                    serializer.createObjectWriter(metadata.getType()).write(metadata, out);
                    writtenMetadataIds.add(metadataId);
                    objectCount++;
                }

                ObjectId objectId = newObject.objectId();
                writeObjectId(objectId, out, oidbuffer);
                RevObject object = objectDatabase.get(objectId);
                serializer.createObjectWriter(object.getType()).write(object, out);
                objectCount++;
            }
            DataOutput dataOut = new DataOutputStream(out);
            FormatCommonV1.writeDiff(diff, dataOut);
View Full Code Here

    public void ingest(final InputStream in, Callback callback) {
        PacketReadingIterator readingIterator = new PacketReadingIterator(in);

        Iterator<RevObject> asObjects = asObjects(readingIterator, callback);

        ObjectDatabase objectDatabase = repository.objectDatabase();
        CountingListener listener = BulkOpListener.newCountingListener();
        objectDatabase.putAll(asObjects, listener);
        LOGGER.info("Ingested %,d objects. Inserted: %,d. Already existing: %,d\n",
                listener.inserted() + listener.found(), listener.inserted(), listener.found());
        this.filtered = readingIterator.isFiltered();
    }
View Full Code Here

                repository = repository();
            }
            try {
                repository.open();
                // make sure the repo has the empty tree
                ObjectDatabase objectDatabase = repository.objectDatabase();
                objectDatabase.put(RevTree.EMPTY);
            } catch (RepositoryConnectionException e) {
                throw new IllegalStateException("Error opening repository databases: "
                        + e.getMessage(), e);
            }
            createSampleHooks(envHome);
View Full Code Here

                            roots.removeAll(commit.getParentIds());
                            roots.add(commit.getId());
                        }
                    }
                };
                ObjectDatabase database = localRepository.objectDatabase();
                BinaryPackedObjects packer = new BinaryPackedObjects(database);

                ImmutableList<ObjectId> have = ImmutableList.copyOf(roots);
                final boolean traverseCommits = false;
View Full Code Here

        } catch (UnsupportedOperationException e) {
            assertTrue(true);
        }

        hints.set(Hints.OBJECTS_READ_ONLY, Boolean.FALSE);
        ObjectDatabase db2 = createDb();

        Assert.assertTrue(db2.put(obj));
        db.close();
        db2.close();
    }
View Full Code Here

        db.close();
        db2.close();
    }

    public void testMultipleInstances() {
        ObjectDatabase db1 = createDb();
        ObjectDatabase db2 = createDb();

        RevObject obj = RevTree.EMPTY;

        assertTrue(db1.put(obj));
        db1.close();
        assertFalse(db2.put(obj));
        db2.close();

        RevObject revObject = db.get(obj.getId());
        assertEquals(obj, revObject);
    }
View Full Code Here

     * @return the {@link ObjectId} of the moved object, or {@code null} if {@link #setObjects} was
     *         used and hence no such information it available
     */
    @Override
    protected ObjectId _call() {
        ObjectDatabase from = toIndex ? objectDatabase() : stagingDatabase();
        ObjectDatabase to = toIndex ? stagingDatabase() : objectDatabase();

        Set<ObjectId> metadataIds = new HashSet<ObjectId>();

        final ObjectId ret;
        if (objectRef != null) {
View Full Code Here

TOP

Related Classes of org.locationtech.geogig.storage.ObjectDatabase

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.