diff --git a/java/google/registry/flows/custom/CustomLogicFactory.java b/java/google/registry/flows/custom/CustomLogicFactory.java index 241da7a61..f1c8485ad 100644 --- a/java/google/registry/flows/custom/CustomLogicFactory.java +++ b/java/google/registry/flows/custom/CustomLogicFactory.java @@ -40,4 +40,9 @@ public class CustomLogicFactory { EppInput eppInput, SessionMetadata sessionMetadata) { return new DomainCheckFlowCustomLogic(eppInput, sessionMetadata); } + + public DomainInfoFlowCustomLogic forDomainInfoFlow( + EppInput eppInput, SessionMetadata sessionMetadata) { + return new DomainInfoFlowCustomLogic(eppInput, sessionMetadata); + } } diff --git a/java/google/registry/flows/custom/CustomLogicModule.java b/java/google/registry/flows/custom/CustomLogicModule.java index 6259b33dd..4883b33b1 100644 --- a/java/google/registry/flows/custom/CustomLogicModule.java +++ b/java/google/registry/flows/custom/CustomLogicModule.java @@ -34,4 +34,10 @@ public class CustomLogicModule { CustomLogicFactory factory, EppInput eppInput, SessionMetadata sessionMetadata) { return factory.forDomainCheckFlow(eppInput, sessionMetadata); } + + @Provides + static DomainInfoFlowCustomLogic provideDomainInfoFlowCustomLogic( + CustomLogicFactory factory, EppInput eppInput, SessionMetadata sessionMetadata) { + return factory.forDomainInfoFlow(eppInput, sessionMetadata); + } } diff --git a/java/google/registry/flows/custom/DomainInfoFlowCustomLogic.java b/java/google/registry/flows/custom/DomainInfoFlowCustomLogic.java new file mode 100644 index 000000000..db95919dd --- /dev/null +++ b/java/google/registry/flows/custom/DomainInfoFlowCustomLogic.java @@ -0,0 +1,140 @@ +// Copyright 2016 The Nomulus 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 google.registry.flows.custom; + +import com.google.auto.value.AutoValue; +import com.google.common.collect.ImmutableList; +import google.registry.flows.EppException; +import google.registry.flows.SessionMetadata; +import google.registry.flows.domain.DomainInfoFlow; +import google.registry.model.ImmutableObject; +import google.registry.model.domain.DomainResource; +import google.registry.model.eppinput.EppInput; +import google.registry.model.eppoutput.EppResponse.ResponseExtension; + +/** + * A no-op base class for {@link DomainInfoFlow} custom logic. + * + *

