Esempio n. 1
0
 @Test
 public void testPartialApplication() throws Exception {
   insert(points1, points2);
   Patch patch = new Patch();
   String pathRemove = NodeRef.appendChild(pointsName, points2.getIdentifier().getID());
   patch.addRemovedFeature(pathRemove, points2, RevFeatureType.build(pointsType));
   String pathModify = NodeRef.appendChild(pointsName, points1B.getIdentifier().getID());
   Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap();
   Optional<?> oldValue = Optional.fromNullable(points1B.getProperty("extra").getValue());
   GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(oldValue, null);
   map.put(modifiedPointsType.getDescriptor("extra"), diff);
   FeatureDiff featureDiff =
       new FeatureDiff(
           pathModify,
           map,
           RevFeatureType.build(modifiedPointsType),
           RevFeatureType.build(pointsType));
   patch.addModifiedFeature(featureDiff);
   Patch rejected =
       geogit.command(ApplyPatchOp.class).setPatch(patch).setApplyPartial(true).call();
   assertFalse(rejected.isEmpty());
   RevTree root = repo.getWorkingTree().getTree();
   assertNotNull(root);
   Optional<Node> featureBlobId = findTreeChild(root, pathRemove);
   assertFalse(featureBlobId.isPresent());
   // now we take the rejected patch and apply it, and the new rejected should be identical to
   // it
   Patch newRejected =
       geogit.command(ApplyPatchOp.class).setPatch(rejected).setApplyPartial(true).call();
   assertEquals(rejected, newRejected);
 }
Esempio n. 2
0
 @Test
 public void testReversedPatch() throws Exception {
   insert(points1, points2);
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID());
   Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap();
   Optional<?> oldValue = Optional.fromNullable(points1.getProperty("sp").getValue());
   GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(oldValue, Optional.of("new"));
   map.put(pointsType.getDescriptor("sp"), diff);
   FeatureDiff feaureDiff =
       new FeatureDiff(
           path, map, RevFeatureType.build(pointsType), RevFeatureType.build(pointsType));
   patch.addModifiedFeature(feaureDiff);
   String removedPath = NodeRef.appendChild(pointsName, points2.getIdentifier().getID());
   patch.addRemovedFeature(removedPath, points2, RevFeatureType.build(pointsType));
   String addedPath = NodeRef.appendChild(pointsName, points3.getIdentifier().getID());
   patch.addAddedFeature(addedPath, points3, RevFeatureType.build(pointsType));
   geogit.command(ApplyPatchOp.class).setPatch(patch).call();
   geogit.command(ApplyPatchOp.class).setPatch(patch.reversed()).call();
   RevTree root = repo.getWorkingTree().getTree();
   Optional<Node> featureBlobId = findTreeChild(root, removedPath);
   assertTrue(featureBlobId.isPresent());
   featureBlobId = findTreeChild(root, addedPath);
   assertFalse(featureBlobId.isPresent());
   Optional<RevFeature> feature =
       geogit.command(RevObjectParse.class).setRefSpec("WORK_HEAD:" + path).call(RevFeature.class);
   assertTrue(feature.isPresent());
   assertEquals(oldValue, feature.get().getValues().get(0));
 }
Esempio n. 3
0
  private ObjectId writeBack(
      RevTreeBuilder ancestor,
      final String ancestorPath,
      final RevTree childTree,
      final String childPath,
      final ObjectDatabase targetDatabase) {

    final ObjectId treeId = childTree.getId();
    targetDatabase.put(childTree);

    final boolean isDirectChild = NodeRef.isDirectChild(ancestorPath, childPath);
    if (isDirectChild) {
      ObjectId metadataId = ObjectId.NULL;
      ancestor.put(new Node(childPath, treeId, metadataId, TYPE.TREE));
      RevTree newAncestor = ancestor.build();
      targetDatabase.put(newAncestor);
      return newAncestor.getId();
    }

    final String parentPath = NodeRef.parentPath(childPath);
    Optional<Node> parentRef = getTreeChild(ancestor, parentPath);
    RevTreeBuilder parentBuilder;
    if (parentRef.isPresent()) {
      ObjectId parentId = parentRef.get().getObjectId();
      parentBuilder = getTree(parentId).builder(targetdb);
    } else {
      parentBuilder = RevTree.EMPTY.builder(targetDatabase);
    }

    parentBuilder.put(new Node(NodeRef.nodeFromPath(childPath), treeId, ObjectId.NULL, TYPE.TREE));
    RevTree parent = parentBuilder.build();

    return writeBack(ancestor, ancestorPath, parent, parentPath, targetDatabase);
  }
