mirror of
https://github.com/google/nomulus.git
synced 2025-05-03 13:37:51 +02:00
d87f01e7bf
Before pushing an update to Cloud DNS, the CloudDnsWriter needs to read all the domain RRSs from Cloud DNS one by one to know what to delete. Doing so sequentially results in update times that are too long (approx 200ms per domain, which is 20 seconds per batch of 100) severely limiting our QPS. This CL uses Concurrent threading to do the Cloud DNS queries in parallel. Unfortunately, my preferred method (Set.parallelStream) doesn't work on App Engine :( This reduces the per-item time from 200ms to 80ms, which can be further reduced to 50ms if we remove the rate limiter (currently set to 20 per second). ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=178126877
89 lines
2.9 KiB
Java
89 lines
2.9 KiB
Java
// Copyright 2017 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.dns.writer.clouddns;
|
|
|
|
import com.google.api.client.http.HttpRequestInitializer;
|
|
import com.google.api.client.http.HttpTransport;
|
|
import com.google.api.client.json.JsonFactory;
|
|
import com.google.api.services.dns.Dns;
|
|
import com.google.api.services.dns.DnsScopes;
|
|
import com.google.common.base.Function;
|
|
import com.google.common.util.concurrent.RateLimiter;
|
|
import dagger.Module;
|
|
import dagger.Provides;
|
|
import dagger.multibindings.IntoMap;
|
|
import dagger.multibindings.IntoSet;
|
|
import dagger.multibindings.StringKey;
|
|
import google.registry.config.RegistryConfig.Config;
|
|
import google.registry.dns.writer.DnsWriter;
|
|
import java.util.Optional;
|
|
import java.util.Set;
|
|
import javax.inject.Named;
|
|
|
|
/** Dagger module for Google Cloud DNS service connection objects. */
|
|
@Module
|
|
public final class CloudDnsWriterModule {
|
|
|
|
@Provides
|
|
static Dns provideDns(
|
|
HttpTransport transport,
|
|
JsonFactory jsonFactory,
|
|
Function<Set<String>, ? extends HttpRequestInitializer> credential,
|
|
@Config("projectId") String projectId,
|
|
@Config("cloudDnsRootUrl") Optional<String> rootUrl,
|
|
@Config("cloudDnsServicePath") Optional<String> servicePath) {
|
|
Dns.Builder builder =
|
|
new Dns.Builder(transport, jsonFactory, credential.apply(DnsScopes.all()))
|
|
.setApplicationName(projectId);
|
|
|
|
rootUrl.ifPresent(builder::setRootUrl);
|
|
servicePath.ifPresent(builder::setServicePath);
|
|
|
|
return builder.build();
|
|
}
|
|
|
|
@Provides
|
|
@IntoMap
|
|
@StringKey(CloudDnsWriter.NAME)
|
|
static DnsWriter provideWriter(CloudDnsWriter writer) {
|
|
return writer;
|
|
}
|
|
|
|
@Provides
|
|
@IntoSet
|
|
@Named("dnsWriterNames")
|
|
static String provideWriterName() {
|
|
return CloudDnsWriter.NAME;
|
|
}
|
|
|
|
@Provides
|
|
@Named("cloudDns")
|
|
static RateLimiter provideRateLimiter() {
|
|
// This is the default max QPS for Cloud DNS. It can be increased by contacting the team
|
|
// via the Quotas page on the Cloud Console.
|
|
int cloudDnsMaxQps = 20;
|
|
return RateLimiter.create(cloudDnsMaxQps);
|
|
}
|
|
|
|
@Provides
|
|
@Named("cloudDnsNumThreads")
|
|
static int provideNumThreads() {
|
|
// TODO(b/70217860): find the "best" number of threads, taking into account running time, App
|
|
// Engine constraints, and any Cloud DNS comsiderations etc.
|
|
//
|
|
// NOTE: any number below 2 will not use threading at all.
|
|
return 10;
|
|
}
|
|
}
|