Extend this class and override the hook(s) to perform custom logic. + */ +public class DomainInfoFlowCustomLogic extends BaseFlowCustomLogic { + + protected DomainInfoFlowCustomLogic(EppInput eppInput, SessionMetadata sessionMetadata) { + super(eppInput, sessionMetadata); + } + + /** A hook that runs before any validation. This is useful to e.g. add allowable extensions. */ + @SuppressWarnings("unused") + public void beforeValidation() throws EppException { + // Do nothing. + } + + /** A hook that runs at the end of the validation step to perform additional validation. */ + @SuppressWarnings("unused") + public void afterValidation(AfterValidationParameters parameters) throws EppException { + // Do nothing. + } + + /** + * A hook that runs before the response is returned. + * + *

This takes the {@link DomainResource} and {@link ResponseExtension}s as input and returns + * them, potentially with modifications. + */ + @SuppressWarnings("unused") + public BeforeResponseReturnData beforeResponse(BeforeResponseParameters parameters) + throws EppException { + return BeforeResponseReturnData.newBuilder() + .setResData(parameters.resData()) + .setResponseExtensions(parameters.responseExtensions()) + .build(); + } + + /** A class to encapsulate parameters for a call to {@link #afterValidation}. */ + @AutoValue + public abstract static class AfterValidationParameters extends ImmutableObject { + + public abstract DomainResource domain(); + + public static Builder newBuilder() { + return new AutoValue_DomainInfoFlowCustomLogic_AfterValidationParameters.Builder(); + } + + /** Builder for {@link AfterValidationParameters}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setDomain(DomainResource domain); + + public abstract AfterValidationParameters build(); + } + } + + /** A class to encapsulate parameters for a call to {@link #beforeResponse}. */ + @AutoValue + public abstract static class BeforeResponseParameters extends ImmutableObject { + + public abstract DomainResource domain(); + + public abstract DomainResource resData(); + + public abstract ImmutableList responseExtensions(); + + public static Builder newBuilder() { + return new AutoValue_DomainInfoFlowCustomLogic_BeforeResponseParameters.Builder(); + } + + /** Builder for {@link BeforeResponseParameters}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setDomain(DomainResource domain); + + public abstract Builder setResData(DomainResource resData); + + public abstract Builder setResponseExtensions( + ImmutableList responseExtensions); + + public abstract BeforeResponseParameters build(); + } + } + + /** + * A class to encapsulate parameters for the return values from a call to {@link #beforeResponse}. + */ + @AutoValue + public abstract static class BeforeResponseReturnData extends ImmutableObject { + + public abstract DomainResource resData(); + + public abstract ImmutableList responseExtensions(); + + public static Builder newBuilder() { + return new AutoValue_DomainInfoFlowCustomLogic_BeforeResponseReturnData.Builder(); + } + + /** Builder for {@link BeforeResponseReturnData}. */ + @AutoValue.Builder + public abstract static class Builder { + + public abstract Builder setResData(DomainResource resData); + + public abstract Builder setResponseExtensions( + ImmutableList responseExtensions); + + public abstract BeforeResponseReturnData build(); + } + } +} diff --git a/java/google/registry/flows/domain/DomainInfoFlow.java b/java/google/registry/flows/domain/DomainInfoFlow.java index 447fb9eab..81507a1b5 100644 --- a/java/google/registry/flows/domain/DomainInfoFlow.java +++ b/java/google/registry/flows/domain/DomainInfoFlow.java @@ -29,6 +29,10 @@ import google.registry.flows.ExtensionManager; import google.registry.flows.Flow; import google.registry.flows.FlowModule.ClientId; import google.registry.flows.FlowModule.TargetId; +import google.registry.flows.custom.DomainInfoFlowCustomLogic; +import google.registry.flows.custom.DomainInfoFlowCustomLogic.AfterValidationParameters; +import google.registry.flows.custom.DomainInfoFlowCustomLogic.BeforeResponseParameters; +import google.registry.flows.custom.DomainInfoFlowCustomLogic.BeforeResponseReturnData; import google.registry.model.domain.DomainCommand.Info; import google.registry.model.domain.DomainCommand.Info.HostsRequest; import google.registry.model.domain.DomainResource; @@ -72,19 +76,31 @@ public final class DomainInfoFlow implements Flow { @Inject @TargetId String targetId; @Inject Clock clock; @Inject EppResponse.Builder responseBuilder; - @Inject DomainInfoFlow() {} + @Inject DomainInfoFlowCustomLogic customLogic; + + @Inject + DomainInfoFlow() {} @Override public final EppResponse run() throws EppException { extensionManager.register(FeeInfoCommandExtensionV06.class); + customLogic.beforeValidation(); extensionManager.validate(); validateClientIsLoggedIn(clientId); DateTime now = clock.nowUtc(); DomainResource domain = loadAndVerifyExistence(DomainResource.class, targetId, now); verifyOptionalAuthInfo(authInfo, domain); + customLogic.afterValidation(AfterValidationParameters.newBuilder().setDomain(domain).build()); + BeforeResponseReturnData responseData = + customLogic.beforeResponse( + BeforeResponseParameters.newBuilder() + .setDomain(domain) + .setResData(getResourceInfo(domain)) + .setResponseExtensions(getDomainResponseExtensions(domain, now)) + .build()); return responseBuilder - .setResData(getResourceInfo(domain)) - .setExtensions(getDomainResponseExtensions(domain, now)) + .setResData(responseData.resData()) + .setExtensions(responseData.responseExtensions()) .build(); } @@ -126,24 +142,21 @@ public final class DomainInfoFlow implements Flow { } FeeInfoCommandExtensionV06 feeInfo = eppInput.getSingleExtension(FeeInfoCommandExtensionV06.class); - if (feeInfo != null) { // Fee check was requested. + if (feeInfo != null) { // Fee check was requested. FeeInfoResponseExtensionV06.Builder builder = new FeeInfoResponseExtensionV06.Builder(); handleFeeRequest( - feeInfo, - builder, - InternetDomainName.from(targetId), - clientId, - null, - now, - eppInput); + feeInfo, builder, InternetDomainName.from(targetId), clientId, null, now, eppInput); extensions.add(builder.build()); } // If the TLD uses the flags extension, add it to the info response. Optional extraLogicManager = RegistryExtraFlowLogicProxy.newInstanceForDomain(domain); if (extraLogicManager.isPresent()) { - Set flags = extraLogicManager.get().getExtensionFlags( - domain, clientId, now); // As-of date is always now for info commands. + Set flags = + extraLogicManager + .get() + .getExtensionFlags( + domain, clientId, now); // As-of date is always now for info commands. if (!flags.isEmpty()) { extensions.add(FlagsInfoResponseExtension.create(ImmutableList.copyOf(flags))); }