Esempio n. 4
0
 /**
  * Translates a feature pointed by a node from its original feature type to a given one, using
  * values from those attributes that exist in both original and destination feature type. New
  * attributes are populated with null values
  *
  * @param node The node that points to the feature. No checking is performed to ensure the node
  *     points to a feature instead of other type
  * @param featureType the destination feature type
  * @return a feature with the passed feature type and data taken from the input feature
  */
 private Feature alter(NodeRef node, RevFeatureType featureType) {
   RevFeature oldFeature =
       command(RevObjectParse.class).setObjectId(node.objectId()).call(RevFeature.class).get();
   RevFeatureType oldFeatureType;
   oldFeatureType =
       command(RevObjectParse.class)
           .setObjectId(node.getMetadataId())
           .call(RevFeatureType.class)
           .get();
   ImmutableList<PropertyDescriptor> oldAttributes = oldFeatureType.sortedDescriptors();
   ImmutableList<PropertyDescriptor> newAttributes = featureType.sortedDescriptors();
   ImmutableList<Optional<Object>> oldValues = oldFeature.getValues();
   List<Optional<Object>> newValues = Lists.newArrayList();
   for (int i = 0; i < newAttributes.size(); i++) {
     int idx = oldAttributes.indexOf(newAttributes.get(i));
     if (idx != -1) {
       Optional<Object> oldValue = oldValues.get(idx);
       newValues.add(oldValue);
     } else {
       newValues.add(Optional.absent());
     }
   }
   RevFeature newFeature = RevFeature.build(ImmutableList.copyOf(newValues));
   FeatureBuilder featureBuilder = new FeatureBuilder(featureType);
   Feature feature = featureBuilder.build(node.name(), newFeature);
   return feature;
 }
Esempio n. 5
0
 /** Provides for natural ordering of {@code NodeRef}, based on {@link #path()} */
 @Override
 public int compareTo(NodeRef o) {
   int c = parentPath.compareTo(o.getParentPath());
   if (c == 0) {
     return node.compareTo(o.getNode());
   }
   return c;
 }
Esempio n. 6
0
 /**
  * Tests equality over another {@code NodeRef} based on {@link #getParentPath() parent path},
  * {@link #getNode() node} name and id, and {@link #getMetadataId()}
  */
 @Override
 public boolean equals(Object o) {
   if (!(o instanceof NodeRef)) {
     return false;
   }
   NodeRef r = (NodeRef) o;
   return parentPath.equals(r.parentPath)
       && node.equals(r.node)
       && getMetadataId().equals(r.getMetadataId());
 }
Esempio n. 7
0
 @Test
 public void testModifyFeatureAttributePatch() throws Exception {
   insert(points1);
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID());
   Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap();
   Optional<?> oldValue = Optional.fromNullable(points1.getProperty("sp").getValue());
   GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(oldValue, Optional.of("new"));
   map.put(pointsType.getDescriptor("sp"), diff);
   FeatureDiff feaureDiff =
       new FeatureDiff(
           path, map, RevFeatureType.build(pointsType), RevFeatureType.build(pointsType));
   patch.addModifiedFeature(feaureDiff);
   geogit.command(ApplyPatchOp.class).setPatch(patch).call();
   RevTree root = repo.getWorkingTree().getTree();
   Optional<Node> featureBlobId = findTreeChild(root, path);
   assertTrue(featureBlobId.isPresent());
   Iterator<DiffEntry> unstaged = repo.getWorkingTree().getUnstaged(pointsName);
   ArrayList<DiffEntry> diffs = Lists.newArrayList(unstaged);
   assertEquals(2, diffs.size());
   Optional<RevFeature> feature =
       geogit.command(RevObjectParse.class).setRefSpec("WORK_HEAD:" + path).call(RevFeature.class);
   assertTrue(feature.isPresent());
   ImmutableList<Optional<Object>> values = feature.get().getValues();
   assertEquals("new", values.get(0).get());
 }
Esempio n. 8
0
 @Test
 public void testRemovedFeatureDoesNotExists() throws Exception {
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID());
   patch.addRemovedFeature(path, points1, RevFeatureType.build(pointsType));
   try {
     geogit.command(ApplyPatchOp.class).setPatch(patch).call();
     fail();
   } catch (CannotApplyPatchException e) {
     assertTrue(true);
   }
 }
Esempio n. 9
0
 @Test
 public void testRemoveFeaturePatch() throws Exception {
   insert(points1);
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID());
   patch.addRemovedFeature(path, points1, RevFeatureType.build(pointsType));
   geogit.command(ApplyPatchOp.class).setPatch(patch).call();
   RevTree root = repo.getWorkingTree().getTree();
   assertNotNull(root);
   Optional<Node> featureBlobId = findTreeChild(root, path);
   assertFalse(featureBlobId.isPresent());
 }
