mv com/google/domain/registry google/registry

This change renames directories in preparation for the great package
rename. The repository is now in a broken state because the code
itself hasn't been updated. However this should ensure that git
correctly preserves history for each file.

java/google/registry/tools/DeleteEppResourceCommand.java

@@ -0,0 +1,114 @@
+// Copyright 2016 The Domain Registry Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.domain.registry.tools;
+
+import static com.google.domain.registry.model.ofy.ObjectifyService.ofy;
+import static com.google.domain.registry.util.DateTimeUtils.isBeforeOrAt;
+import static org.joda.time.DateTimeZone.UTC;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableList;
+import com.google.domain.registry.model.EppResource;
+import com.google.domain.registry.model.index.ForeignKeyIndex;
+import com.google.domain.registry.model.reporting.HistoryEntry;
+import com.google.domain.registry.tools.params.EppResourceTypeParameter;
+
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+import com.googlecode.objectify.Key;
+
+import org.joda.time.DateTime;
+
+import java.util.List;
+import java.util.Map;
+
+/** Command to soft-delete a list of EppResources of a given type specified by ROIDs. */
+@Parameters(separators = " =", commandDescription = "Soft-delete EPP resources.")
+final class DeleteEppResourceCommand extends MutatingCommand {
+
+  private static final String DEFAULT_DELETION_REASON = "Deleted using registry_tool.";
+
+  @Parameter(
+      description = "List of EppResource ROIDs to soft-delete.",
+      required = true)
+  private List<String> roids;
+
+  @Parameter(
+      names = {"-t", "--type"},
+      description = "EPP resource type.",
+      required = true)
+  private EppResourceTypeParameter resourceType;
+
+  @Parameter(
+      names = {"-r", "--reason"},
+      description = "Deletion reason message.")
+  private String reason;
+
+  @Override
+  protected void init() throws Exception {
+    DateTime now = DateTime.now(UTC);
+    ImmutableList.Builder<Key<EppResource>> builder = new ImmutableList.Builder<>();
+    for (String roid : roids) {
+      builder.add(Key.create(resourceType.getType(), roid));
+    }
+    ImmutableList<Key<EppResource>> keys = builder.build();
+    Map<Key<EppResource>, EppResource> resources = ofy().load().keys(keys);
+    for (Key<EppResource> key : keys) {
+      if (resources.containsKey(key)) {
+        EppResource resource = resources.get(key);
+        if (isBeforeOrAt(resource.getDeletionTime(), now)) {
+          System.out.printf("Resource already deleted: %s\n", key);
+        } else {
+          stageEntityChange(resource, resource.asBuilder().setDeletionTime(now).build());
+          HistoryEntry deletionRecord = new HistoryEntry.Builder()
+              .setModificationTime(now)
+              .setBySuperuser(true)
+              .setClientId(resource.getCurrentSponsorClientId())
+              .setParent(key)
+              .setReason(MoreObjects.firstNonNull(reason, DEFAULT_DELETION_REASON))
+              .setType(HistoryEntry.Type.SYNTHETIC)
+              .build();
+          stageEntityChange(null, deletionRecord);
+          handleForeignKeyIndex(key, resource, now);
+          flushTransaction();
+        }
+      } else {
+        System.out.printf("Resource does not exist: %s\n", key);
+      }
+    }
+  }
+
+  private void handleForeignKeyIndex(Key<EppResource> key, EppResource resource, DateTime now) {
+    ForeignKeyIndex<?> fki = ofy().load().key(ForeignKeyIndex.createKey(resource)).now();
+    if (fki == null) {
+      System.out.printf("Creating non-existent ForeignKeyIndex for: %s\n", key);
+      stageEntityChange(null, ForeignKeyIndex.create(resource, now));
+    } else {
+      if (fki.getReference().key().equals(key)) {
+        if (isBeforeOrAt(fki.getDeletionTime(), now)) {
+          System.out.printf("ForeignKeyIndex already deleted for: %s\n", key);
+        } else {
+          // Theoretically this is the only code path that should ever be taken, as there should
+          // always be exactly one non-soft-deleted FKI for every non-soft-deleted EppResource. The
+          // other paths exist to correctly handle potential situations caused by bad data.
+          stageEntityChange(fki, ForeignKeyIndex.create(resource, now));
+        }
+      } else {
+        System.out.printf("Found ForeignKeyIndex pointing to different resource for: %s\n", key);
+        System.out.printf("It was: %s\n", fki);
+      }
+    }
+  }
+}