Esempio n. 10
0
 @Test
 public void testAddFeatureWithNonDefaultFeatureType() throws Exception {
   insert(points2, points3);
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID());
   patch.addAddedFeature(path, points1B, RevFeatureType.build(modifiedPointsType));
   geogit.command(ApplyPatchOp.class).setPatch(patch).call();
   RevTree root = repo.getWorkingTree().getTree();
   assertNotNull(root);
   Optional<Node> typeTreeId = findTreeChild(root, pointsName);
   assertEquals(typeTreeId.get().getMetadataId().get(), RevFeatureType.build(pointsType).getId());
   RevTree typeTree = repo.getTree(typeTreeId.get().getObjectId());
   assertNotNull(typeTree);
   Optional<Node> featureBlobId = findTreeChild(root, path);
   assertEquals(
       RevFeatureType.build(modifiedPointsType).getId(),
       featureBlobId.get().getMetadataId().orNull());
   assertTrue(featureBlobId.isPresent());
   path = NodeRef.appendChild(pointsName, points3.getIdentifier().getID());
   featureBlobId = findTreeChild(root, path);
   assertEquals(null, featureBlobId.get().getMetadataId().orNull());
 }
Esempio n. 11
0
 @Test
 public void testModifiedFeatureType() throws Exception {
   insert(points2, points3, points1B);
   Patch patch = new Patch();
   RevFeatureType oldFeatureType = RevFeatureType.build(pointsType);
   RevFeatureType featureType = RevFeatureType.build(modifiedPointsType);
   patch.addFeatureType(featureType);
   patch.addAlteredTree(
       new FeatureTypeDiff(pointsName, oldFeatureType.getId(), featureType.getId()));
   geogit.command(ApplyPatchOp.class).setPatch(patch).call();
   RevTree root = repo.getWorkingTree().getTree();
   assertNotNull(root);
   Optional<Node> typeTree = findTreeChild(root, pointsName);
   assertTrue(typeTree.isPresent());
   assertEquals(featureType.getId(), typeTree.get().getMetadataId().get());
   Optional<Node> featureNode = findTreeChild(root, NodeRef.appendChild(pointsName, idP2));
   assertTrue(featureNode.isPresent());
   assertEquals(oldFeatureType.getId(), featureNode.get().getMetadataId().get());
   featureNode = findTreeChild(root, NodeRef.appendChild(pointsName, idP1));
   assertTrue(featureNode.isPresent());
   assertFalse(featureNode.get().getMetadataId().isPresent());
 }
Esempio n. 12
0
 @Test
 public void testAddFeatureAttributePatch() throws Exception {
   insert(points1);
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID());
   Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap();
   Optional<?> newValue = Optional.fromNullable(points1B.getProperty("extra").getValue());
   GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(null, newValue);
   map.put(modifiedPointsType.getDescriptor("extra"), diff);
   FeatureDiff featureDiff =
       new FeatureDiff(
           path, map, RevFeatureType.build(pointsType), RevFeatureType.build(modifiedPointsType));
   patch.addModifiedFeature(featureDiff);
   geogit.command(ApplyPatchOp.class).setPatch(patch).call();
   // TODO
 }
Esempio n. 13
0
  /**
   * Executes the write back operation.
   *
   * @return the {@link ObjectId id} of the resulting new ancestor tree.
   */
  @Override
  public ObjectId call() {
    checkNotNull(tree, "child tree not set");
    checkNotNull(childPath, "child tree path not set");

    String ancestorPath = resolveAncestorPath();
    checkArgument(
        NodeRef.isChild(ancestorPath, childPath),
        String.format(
            "child path '%s' is not a child of ancestor path '%s'", childPath, ancestorPath));

    RevTree tree = this.tree.get();
    checkState(null != tree, "child tree supplier returned null");

    ObjectDatabase targetDb = indexDb ? index : odb;
    RevTreeBuilder root = resolveAncestor();

    return writeBack(root, ancestorPath, tree, childPath, targetDb);
  }
Esempio n. 14
0
 @Test
 public void testModifiedFeatureDoesNotExists() throws Exception {
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1.getIdentifier().getID());
   Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap();
   Optional<?> oldValue = Optional.fromNullable(points1.getProperty("sp").getValue());
   GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(oldValue, Optional.of("new"));
   map.put(pointsType.getDescriptor("sp"), diff);
   FeatureDiff featureDiff =
       new FeatureDiff(
           path, map, RevFeatureType.build(pointsType), RevFeatureType.build(pointsType));
   patch.addModifiedFeature(featureDiff);
   try {
     geogit.command(ApplyPatchOp.class).setPatch(patch).call();
     fail();
   } catch (CannotApplyPatchException e) {
     assertTrue(true);
   }
 }
Esempio n. 15
0
 @Test
 public void testRemoveFeatureAttributePatch() throws Exception {
   insert(points1B);
   Patch patch = new Patch();
   String path = NodeRef.appendChild(pointsName, points1B.getIdentifier().getID());
   Map<PropertyDescriptor, AttributeDiff> map = Maps.newHashMap();
   Optional<?> oldValue = Optional.fromNullable(points1B.getProperty("extra").getValue());
   GenericAttributeDiffImpl diff = new GenericAttributeDiffImpl(oldValue, null);
   map.put(modifiedPointsType.getDescriptor("extra"), diff);
   FeatureDiff featureDiff =
       new FeatureDiff(
           path, map, RevFeatureType.build(modifiedPointsType), RevFeatureType.build(pointsType));
   patch.addModifiedFeature(featureDiff);
   geogit.command(ApplyPatchOp.class).setPatch(patch).call();
   Optional<RevFeature> feature =
       geogit.command(RevObjectParse.class).setRefSpec("WORK_HEAD:" + path).call(RevFeature.class);
   assertTrue(feature.isPresent());
   ImmutableList<Optional<Object>> values = feature.get().getValues();
   assertEquals(points1.getProperties().size(), values.size());
   assertFalse(values.contains("ExtraString"));
 }
Esempio n. 16
0
 /**
  * Returns the full path from the root tree to the object this ref points to
  *
  * <p>This is a derived property, shortcut for <code>
  * {@link #getParentPath()} + "/" + getNode().getName() </code>
  */
 public String path() {
   return NodeRef.appendChild(parentPath, node.getName());
 }
Esempio n. 17
0
  /**
   * Executes the import operation using the parameters that have been specified. Features will be
   * added to the working tree, and a new working tree will be constructed. Either {@code all} or
   * {@code table}, but not both, must be set prior to the import process.
   *
   * @return RevTree the new working tree
   */
  @SuppressWarnings("deprecation")
  @Override
  public RevTree call() {

    // check preconditions and get the actual list of type names to import
    final String[] typeNames = checkPreconditions();

    ProgressListener progressListener = getProgressListener();
    progressListener.started();

    // use a local variable not to alter the command's state
    boolean overwrite = this.overwrite;
    if (alter) {
      overwrite = false;
    }

    final WorkingTree workTree = getWorkTree();

    final boolean destPathProvided = destPath != null;
    if (destPathProvided && overwrite) {
      // we delete the previous tree to honor the overwrite setting, but then turn it
      // to false. Otherwise, each table imported will overwrite the previous ones and
      // only the last one will be imported.
      try {
        workTree.delete(destPath);
      } catch (Exception e) {
        throw new GeoToolsOpException(e, StatusCode.UNABLE_TO_INSERT);
      }
      overwrite = false;
    }

    int tableCount = 0;

    for (String typeName : typeNames) {
      {
        tableCount++;
        String tableName = String.format("%-16s", typeName);
        if (typeName.length() > 16) {
          tableName = tableName.substring(0, 13) + "...";
        }
        progressListener.setDescription(
            "Importing " + tableName + " (" + tableCount + "/" + typeNames.length + ")... ");
      }

      FeatureSource featureSource = getFeatureSource(typeName);
      SimpleFeatureType featureType = (SimpleFeatureType) featureSource.getSchema();

      final String fidPrefix = featureType.getTypeName() + ".";

      String path;
      if (destPath == null) {
        path = featureType.getTypeName();
      } else {
        NodeRef.checkValidPath(destPath);
        path = destPath;
        featureType = createForceFeatureType(featureType, path);
      }
      featureSource =
          new ForceTypeAndFidFeatureSource<FeatureType, Feature>(
              featureSource, featureType, fidPrefix);

      ProgressListener taskProgress = subProgress(100.f / typeNames.length);
      if (overwrite) {
        try {
          workTree.delete(path);
          workTree.createTypeTree(path, featureType);
        } catch (Exception e) {
          throw new GeoToolsOpException(e, StatusCode.UNABLE_TO_INSERT);
        }
      }

      if (alter) {
        // first we modify the feature type and the existing features, if needed
        workTree.updateTypeTree(path, featureType);
        Iterator<Feature> transformedIterator = transformFeatures(featureType, path);
        try {
          final Integer collectionSize = collectionSize(featureSource);
          workTree.insert(path, transformedIterator, taskProgress, null, collectionSize);
        } catch (Exception e) {
          throw new GeoToolsOpException(StatusCode.UNABLE_TO_INSERT);
        }
      }
      try {
        insert(workTree, path, featureSource, taskProgress);
      } catch (Exception e) {
        throw new GeoToolsOpException(e, StatusCode.UNABLE_TO_INSERT);
      }
    }

    progressListener.progress(100.f);
    progressListener.complete();
    return workTree.getTree();
  }