resolveTxt(String domainName) throws NameNotFoundException;
25 | }
26 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/FileCredentialFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import com.google.api.client.http.HttpRequestInitializer;
20 | import com.google.api.services.sqladmin.SQLAdminScopes;
21 | import com.google.auth.http.HttpCredentialsAdapter;
22 | import com.google.auth.oauth2.GoogleCredentials;
23 | import com.google.cloud.sql.CredentialFactory;
24 | import java.io.FileInputStream;
25 | import java.io.IOException;
26 | import java.util.Arrays;
27 |
28 | class FileCredentialFactory implements CredentialFactory {
29 | private final String path;
30 |
31 | FileCredentialFactory(String path) {
32 | this.path = path;
33 | }
34 |
35 | @Override
36 | public HttpRequestInitializer create() {
37 | return new HttpCredentialsAdapter(getCredentials());
38 | }
39 |
40 | @Override
41 | public GoogleCredentials getCredentials() {
42 | GoogleCredentials credentials;
43 | try {
44 | credentials = GoogleCredentials.fromStream(new FileInputStream(path));
45 | } catch (IOException e) {
46 | throw new IllegalStateException("Unable to load GoogleCredentials from file " + path, e);
47 | }
48 |
49 | if (credentials.createScopedRequired()) {
50 | credentials =
51 | credentials.createScoped(
52 | Arrays.asList(SQLAdminScopes.SQLSERVICE_ADMIN, SQLAdminScopes.CLOUD_PLATFORM));
53 | }
54 |
55 | return credentials;
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/InstanceCheckingTrustManagerFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import java.io.IOException;
20 | import java.security.KeyStore;
21 | import java.security.KeyStoreException;
22 | import java.security.NoSuchAlgorithmException;
23 | import java.security.cert.Certificate;
24 | import java.security.cert.CertificateException;
25 | import javax.net.ssl.TrustManagerFactory;
26 |
27 | /**
28 | * Implement custom server certificate trust checks specific to Cloud SQL.
29 | *
30 | * In the JVM, we need to implement 3 classes to make sure that we are capturing all the
31 | * TrustManager instances created by the Java Crypto provider so that the connector will:
32 | *
33 | *
class InstanceCheckingTrustManagerFactory extends TrustManagerFactory - has a bunch of final
34 | * methods that delegate to a TrustManagerFactorySpi.
35 | *
36 | *
class InstanceCheckingTrustManagerFactorySpi implements TrustManagerFactorySpi - can actually
37 | * intercept requests for the list of TrustManager instances and wrap them with our replacement
38 | * TrustManager.
39 | *
40 | *
class ConscryptWorkaroundTrustManager - the workaround for the Conscrypt bug.
41 | *
42 | *
class InstanceCheckingTrustManager - delegates TLS checks to the default provider and then
43 | * does custom hostname verification.
44 | */
45 | class InstanceCheckingTrustManagerFactory extends TrustManagerFactory {
46 |
47 | static InstanceCheckingTrustManagerFactory newInstance(InstanceMetadata instanceMetadata)
48 | throws NoSuchAlgorithmException, KeyStoreException, CertificateException, IOException {
49 |
50 | TrustManagerFactory delegate = TrustManagerFactory.getInstance("X.509");
51 | KeyStore trustedKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
52 | trustedKeyStore.load(null, null);
53 |
54 | // Add all the certificates in the chain of trust to the trust keystore.
55 | for (Certificate cert : instanceMetadata.getInstanceCaCertificates()) {
56 | trustedKeyStore.setCertificateEntry("ca" + cert.hashCode(), cert);
57 | }
58 |
59 | // Use a custom trust manager factory that checks the CN against the instance name
60 | // The delegate TrustManagerFactory will check the certificate chain, but will not do
61 | // hostname checking.
62 | InstanceCheckingTrustManagerFactory tmf =
63 | new InstanceCheckingTrustManagerFactory(instanceMetadata, delegate);
64 | tmf.init(trustedKeyStore);
65 |
66 | return tmf;
67 | }
68 |
69 | private InstanceCheckingTrustManagerFactory(
70 | InstanceMetadata instanceMetadata, TrustManagerFactory delegate) {
71 | super(
72 | new InstanceCheckingTrustManagerFactorySpi(instanceMetadata, delegate),
73 | delegate.getProvider(),
74 | delegate.getAlgorithm());
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/InstanceCheckingTrustManagerFactorySpi.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import java.security.InvalidAlgorithmParameterException;
20 | import java.security.KeyStore;
21 | import java.security.KeyStoreException;
22 | import javax.net.ssl.ManagerFactoryParameters;
23 | import javax.net.ssl.TrustManager;
24 | import javax.net.ssl.TrustManagerFactory;
25 | import javax.net.ssl.TrustManagerFactorySpi;
26 | import javax.net.ssl.X509ExtendedTrustManager;
27 |
28 | /**
29 | * Part of the InstanceCheckingTrustManagerFactory that implements custom CloudSQL server
30 | * certificate checks.
31 | */
32 | class InstanceCheckingTrustManagerFactorySpi extends TrustManagerFactorySpi {
33 | private final TrustManagerFactory delegate;
34 | private final InstanceMetadata instanceMetadata;
35 |
36 | InstanceCheckingTrustManagerFactorySpi(
37 | InstanceMetadata instanceMetadata, TrustManagerFactory delegate) {
38 | this.instanceMetadata = instanceMetadata;
39 | this.delegate = delegate;
40 | }
41 |
42 | @Override
43 | protected void engineInit(KeyStore ks) throws KeyStoreException {
44 | delegate.init(ks);
45 | }
46 |
47 | @Override
48 | protected void engineInit(ManagerFactoryParameters spec)
49 | throws InvalidAlgorithmParameterException {
50 | delegate.init(spec);
51 | }
52 |
53 | @Override
54 | protected TrustManager[] engineGetTrustManagers() {
55 | TrustManager[] tms = delegate.getTrustManagers();
56 | TrustManager[] delegates = new TrustManager[tms.length];
57 | for (int i = 0; i < tms.length; i++) {
58 | if (tms[i] instanceof X509ExtendedTrustManager) {
59 | X509ExtendedTrustManager tm = (X509ExtendedTrustManager) tms[i];
60 |
61 | // Note: This is a workaround for Conscrypt bug #1033
62 | // Conscrypt is the JCE provider on some Google Cloud runtimes like DataProc.
63 | // https://github.com/google/conscrypt/issues/1033
64 | if (ConscryptWorkaroundDelegatingTrustManger.isWorkaroundNeeded()) {
65 | tm = new ConscryptWorkaroundDelegatingTrustManger(tm);
66 | }
67 |
68 | delegates[i] = new InstanceCheckingTrustManger(instanceMetadata, tm);
69 | } else {
70 | delegates[i] = tms[i];
71 | }
72 | }
73 | return delegates;
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/InstanceConnectionNameResolver.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | /** Resolves the Cloud SQL Instance from the configuration name. */
20 | interface InstanceConnectionNameResolver {
21 |
22 | /**
23 | * Resolves the CloudSqlInstanceName from a configuration string value.
24 | *
25 | * @param name the configuration string
26 | * @return the CloudSqlInstanceName
27 | * @throws IllegalArgumentException if the name cannot be resolved.
28 | */
29 | CloudSqlInstanceName resolve(String name);
30 | }
31 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/InstanceMetadata.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import com.google.cloud.sql.IpType;
20 | import java.security.cert.Certificate;
21 | import java.util.List;
22 | import java.util.Map;
23 |
24 | /** Represents the results of @link #fetchMetadata(). */
25 | class InstanceMetadata {
26 |
27 | private final CloudSqlInstanceName instanceName;
28 | private final Map ipAddrs;
29 | private final List instanceCaCertificates;
30 | private final boolean casManagedCertificate;
31 | private final String dnsName;
32 | private final boolean pscEnabled;
33 |
34 | InstanceMetadata(
35 | CloudSqlInstanceName instanceName,
36 | Map ipAddrs,
37 | List instanceCaCertificates,
38 | boolean casManagedCertificate,
39 | String dnsName,
40 | boolean pscEnabled) {
41 | this.instanceName = instanceName;
42 | this.ipAddrs = ipAddrs;
43 | this.instanceCaCertificates = instanceCaCertificates;
44 | this.casManagedCertificate = casManagedCertificate;
45 | this.dnsName = dnsName;
46 | this.pscEnabled = pscEnabled;
47 | }
48 |
49 | Map getIpAddrs() {
50 | return ipAddrs;
51 | }
52 |
53 | List getInstanceCaCertificates() {
54 | return instanceCaCertificates;
55 | }
56 |
57 | public boolean isCasManagedCertificate() {
58 | return casManagedCertificate;
59 | }
60 |
61 | public String getDnsName() {
62 | return dnsName;
63 | }
64 |
65 | public boolean isPscEnabled() {
66 | return pscEnabled;
67 | }
68 |
69 | public CloudSqlInstanceName getInstanceName() {
70 | return instanceName;
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/JndiDnsResolver.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import java.util.Collection;
20 | import java.util.Collections;
21 | import java.util.Hashtable;
22 | import java.util.stream.Collectors;
23 | import javax.naming.Context;
24 | import javax.naming.NameNotFoundException;
25 | import javax.naming.NamingException;
26 | import javax.naming.directory.Attribute;
27 | import javax.naming.directory.InitialDirContext;
28 |
29 | /** Implements DnsResolver using the Java JNDI built-in DNS directory. */
30 | class JndiDnsResolver implements DnsResolver {
31 | private final String jndiPrefix;
32 |
33 | /** Creates a resolver using the system DNS settings. */
34 | JndiDnsResolver() {
35 | this.jndiPrefix = "dns:";
36 | }
37 |
38 | /**
39 | * Creates a DNS resolver that uses a specific DNS server.
40 | *
41 | * @param dnsServer the DNS server hostname
42 | * @param port the DNS server port (DNS servers usually use port 53)
43 | */
44 | JndiDnsResolver(String dnsServer, int port) {
45 | this.jndiPrefix = "dns://" + dnsServer + ":" + port + "/";
46 | }
47 |
48 | /**
49 | * Returns DNS records for a domain name, sorted alphabetically.
50 | *
51 | * @param domainName the domain name to lookup
52 | * @return the list of record
53 | * @throws javax.naming.NameNotFoundException when the domain name did not resolve.
54 | */
55 | @Override
56 | @SuppressWarnings("JdkObsolete")
57 | public Collection resolveTxt(String domainName)
58 | throws javax.naming.NameNotFoundException {
59 | try {
60 | // Notice: This is old Java 1.2 style code. It uses the ancient JNDI DNS Provider api.
61 | // See https://docs.oracle.com/javase/7/docs/technotes/guides/jndi/jndi-dns.html
62 |
63 | // Explicitly reference the JNDI DNS classes. This is required for GraalVM.
64 | Hashtable contextProps = new Hashtable<>();
65 | contextProps.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.dns.DnsContextFactory");
66 | contextProps.put(Context.OBJECT_FACTORIES, "com.sun.jndi.url.dns.dnsURLContextFactory");
67 | Attribute attr =
68 | new InitialDirContext(contextProps)
69 | .getAttributes(jndiPrefix + domainName, new String[] {"TXT"})
70 | .get("TXT");
71 | // attr.getAll() returns a Vector containing strings, one for each record returned by dns.
72 | return Collections.list(attr.getAll()).stream()
73 | .map((Object v) -> (String) v)
74 | .sorted() // sort multiple records alphabetically
75 | .collect(Collectors.toList());
76 | } catch (NameNotFoundException e) {
77 | throw e;
78 | } catch (NamingException e) {
79 | throw new RuntimeException("Unable to look up domain name " + domainName, e);
80 | }
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/LazyRefreshConnectionInfoCache.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.cloud.sql.core.RefreshCalculator.DEFAULT_REFRESH_BUFFER;
20 |
21 | import com.google.cloud.sql.CredentialFactory;
22 | import java.security.KeyPair;
23 |
24 | /**
25 | * Implements the lazy refresh cache strategy, which loads the new certificate as needed during a
26 | * request for a new connection.
27 | */
28 | class LazyRefreshConnectionInfoCache implements ConnectionInfoCache {
29 | private final ConnectionConfig config;
30 | private final CloudSqlInstanceName instanceName;
31 |
32 | private final LazyRefreshStrategy refreshStrategy;
33 |
34 | /**
35 | * Initializes a new Cloud SQL instance based on the given connection name using the lazy refresh
36 | * strategy.
37 | *
38 | * @param config instance connection name in the format "PROJECT_ID:REGION_ID:INSTANCE_ID"
39 | * @param connectionInfoRepository Service class for interacting with the Cloud SQL Admin API
40 | * @param keyPair public/private key pair used to authenticate connections
41 | */
42 | public LazyRefreshConnectionInfoCache(
43 | ConnectionConfig config,
44 | ConnectionInfoRepository connectionInfoRepository,
45 | CredentialFactory tokenSourceFactory,
46 | KeyPair keyPair) {
47 |
48 | CloudSqlInstanceName instanceName =
49 | new CloudSqlInstanceName(config.getCloudSqlInstance(), config.getDomainName());
50 |
51 | this.config = config;
52 | this.instanceName = instanceName;
53 |
54 | AccessTokenSupplier accessTokenSupplier =
55 | DefaultAccessTokenSupplier.newInstance(config.getAuthType(), tokenSourceFactory);
56 |
57 | this.refreshStrategy =
58 | new LazyRefreshStrategy(
59 | config.getCloudSqlInstance(),
60 | () ->
61 | connectionInfoRepository.getConnectionInfoSync(
62 | instanceName, accessTokenSupplier, config.getAuthType(), keyPair),
63 | DEFAULT_REFRESH_BUFFER);
64 | }
65 |
66 | @Override
67 | public ConnectionMetadata getConnectionMetadata(long timeoutMs) {
68 | return refreshStrategy.getConnectionInfo(timeoutMs).toConnectionMetadata(config, instanceName);
69 | }
70 |
71 | @Override
72 | public void forceRefresh() {
73 | refreshStrategy.forceRefresh();
74 | }
75 |
76 | @Override
77 | public void refreshIfExpired() {
78 | refreshStrategy.refreshIfExpired();
79 | }
80 |
81 | @Override
82 | public void close() {
83 | refreshStrategy.close();
84 | }
85 |
86 | @Override
87 | public boolean isClosed() {
88 | return refreshStrategy.isClosed();
89 | }
90 |
91 | @Override
92 | public ConnectionConfig getConfig() {
93 | return config;
94 | }
95 | }
96 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/RefreshCalculator.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import java.time.Duration;
20 | import java.time.Instant;
21 |
22 | /**
23 | * RefreshCalculator determines the number of seconds until the next refresh operation using the
24 | * same algorithm used by the other Connectors.
25 | */
26 | class RefreshCalculator {
27 |
28 | // defaultRefreshBuffer is the minimum amount of time for which a
29 | // certificate must be valid to ensure the next refresh attempt has adequate
30 | // time to complete.
31 | static final Duration DEFAULT_REFRESH_BUFFER = Duration.ofMinutes(4);
32 |
33 | long calculateSecondsUntilNextRefresh(Instant now, Instant expiration) {
34 | Duration timeUntilExp = Duration.between(now, expiration);
35 |
36 | if (timeUntilExp.compareTo(Duration.ofHours(1)) < 0) {
37 | if (timeUntilExp.compareTo(DEFAULT_REFRESH_BUFFER) < 0) {
38 | // If the time until the certificate expires is less the refresh buffer, schedule the
39 | // refresh immediately
40 | return 0;
41 | }
42 | // Otherwise schedule a refresh in (timeUntilExp - buffer) seconds
43 | return timeUntilExp.minus(DEFAULT_REFRESH_BUFFER).getSeconds();
44 | }
45 |
46 | // If the time until the certificate expires is longer than an hour, return timeUntilExp//2
47 | return timeUntilExp.dividedBy(2).getSeconds();
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/RefreshStrategy.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | /** Provide the refresh strategy to the DefaultConnectionInfoCache. */
20 | public interface RefreshStrategy {
21 | /** Return the current valid ConnectionInfo, blocking if necessary for up to the timeout. */
22 | ConnectionInfo getConnectionInfo(long timeoutMs);
23 |
24 | /** Force a refresh of the ConnectionInfo, possibly in the background. */
25 | void forceRefresh();
26 |
27 | /** Refresh the ConnectionInfo if it has expired or is near expiration. */
28 | void refreshIfExpired();
29 |
30 | /**
31 | * Stop background threads and refresh operations in progress and refuse to start subsequent
32 | * refresh operations.
33 | */
34 | void close();
35 |
36 | /** Returns true when the RefreshStrategy instance is closed. */
37 | boolean isClosed();
38 | }
39 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/ServiceAccountImpersonatingCredentialFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import com.google.api.client.http.HttpRequestInitializer;
20 | import com.google.api.services.sqladmin.SQLAdminScopes;
21 | import com.google.auth.http.HttpCredentialsAdapter;
22 | import com.google.auth.oauth2.GoogleCredentials;
23 | import com.google.auth.oauth2.ImpersonatedCredentials;
24 | import com.google.cloud.sql.CredentialFactory;
25 | import java.util.Arrays;
26 | import java.util.List;
27 |
28 | /**
29 | * Wraps an existing CredentialFactory to impersonate the targetPrincipal, with an optional list of
30 | * delegating service accounts in accordance with the ImpersonatedCredentials API.
31 | *
32 | * targetPrincipal – the service account to impersonate
33 | *
34 | *
delegates – the chained list of delegates required to grant the final access_token. If set,
35 | * the sequence of identities must have "Service Account Token Creator" capability granted to the
36 | * preceding identity. For example, if set to [serviceAccountB, serviceAccountC], the
37 | * sourceCredential must have the Token Creator role on serviceAccountB. serviceAccountB must have
38 | * the Token Creator on serviceAccountC. Finally, C must have Token Creator on target_principal. If
39 | * unset, sourceCredential must have that role on targetPrincipal.
40 | *
41 | * @see com.google.auth.oauth2.ImpersonatedCredentials
42 | */
43 | class ServiceAccountImpersonatingCredentialFactory implements CredentialFactory {
44 |
45 | private final CredentialFactory source;
46 | private final List delegates;
47 | private final String targetPrincipal;
48 |
49 | /**
50 | * Creates a new ServiceAccountImpersonatingCredentialFactory.
51 | *
52 | * @param source the source of the original credentials, before they are impersonated.
53 | * @param targetPrincipal The target principal in the form of a service account, must not be null.
54 | * @param delegates The optional list of delegate service accounts, may be null or empty.
55 | */
56 | ServiceAccountImpersonatingCredentialFactory(
57 | CredentialFactory source, String targetPrincipal, List delegates) {
58 | if (targetPrincipal == null || targetPrincipal.isEmpty()) {
59 | throw new IllegalArgumentException("targetPrincipal must not be empty");
60 | }
61 | this.source = source;
62 | this.delegates = delegates;
63 | this.targetPrincipal = targetPrincipal;
64 | }
65 |
66 | @Override
67 | public HttpRequestInitializer create() {
68 | GoogleCredentials credentials = getCredentials();
69 | return new HttpCredentialsAdapter(credentials);
70 | }
71 |
72 | @Override
73 | public GoogleCredentials getCredentials() {
74 | GoogleCredentials credentials = source.getCredentials();
75 |
76 | credentials =
77 | ImpersonatedCredentials.newBuilder()
78 | .setSourceCredentials(credentials)
79 | .setTargetPrincipal(targetPrincipal)
80 | .setDelegates(this.delegates)
81 | .setScopes(
82 | Arrays.asList(SQLAdminScopes.SQLSERVICE_ADMIN, SQLAdminScopes.CLOUD_PLATFORM))
83 | .build();
84 | return credentials;
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/SslData.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2021 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import javax.net.ssl.KeyManagerFactory;
20 | import javax.net.ssl.SSLContext;
21 | import javax.net.ssl.TrustManagerFactory;
22 |
23 | /** This class stores data that can be used to establish Cloud SQL SSL connection. */
24 | class SslData {
25 |
26 | private final SSLContext sslContext;
27 | private final KeyManagerFactory keyManagerFactory;
28 | private final TrustManagerFactory trustManagerFactory;
29 |
30 | SslData(
31 | SSLContext sslContext,
32 | KeyManagerFactory keyManagerFactory,
33 | TrustManagerFactory trustManagerFactory) {
34 | this.sslContext = sslContext;
35 | this.keyManagerFactory = keyManagerFactory;
36 | this.trustManagerFactory = trustManagerFactory;
37 | }
38 |
39 | SSLContext getSslContext() {
40 | return sslContext;
41 | }
42 |
43 | KeyManagerFactory getKeyManagerFactory() {
44 | return keyManagerFactory;
45 | }
46 |
47 | TrustManagerFactory getTrustManagerFactory() {
48 | return trustManagerFactory;
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/SupplierCredentialFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import com.google.api.client.http.HttpRequestInitializer;
20 | import com.google.auth.http.HttpCredentialsAdapter;
21 | import com.google.auth.oauth2.GoogleCredentials;
22 | import com.google.cloud.sql.CredentialFactory;
23 | import java.util.function.Supplier;
24 |
25 | class SupplierCredentialFactory implements CredentialFactory {
26 |
27 | private final Supplier supplier;
28 |
29 | public SupplierCredentialFactory(Supplier supplier) {
30 | this.supplier = supplier;
31 | }
32 |
33 | @Override
34 | public HttpRequestInitializer create() {
35 | return new HttpCredentialsAdapter(getCredentials());
36 | }
37 |
38 | @Override
39 | public GoogleCredentials getCredentials() {
40 | return supplier.get();
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/TerminalException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | class TerminalException extends RuntimeException {
20 | public TerminalException() {
21 | super();
22 | }
23 |
24 | public TerminalException(String message) {
25 | super(message);
26 | }
27 |
28 | public TerminalException(String message, Throwable cause) {
29 | super(message, cause);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/core/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | /**
18 | * WARNING: This package does not contain any stable, public Java API. The class definitions may
19 | * change without notice.
20 | *
21 | * Package com.google.cloud.sql.core holds internal shared packages that implement logic to
22 | * create a socket to a Cloud SQL database.
23 | */
24 | package com.google.cloud.sql.core;
25 |
--------------------------------------------------------------------------------
/core/src/main/java/com/google/cloud/sql/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | /**
18 | * Package com.google.cloud.sql holds the stable public java API for creating sockets to Cloud SQL
19 | * database.
20 | */
21 | package com.google.cloud.sql;
22 |
--------------------------------------------------------------------------------
/core/src/main/resources/META-INF/native-image/com.google.cloud.sql/cloud-sql-jdbc-socket-factory-parent/jni-unix-socket-config.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "name": "jnr.ffi.provider.LoadedLibrary"
4 | },
5 | {
6 | "name": "jnr.unixsocket.Native$LibC",
7 | "interfaces": [
8 | "jnr.unixsocket.Native$LibC",
9 | "jnr.ffi.provider.LoadedLibrary"
10 | ]
11 | },
12 | {
13 | "name": "jnr.enxio.channels.Native$LibC",
14 | "interfaces": [
15 | "jnr.enxio.channels.Native$LibC",
16 | "jnr.ffi.provider.LoadedLibrary"
17 | ]
18 | }
19 | ]
20 |
--------------------------------------------------------------------------------
/core/src/main/resources/META-INF/native-image/com.google.cloud.sql/cloud-sql-jdbc-socket-factory-parent/native-image.properties:
--------------------------------------------------------------------------------
1 | Args =\
2 | -H:+AddAllCharsets \
3 | -H:ReflectionConfigurationResources=META-INF/native-image/com.google.cloud.sql/cloud-sql-jdbc-socket-factory-parent/jni-unix-socket-config.json \
4 | -H:ResourceConfigurationResources=META-INF/native-image/com.google.cloud.sql/cloud-sql-jdbc-socket-factory-parent/resource-config.json \
5 | -H:DynamicProxyConfigurationResources=META-INF/native-image/com.google.cloud.sql/cloud-sql-jdbc-socket-factory-parent/proxy-config.json \
6 | --features=com.google.cloud.sql.nativeimage.CloudSqlFeature
7 |
--------------------------------------------------------------------------------
/core/src/main/resources/META-INF/native-image/com.google.cloud.sql/cloud-sql-jdbc-socket-factory-parent/proxy-config.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "condition": {
4 | "typeReachable": "jnr.unixsocket.Native$LibC"
5 | },
6 | "name": "jnr.unixsocket.Native$LibC",
7 | "interfaces": [
8 | "jnr.unixsocket.Native$LibC",
9 | "jnr.ffi.provider.LoadedLibrary"
10 | ]
11 | },
12 | {
13 | "condition": {
14 | "typeReachable":"jnr.enxio.channels.Native$LibC"
15 | },
16 | "name": "jnr.enxio.channels.Native$LibC",
17 | "interfaces": [
18 | "jnr.enxio.channels.Native$LibC",
19 | "jnr.ffi.provider.LoadedLibrary"
20 | ]
21 | },
22 | {
23 | "name": "com.sun.jndi.dns.DnsContextFactory",
24 | "interfaces": [
25 | "javax.naming.spi.InitialContextFactory"
26 | ]
27 | },
28 | {
29 | "name": "com.sun.jndi.url.dns.dnsURLContextFactory",
30 | "interfaces": [
31 | "javax.naming.spi.ObjectFactory"
32 | ]
33 | }
34 | ]
35 |
--------------------------------------------------------------------------------
/core/src/main/resources/META-INF/native-image/com.google.cloud.sql/cloud-sql-jdbc-socket-factory-parent/resource-config.json:
--------------------------------------------------------------------------------
1 | {
2 | "resources":[
3 | {"pattern":"\\Qcom.google.cloud.sql/project.properties\\E"},
4 | {"pattern":"\\QMETA-INF/services/java.sql.Driver\\E"},
5 | {"pattern":"\\Qcom/mysql/cj/util/TimeZoneMapping.properties\\E"},
6 | {"pattern":"jni/.*\\.so"},
7 | {"pattern":"jni/.*\\.dll"}
8 | ],
9 | "bundles": [
10 | {"name":"com.mysql.cj.LocalizedErrorMessages"},
11 | {"name":"com.mysql.jdbc.LocalizedErrorMessages"}
12 | ]
13 | }
14 |
--------------------------------------------------------------------------------
/core/src/main/resources/com.google.cloud.sql/project.properties:
--------------------------------------------------------------------------------
1 | version=${project.version}
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/ApiClientRetryingCallableTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 |
21 | import com.google.api.client.http.HttpHeaders;
22 | import com.google.api.client.http.HttpResponseException;
23 | import java.util.concurrent.atomic.AtomicInteger;
24 | import org.junit.Assert;
25 | import org.junit.Test;
26 | import org.junit.runner.RunWith;
27 | import org.junit.runners.JUnit4;
28 |
29 | @RunWith(JUnit4.class)
30 | public class ApiClientRetryingCallableTest {
31 | @Test
32 | public void testApiClientRetriesOn500ErrorAndSucceeds() throws Exception {
33 | AtomicInteger counter = new AtomicInteger(0);
34 | ApiClientRetryingCallable c =
35 | new ApiClientRetryingCallable<>(
36 | () -> {
37 | int attempt = counter.incrementAndGet();
38 | if (attempt < 3) {
39 | throw new HttpResponseException.Builder(
40 | 503, "service unavailable", new HttpHeaders())
41 | .build();
42 | }
43 | return attempt;
44 | });
45 |
46 | Integer v = c.call();
47 | assertThat(counter.get()).isEqualTo(3);
48 | assertThat(v).isEqualTo(3);
49 | }
50 |
51 | @Test
52 | public void testApiClientRetriesOn500ErrorAndFailsAfter5Attempts() throws Exception {
53 | AtomicInteger counter = new AtomicInteger(0);
54 | ApiClientRetryingCallable c =
55 | new ApiClientRetryingCallable<>(
56 | () -> {
57 | counter.incrementAndGet();
58 | throw new HttpResponseException.Builder(503, "service unavailable", new HttpHeaders())
59 | .build();
60 | });
61 |
62 | try {
63 | c.call();
64 | Assert.fail("got no exception, wants an exception to be thrown");
65 | } catch (Exception e) {
66 | // Expected to throw an exception
67 | }
68 | assertThat(counter.get()).isEqualTo(5);
69 | }
70 |
71 | @Test
72 | public void testRetryStopsAfterFatalException() throws Exception {
73 | final AtomicInteger counter = new AtomicInteger();
74 | RetryingCallable r =
75 | new RetryingCallable(
76 | () -> {
77 | counter.incrementAndGet();
78 | throw new Exception("nope");
79 | }) {
80 | @Override
81 | protected boolean isFatalException(Exception e) {
82 | return true;
83 | }
84 | };
85 |
86 | try {
87 | r.call();
88 | Assert.fail("got no exception, wants an exception to be thrown");
89 | } catch (Exception e) {
90 | // Expected to throw an exception
91 | }
92 | assertThat(counter.get()).isEqualTo(1);
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/BadConnectionFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import com.google.api.client.http.HttpTransport;
20 | import com.google.api.client.http.LowLevelHttpRequest;
21 | import com.google.api.client.http.LowLevelHttpResponse;
22 | import java.io.IOException;
23 | import java.net.SocketTimeoutException;
24 |
25 | public class BadConnectionFactory extends HttpTransport {
26 |
27 | @Override
28 | protected LowLevelHttpRequest buildRequest(String method, String url) throws IOException {
29 | return new FailToConnectRequest();
30 | }
31 |
32 | private static class FailToConnectRequest extends LowLevelHttpRequest {
33 |
34 | @Override
35 | public void addHeader(String name, String value) throws IOException {
36 | // do nothing.
37 | }
38 |
39 | @Override
40 | public LowLevelHttpResponse execute() throws IOException {
41 | try {
42 | Thread.sleep(100);
43 | } catch (InterruptedException e) {
44 | // Ignore the interruption
45 | }
46 | throw new SocketTimeoutException("Fake connect timeout");
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/CloudSqlInstanceNameTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static org.junit.Assert.assertThrows;
21 |
22 | import org.junit.Assert;
23 | import org.junit.Test;
24 | import org.junit.runner.RunWith;
25 | import org.junit.runners.JUnit4;
26 |
27 | @RunWith(JUnit4.class)
28 | public class CloudSqlInstanceNameTest {
29 |
30 | @Test
31 | public void parseStandardConnectionName() {
32 | String connectionName = "my-project:my-region:my-instance";
33 |
34 | CloudSqlInstanceName instanceName = new CloudSqlInstanceName(connectionName);
35 |
36 | Assert.assertEquals(connectionName, instanceName.getConnectionName());
37 | Assert.assertEquals("my-project", instanceName.getProjectId());
38 | Assert.assertEquals("my-region", instanceName.getRegionId());
39 | Assert.assertEquals("my-instance", instanceName.getInstanceId());
40 | }
41 |
42 | @Test
43 | public void parseLegacyConnectionName() {
44 | String connectionName = "google.com:my-project:my-region:my-instance";
45 |
46 | CloudSqlInstanceName instanceName = new CloudSqlInstanceName(connectionName);
47 |
48 | Assert.assertEquals(instanceName.getConnectionName(), connectionName);
49 | Assert.assertEquals("google.com:my-project", instanceName.getProjectId());
50 | Assert.assertEquals("my-region", instanceName.getRegionId());
51 | Assert.assertEquals("my-instance", instanceName.getInstanceId());
52 | }
53 |
54 | @Test
55 | public void parseBadConnectionName() {
56 | IllegalArgumentException ex =
57 | assertThrows(
58 | IllegalArgumentException.class,
59 | () -> new CloudSqlInstanceName("my-project:my-instance"));
60 |
61 | assertThat(ex).hasMessageThat().contains("Cloud SQL connection name is invalid");
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/ConstantCredentialsFactoryTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 |
21 | import com.google.auth.oauth2.GoogleCredentials;
22 | import org.junit.Test;
23 | import org.junit.runner.RunWith;
24 | import org.junit.runners.JUnit4;
25 |
26 | @RunWith(JUnit4.class)
27 | public class ConstantCredentialsFactoryTest {
28 |
29 | @Test
30 | public void testConstantCredentials() {
31 | GoogleCredentials c = GoogleCredentials.create(null);
32 | ConstantCredentialFactory f = new ConstantCredentialFactory(c);
33 | assertThat(f.getCredentials()).isSameInstanceAs(c);
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/DefaultConnectionInfoRepositoryIntegrationTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static com.google.common.truth.Truth.assertWithMessage;
21 |
22 | import com.google.cloud.sql.ConnectorConfig;
23 | import com.google.cloud.sql.CredentialFactory;
24 | import com.google.common.collect.ImmutableList;
25 | import java.util.concurrent.TimeUnit;
26 | import org.junit.BeforeClass;
27 | import org.junit.Rule;
28 | import org.junit.Test;
29 | import org.junit.rules.Timeout;
30 | import org.junit.runner.RunWith;
31 | import org.junit.runners.JUnit4;
32 |
33 | @RunWith(JUnit4.class)
34 | public class DefaultConnectionInfoRepositoryIntegrationTests {
35 | private static final String QUOTA_PROJECT = System.getenv("QUOTA_PROJECT");
36 | private static final String CONNECTION_NAME = System.getenv("MYSQL_CONNECTION_NAME");
37 |
38 | private static final ImmutableList requiredEnvVars =
39 | ImmutableList.of("QUOTA_PROJECT", "MYSQL_CONNECTION_NAME");
40 | @Rule public Timeout globalTimeout = new Timeout(80, TimeUnit.SECONDS);
41 |
42 | @BeforeClass
43 | public static void checkEnvVars() {
44 | // Check that required env vars are set
45 | requiredEnvVars.forEach(
46 | (varName) ->
47 | assertWithMessage(
48 | String.format(
49 | "Environment variable '%s' must be set to perform these tests.", varName))
50 | .that(System.getenv(varName))
51 | .isNotEmpty());
52 | }
53 |
54 | @Test
55 | public void testQuotaProjectIsSetOnAdminApiRequest() {
56 | ConnectorConfig config =
57 | new ConnectorConfig.Builder().withAdminQuotaProject(QUOTA_PROJECT).build();
58 |
59 | CredentialFactoryProvider credentialFactoryProvider = new CredentialFactoryProvider();
60 | CredentialFactory instanceCredentialFactory =
61 | credentialFactoryProvider.getInstanceCredentialFactory(config);
62 | DefaultConnectionInfoRepository repo =
63 | new DefaultConnectionInfoRepositoryFactory("cloud-sql-connector-connector-core")
64 | .create(instanceCredentialFactory.create(), config);
65 |
66 | assertThat(repo.getQuotaProject(CONNECTION_NAME)).isEqualTo(QUOTA_PROJECT);
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/FileCredentialFactoryTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static org.junit.Assert.*;
21 |
22 | import com.google.auth.oauth2.GoogleCredentials;
23 | import org.junit.Test;
24 | import org.junit.runner.RunWith;
25 | import org.junit.runners.JUnit4;
26 |
27 | @RunWith(JUnit4.class)
28 | public class FileCredentialFactoryTest {
29 |
30 | @Test
31 | public void getCredentials_failsWhenNoFileExists() {
32 | FileCredentialFactory f = new FileCredentialFactory("nope");
33 | assertThrows(IllegalStateException.class, f::getCredentials);
34 | }
35 |
36 | @Test
37 | public void getCredentials_loadsFromFilePath() {
38 | String path = FileCredentialFactoryTest.class.getResource("/sample-credentials.json").getFile();
39 | FileCredentialFactory f = new FileCredentialFactory(path);
40 | GoogleCredentials c = f.getCredentials();
41 | assertThat(c.getQuotaProjectId()).isEqualTo("sample");
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/LazyRefreshConnectionInfoCacheTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.google.cloud.sql.core;
17 |
18 | import static com.google.common.truth.Truth.assertThat;
19 |
20 | import com.google.common.util.concurrent.Futures;
21 | import com.google.common.util.concurrent.ListenableFuture;
22 | import java.security.KeyPair;
23 | import java.util.concurrent.ExecutionException;
24 | import org.junit.Before;
25 | import org.junit.Test;
26 | import org.junit.runner.RunWith;
27 | import org.junit.runners.JUnit4;
28 |
29 | @RunWith(JUnit4.class)
30 | public class LazyRefreshConnectionInfoCacheTest {
31 | private ListenableFuture keyPairFuture;
32 | private final StubCredentialFactory stubCredentialFactory =
33 | new StubCredentialFactory("my-token", System.currentTimeMillis() + 3600L);
34 |
35 | @Before
36 | public void setup() throws Exception {
37 | MockAdminApi mockAdminApi = new MockAdminApi();
38 | this.keyPairFuture = Futures.immediateFuture(mockAdminApi.getClientKeyPair());
39 | }
40 |
41 | @Test
42 | public void testCloudSqlInstanceDataLazyStrategyRetrievedSuccessfully()
43 | throws ExecutionException, InterruptedException {
44 | KeyPair kp = keyPairFuture.get();
45 | TestDataSupplier instanceDataSupplier = new TestDataSupplier(false);
46 |
47 | // initialize connectionInfoCache after mocks are set up
48 | LazyRefreshConnectionInfoCache connectionInfoCache =
49 | new LazyRefreshConnectionInfoCache(
50 | new ConnectionConfig.Builder().withCloudSqlInstance("project:region:instance").build(),
51 | instanceDataSupplier,
52 | stubCredentialFactory,
53 | kp);
54 |
55 | ConnectionMetadata gotMetadata = connectionInfoCache.getConnectionMetadata(300);
56 | ConnectionMetadata gotMetadata2 = connectionInfoCache.getConnectionMetadata(300);
57 |
58 | // Assert that the underlying ConnectionInfo was retrieved exactly once.
59 | assertThat(instanceDataSupplier.counter.get()).isEqualTo(1);
60 |
61 | // Assert that the ConnectionInfo fields are added to ConnectionMetadata
62 | assertThat(gotMetadata.getKeyManagerFactory())
63 | .isSameInstanceAs(instanceDataSupplier.response.getSslData().getKeyManagerFactory());
64 | assertThat(gotMetadata.getKeyManagerFactory())
65 | .isSameInstanceAs(gotMetadata2.getKeyManagerFactory());
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/RefreshCalculatorTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.google.cloud.sql.core;
17 |
18 | import static com.google.common.truth.Truth.assertThat;
19 | import static java.time.temporal.ChronoUnit.SECONDS;
20 |
21 | import java.time.Duration;
22 | import java.time.Instant;
23 | import java.util.Arrays;
24 | import java.util.Collection;
25 | import org.junit.Test;
26 | import org.junit.runner.RunWith;
27 | import org.junit.runners.Parameterized;
28 | import org.junit.runners.Parameterized.Parameters;
29 |
30 | @RunWith(Parameterized.class)
31 | public class RefreshCalculatorTest {
32 |
33 | private final Duration input;
34 | private final Duration want;
35 |
36 | @Parameters(name = "Test {0}: calculateSecondsUntilNextRefresh({1})={2}")
37 | public static Collection data() {
38 | return Arrays.asList(
39 | new Object[][] {
40 | {"when expiration is greater than 1 hour", Duration.ofHours(4), Duration.ofHours(2)},
41 | {"when expiration is equal to 1 hour", Duration.ofHours(1), Duration.ofMinutes(30)},
42 | {
43 | "when expiration is less than 1 hour, but greater than 4 minutes",
44 | Duration.ofMinutes(5),
45 | Duration.ofMinutes(1)
46 | },
47 | {"when expiration is less than 4 minutes", Duration.ofMinutes(3), Duration.ofMinutes(0)},
48 | {"when expiration is now", Duration.ofMinutes(0), Duration.ofMinutes(0)},
49 | {"when expiration is 62 minutes", Duration.ofMinutes(62), Duration.ofMinutes(31)},
50 | {"when expiration is 58 minutes", Duration.ofMinutes(58), Duration.ofMinutes(54)},
51 | });
52 | }
53 |
54 | public RefreshCalculatorTest(String name, Duration input, Duration want) {
55 | this.input = input;
56 | this.want = want;
57 | this.refreshCalculator = new RefreshCalculator();
58 | }
59 |
60 | private static final Instant NOW = Instant.now().truncatedTo(SECONDS);
61 | private final RefreshCalculator refreshCalculator;
62 |
63 | @Test
64 | public void testDuration() {
65 | Duration nextRefresh =
66 | Duration.ofSeconds(
67 | refreshCalculator.calculateSecondsUntilNextRefresh(NOW, NOW.plus(input)));
68 | assertThat(nextRefresh).isEqualTo(want);
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/RetryingCallableTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 |
21 | import java.util.concurrent.atomic.AtomicInteger;
22 | import org.junit.Assert;
23 | import org.junit.Test;
24 | import org.junit.runner.RunWith;
25 | import org.junit.runners.JUnit4;
26 |
27 | @RunWith(JUnit4.class)
28 | public class RetryingCallableTest {
29 | @Test
30 | public void testConstructorIllegalArguments() throws Exception {
31 | // Callable must not be null
32 | Assert.assertThrows(IllegalArgumentException.class, () -> new RetryingCallable<>(null));
33 | }
34 |
35 | @Test
36 | public void testNoRetryRequired() throws Exception {
37 | RetryingCallable r = new RetryingCallable<>(() -> 1);
38 | int v = r.call();
39 | assertThat(v).isEqualTo(1);
40 | }
41 |
42 | @Test
43 | public void testAlwaysFails() {
44 | final AtomicInteger counter = new AtomicInteger();
45 | RetryingCallable r =
46 | new RetryingCallable<>(
47 | () -> {
48 | counter.incrementAndGet();
49 | throw new Exception("nope");
50 | });
51 |
52 | try {
53 | r.call();
54 | Assert.fail("got no exception, wants an exception to be thrown");
55 | } catch (Exception e) {
56 | // Expected to throw an exception
57 | }
58 |
59 | assertThat(counter.get()).isEqualTo(5);
60 | }
61 |
62 | @Test
63 | public void testRetrySucceedsAfterFailures() throws Exception {
64 | final AtomicInteger counter = new AtomicInteger();
65 | RetryingCallable r =
66 | new RetryingCallable<>(
67 | () -> {
68 | int i = counter.incrementAndGet();
69 | if (i < 3) {
70 | throw new Exception("nope");
71 | }
72 | return i;
73 | });
74 |
75 | int v = r.call();
76 | assertThat(counter.get()).isEqualTo(3);
77 | assertThat(v).isEqualTo(3);
78 | }
79 |
80 | @Test
81 | public void testRetryStopsAfterFatalException() throws Exception {
82 | final AtomicInteger counter = new AtomicInteger();
83 | RetryingCallable r =
84 | new RetryingCallable(
85 | () -> {
86 | int i = counter.incrementAndGet();
87 | if (i < 3) {
88 | throw new Exception("nope");
89 | }
90 | return i;
91 | }) {
92 | @Override
93 | protected boolean isFatalException(Exception e) {
94 | return true;
95 | }
96 | };
97 |
98 | try {
99 | r.call();
100 | Assert.fail("got no exception, wants an exception to be thrown");
101 | } catch (Exception e) {
102 | // Expected to throw an exception
103 | }
104 | assertThat(counter.get()).isEqualTo(1);
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/StubConnectionInfoRepository.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import com.google.cloud.sql.AuthType;
20 | import com.google.cloud.sql.IpType;
21 | import com.google.common.util.concurrent.Futures;
22 | import com.google.common.util.concurrent.ListenableFuture;
23 | import com.google.common.util.concurrent.ListeningScheduledExecutorService;
24 | import java.security.KeyPair;
25 | import java.security.NoSuchAlgorithmException;
26 | import java.time.Instant;
27 | import java.time.temporal.ChronoUnit;
28 | import java.util.Collections;
29 | import java.util.Map;
30 | import java.util.concurrent.atomic.AtomicInteger;
31 | import javax.net.ssl.KeyManagerFactory;
32 |
33 | class StubConnectionInfoRepository implements ConnectionInfoRepository {
34 | private final AtomicInteger refreshCount = new AtomicInteger();
35 |
36 | int getRefreshCount() {
37 | return refreshCount.get();
38 | }
39 |
40 | private ConnectionInfo newConnectionInfo() {
41 | Map ips = Collections.singletonMap(IpType.PUBLIC, "10.1.1.1");
42 | try {
43 | return new ConnectionInfo(
44 | new InstanceMetadata(
45 | new CloudSqlInstanceName("project:region:instance"), ips, null, false, "", false),
46 | new SslData(
47 | null, KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()), null),
48 | Instant.now().plus(1, ChronoUnit.HOURS));
49 | } catch (NoSuchAlgorithmException e) {
50 | throw new RuntimeException(e);
51 | }
52 | }
53 |
54 | @Override
55 | public ListenableFuture getConnectionInfo(
56 | CloudSqlInstanceName instanceName,
57 | AccessTokenSupplier accessTokenSupplier,
58 | AuthType authType,
59 | ListeningScheduledExecutorService executor,
60 | ListenableFuture keyPair) {
61 | refreshCount.incrementAndGet();
62 | ConnectionInfo connectionInfo = newConnectionInfo();
63 | return Futures.immediateFuture(connectionInfo);
64 | }
65 |
66 | @Override
67 | public ConnectionInfo getConnectionInfoSync(
68 | CloudSqlInstanceName instanceName,
69 | AccessTokenSupplier accessTokenSupplier,
70 | AuthType authType,
71 | KeyPair keyPair) {
72 | refreshCount.incrementAndGet();
73 | return newConnectionInfo();
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/StubConnectionInfoRepositoryFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import com.google.api.client.googleapis.services.CommonGoogleClientRequestInitializer;
20 | import com.google.api.client.googleapis.services.GoogleClientRequestInitializer;
21 | import com.google.api.client.http.HttpRequestInitializer;
22 | import com.google.api.client.http.HttpTransport;
23 | import com.google.api.client.json.gson.GsonFactory;
24 | import com.google.api.client.testing.http.MockHttpTransport;
25 | import com.google.api.services.sqladmin.SQLAdmin;
26 | import com.google.cloud.sql.ConnectorConfig;
27 |
28 | public class StubConnectionInfoRepositoryFactory implements ConnectionInfoRepositoryFactory {
29 |
30 | HttpTransport httpTransport;
31 | ConnectionInfoRepository connectionInfoRepository;
32 |
33 | StubConnectionInfoRepositoryFactory(HttpTransport transport) {
34 | this.httpTransport = transport;
35 | }
36 |
37 | StubConnectionInfoRepositoryFactory(ConnectionInfoRepository connectionInfoRepository) {
38 | this.connectionInfoRepository = connectionInfoRepository;
39 | }
40 |
41 | @Override
42 | public ConnectionInfoRepository create(
43 | HttpRequestInitializer credentials, ConnectorConfig config) {
44 | if (connectionInfoRepository != null) {
45 | return connectionInfoRepository;
46 | }
47 |
48 | SQLAdmin.Builder adminApiBuilder =
49 | new SQLAdmin.Builder(
50 | httpTransport != null ? httpTransport : new MockHttpTransport(),
51 | GsonFactory.getDefaultInstance(),
52 | credentials)
53 | .setApplicationName("Mock SQL Admin");
54 |
55 | if (config.getAdminRootUrl() != null) {
56 | adminApiBuilder.setRootUrl(config.getAdminRootUrl());
57 | }
58 | if (config.getAdminServicePath() != null) {
59 | adminApiBuilder.setServicePath(config.getAdminServicePath());
60 | }
61 | if (config.getAdminQuotaProject() != null) {
62 | GoogleClientRequestInitializer clientRequestInitializer =
63 | CommonGoogleClientRequestInitializer.newBuilder()
64 | .setUserProject(config.getAdminQuotaProject())
65 | .build();
66 | adminApiBuilder.setGoogleClientRequestInitializer(clientRequestInitializer);
67 | }
68 | return new DefaultConnectionInfoRepository(adminApiBuilder.build());
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/core/src/test/java/com/google/cloud/sql/core/SupplierCredentialFactoryTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 |
21 | import com.google.auth.oauth2.GoogleCredentials;
22 | import org.junit.Test;
23 | import org.junit.runner.RunWith;
24 | import org.junit.runners.JUnit4;
25 |
26 | @RunWith(JUnit4.class)
27 | public class SupplierCredentialFactoryTest {
28 |
29 | @Test
30 | public void getCredentials() {
31 | GoogleCredentials c = GoogleCredentials.create(null);
32 | SupplierCredentialFactory f = new SupplierCredentialFactory(() -> c);
33 | assertThat(f.getCredentials()).isSameInstanceAs(c);
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/core/src/test/resources/logback.xml:
--------------------------------------------------------------------------------
1 |
16 |
17 |
18 |
19 | %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/core/src/test/resources/sample-credentials.json:
--------------------------------------------------------------------------------
1 | {
2 | "client_id": "sample.apps.googleusercontent.com",
3 | "client_secret": "sample",
4 | "quota_project_id": "sample",
5 | "refresh_token": "sample",
6 | "access_token": "sample",
7 | "type": "authorized_user",
8 | "universe_domain": "googleapis.com"
9 | }
10 |
--------------------------------------------------------------------------------
/java.header:
--------------------------------------------------------------------------------
1 | ^/\*$
2 | ^ \* Copyright \d\d\d\d,? Google (Inc\.|LLC)$
3 | ^ \*$
4 | ^ \* Licensed under the Apache License, Version 2\.0 \(the "License"\);$
5 | ^ \* you may not use this file except in compliance with the License\.$
6 | ^ \* You may obtain a copy of the License at$
7 | ^ \*$
8 | ^ \*[ ]+https?://www.apache.org/licenses/LICENSE-2\.0$
9 | ^ \*$
10 | ^ \* Unless required by applicable law or agreed to in writing, software$
11 | ^ \* distributed under the License is distributed on an "AS IS" BASIS,$
12 | ^ \* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied\.$
13 | ^ \* See the License for the specific language governing permissions and$
14 | ^ \* limitations under the License\.$
15 | ^ \*/$
16 |
--------------------------------------------------------------------------------
/jdbc/mariadb/src/main/java/com/google/cloud/sql/mariadb/SocketFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2023 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.mariadb;
18 |
19 | import com.google.cloud.sql.core.ConnectionConfig;
20 | import com.google.cloud.sql.core.InternalConnectorRegistry;
21 | import java.io.IOException;
22 | import java.net.InetAddress;
23 | import java.net.Socket;
24 | import org.mariadb.jdbc.Configuration;
25 | import org.mariadb.jdbc.util.ConfigurableSocketFactory;
26 |
27 | /**
28 | * A MariaDB {@link SocketFactory} that establishes a secure connection to a Cloud SQL instance
29 | * using ephemeral certificates.
30 | *
31 | * The heavy lifting is done by the singleton {@link InternalConnectorRegistry} class.
32 | */
33 | public class SocketFactory extends ConfigurableSocketFactory {
34 |
35 | static {
36 | InternalConnectorRegistry.addArtifactId("mariadb-socket-factory");
37 | }
38 |
39 | private Configuration conf;
40 | private String host;
41 |
42 | /** Instantiate a socket factory. */
43 | public SocketFactory() {}
44 |
45 | @Override
46 | public void setConfiguration(Configuration conf, String host) {
47 | // Ignore the hostname
48 | this.conf = conf;
49 | this.host = host;
50 | }
51 |
52 | @Override
53 | public Socket createSocket() throws IOException {
54 | try {
55 | return InternalConnectorRegistry.getInstance()
56 | .connect(ConnectionConfig.fromConnectionProperties(conf.nonMappedOptions(), host));
57 | } catch (InterruptedException e) {
58 | throw new RuntimeException(e);
59 | }
60 | }
61 |
62 | @Override
63 | public Socket createSocket(String s, int i) {
64 | throw new UnsupportedOperationException();
65 | }
66 |
67 | @Override
68 | public Socket createSocket(String s, int i, InetAddress inetAddress, int i1) {
69 | throw new UnsupportedOperationException();
70 | }
71 |
72 | @Override
73 | public Socket createSocket(InetAddress inetAddress, int i) {
74 | throw new UnsupportedOperationException();
75 | }
76 |
77 | @Override
78 | public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddress1, int i1) {
79 | throw new UnsupportedOperationException();
80 | }
81 | }
82 |
--------------------------------------------------------------------------------
/jdbc/mysql-j-8/src/main/java/com/google/cloud/sql/mysql/SocketFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2018 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.mysql;
18 |
19 | import com.google.cloud.sql.core.ConnectionConfig;
20 | import com.google.cloud.sql.core.InternalConnectorRegistry;
21 | import com.mysql.cj.conf.PropertySet;
22 | import com.mysql.cj.protocol.ServerSession;
23 | import com.mysql.cj.protocol.SocketConnection;
24 | import java.io.Closeable;
25 | import java.io.IOException;
26 | import java.util.Properties;
27 |
28 | /**
29 | * A MySQL {@link SocketFactory} that establishes a secure connection to a Cloud SQL instance using
30 | * ephemeral certificates.
31 | *
32 | *
The heavy lifting is done by the singleton {@link InternalConnectorRegistry} class.
33 | */
34 | public class SocketFactory implements com.mysql.cj.protocol.SocketFactory {
35 |
36 | static {
37 | InternalConnectorRegistry.addArtifactId("mysql-socket-factory-connector-j-8");
38 | }
39 |
40 | @Override
41 | @SuppressWarnings("TypeParameterUnusedInFormals")
42 | public T connect(
43 | String host, int portNumber, PropertySet props, int loginTimeout) throws IOException {
44 | try {
45 | return connect(host, portNumber, props.exposeAsProperties(), loginTimeout);
46 | } catch (InterruptedException e) {
47 | throw new RuntimeException(e);
48 | }
49 | }
50 |
51 | /**
52 | * Implements the interface for com.mysql.cj.protocol.SocketFactory for mysql-connector-java prior
53 | * to version 8.0.13. This change is required for backwards compatibility.
54 | */
55 | @SuppressWarnings("TypeParameterUnusedInFormals")
56 | public T connect(
57 | String host, int portNumber, Properties props, int loginTimeout)
58 | throws IOException, InterruptedException {
59 | @SuppressWarnings("unchecked")
60 | T socket =
61 | (T)
62 | InternalConnectorRegistry.getInstance()
63 | .connect(ConnectionConfig.fromConnectionProperties(props, host));
64 | return socket;
65 | }
66 |
67 | // Cloud SQL sockets always use TLS and the socket returned by connect above is already TLS-ready.
68 | // It is fine to implement these as no-ops.
69 | @Override
70 | public void beforeHandshake() {}
71 |
72 | @Override
73 | @SuppressWarnings("TypeParameterUnusedInFormals")
74 | public T performTlsHandshake(
75 | SocketConnection socketConnection, ServerSession serverSession) throws IOException {
76 | @SuppressWarnings("unchecked")
77 | T socket = (T) socketConnection.getMysqlSocket();
78 | return socket;
79 | }
80 |
81 | @Override
82 | public void afterHandshake() {}
83 | }
84 |
--------------------------------------------------------------------------------
/license-checks.xml:
--------------------------------------------------------------------------------
1 |
2 |
17 |
18 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/owlbot.py:
--------------------------------------------------------------------------------
1 | # Copyright 2023 Google LLC
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 |
15 | """This script is used to synthesize generated parts of this library."""
16 |
17 | import synthtool.languages.java as java
18 |
19 | java.common_templates(excludes=[
20 | "README.md",
21 | "CONTRIBUTING.md",
22 | ".github/auto-label.yaml",
23 | ".github/blunderbuss.yml",
24 | ".github/CODEOWNERS",
25 | ".github/ISSUE_TEMPLATE/bug_report.md",
26 | ".github/ISSUE_TEMPLATE/feature_request.md",
27 | ".github/ISSUE_TEMPLATE/support_request.md",
28 | ".github/snippet-bot.yml",
29 | ])
30 |
--------------------------------------------------------------------------------
/r2dbc/core/src/main/java/com/google/cloud/sql/core/CloudSqlConnectionFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Google Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static io.r2dbc.spi.ConnectionFactoryOptions.HOST;
20 | import static io.r2dbc.spi.ConnectionFactoryOptions.PORT;
21 |
22 | import io.r2dbc.spi.Connection;
23 | import io.r2dbc.spi.ConnectionFactory;
24 | import io.r2dbc.spi.ConnectionFactoryMetadata;
25 | import io.r2dbc.spi.ConnectionFactoryOptions;
26 | import io.r2dbc.spi.ConnectionFactoryProvider;
27 | import java.util.function.Supplier;
28 | import org.reactivestreams.Publisher;
29 | import reactor.core.publisher.Mono;
30 | import reactor.util.annotation.NonNull;
31 |
32 | /** {@link ConnectionFactory} for accessing Cloud SQL instances via R2DBC protocol. */
33 | public class CloudSqlConnectionFactory implements ConnectionFactory {
34 |
35 | public static final int SERVER_PROXY_PORT = 3307;
36 | private final Supplier supplier;
37 | private final ConnectionFactoryOptions.Builder builder;
38 | private final ConnectionConfig config;
39 |
40 | /** Creates an instance of ConnectionFactory that pulls and sets host ip before delegating. */
41 | public CloudSqlConnectionFactory(
42 | ConnectionConfig config,
43 | Supplier supplier,
44 | ConnectionFactoryOptions.Builder builder) {
45 | this.config = config;
46 | this.supplier = supplier;
47 | this.builder = builder;
48 | }
49 |
50 | @Override
51 | @NonNull
52 | public Publisher create() {
53 | String hostIp =
54 | InternalConnectorRegistry.getInstance()
55 | .getConnectionMetadata(config)
56 | .getPreferredIpAddress();
57 | builder.option(HOST, hostIp).option(PORT, SERVER_PROXY_PORT);
58 |
59 | return Mono.from(supplier.get().create(builder.build()).create())
60 | .map(c -> new CloudSqlConnection(config, c));
61 | }
62 |
63 | @Override
64 | @NonNull
65 | public ConnectionFactoryMetadata getMetadata() {
66 | String hostIp =
67 | InternalConnectorRegistry.getInstance()
68 | .getConnectionMetadata(config)
69 | .getPreferredIpAddress();
70 | builder.option(HOST, hostIp).option(PORT, SERVER_PROXY_PORT);
71 | return supplier.get().create(builder.build()).getMetadata();
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/r2dbc/core/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker:
--------------------------------------------------------------------------------
1 | mock-maker-inline
2 |
--------------------------------------------------------------------------------
/r2dbc/mariadb/src/main/java/com/google/cloud/sql/core/GcpConnectionFactoryProviderMariadb.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static io.r2dbc.spi.ConnectionFactoryOptions.Builder;
20 | import static io.r2dbc.spi.ConnectionFactoryOptions.DRIVER;
21 | import static io.r2dbc.spi.ConnectionFactoryOptions.PROTOCOL;
22 | import static org.mariadb.r2dbc.MariadbConnectionFactoryProvider.MARIADB_DRIVER;
23 |
24 | import io.netty.handler.ssl.SslContextBuilder;
25 | import io.r2dbc.spi.ConnectionFactory;
26 | import io.r2dbc.spi.ConnectionFactoryOptions;
27 | import io.r2dbc.spi.ConnectionFactoryProvider;
28 | import java.util.function.Function;
29 | import java.util.function.UnaryOperator;
30 | import org.mariadb.r2dbc.MariadbConnectionFactoryProvider;
31 |
32 | /** {@link ConnectionFactoryProvider} for proxied access to GCP MySQL instances. */
33 | public class GcpConnectionFactoryProviderMariadb extends GcpConnectionFactoryProvider {
34 |
35 | static {
36 | InternalConnectorRegistry.addArtifactId("cloud-sql-connector-r2dbc-mariadb");
37 | }
38 |
39 | @Override
40 | boolean supportedProtocol(String protocol) {
41 | return protocol.equals(MARIADB_DRIVER);
42 | }
43 |
44 | @Override
45 | ConnectionFactory tcpSocketConnectionFactory(
46 | ConnectionConfig config,
47 | Builder builder,
48 | Function customizer) {
49 |
50 | // The MariaDB driver accepts the UnaryOperator interface so we need to adapt the customizer
51 | // function passed in
52 | UnaryOperator unaryCustomizer =
53 | (sslContextBuilder) -> customizer.apply(sslContextBuilder);
54 |
55 | builder
56 | .option(MariadbConnectionFactoryProvider.SSL_TUNNEL_DISABLE_HOST_VERIFICATION, true)
57 | .option(MariadbConnectionFactoryProvider.SSL_CONTEXT_BUILDER_CUSTOMIZER, unaryCustomizer)
58 | .option(MariadbConnectionFactoryProvider.TCP_KEEP_ALIVE, true)
59 | .option(MariadbConnectionFactoryProvider.SSL_MODE, "tunnel");
60 |
61 | return new CloudSqlConnectionFactory(config, MariadbConnectionFactoryProvider::new, builder);
62 | }
63 |
64 | @Override
65 | ConnectionFactory unixSocketConnectionFactory(Builder optionBuilder, String socket) {
66 | optionBuilder.option(MariadbConnectionFactoryProvider.SOCKET, socket);
67 | return new MariadbConnectionFactoryProvider().create(optionBuilder.build());
68 | }
69 |
70 | @Override
71 | Builder createBuilder(ConnectionFactoryOptions connectionFactoryOptions) {
72 | return connectionFactoryOptions
73 | .mutate()
74 | .option(DRIVER, MARIADB_DRIVER)
75 | .option(PROTOCOL, "none");
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/r2dbc/mariadb/src/main/resources/META-INF/services/io.r2dbc.spi.ConnectionFactoryProvider:
--------------------------------------------------------------------------------
1 | com.google.cloud.sql.core.GcpConnectionFactoryProviderMariadb
2 |
--------------------------------------------------------------------------------
/r2dbc/mariadb/src/test/java/com/google/cloud/sql/core/R2dbcMariadbIntegrationTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static com.google.common.truth.Truth.assertWithMessage;
21 |
22 | import com.google.common.collect.ImmutableList;
23 | import io.r2dbc.pool.ConnectionPool;
24 | import io.r2dbc.pool.ConnectionPoolConfiguration;
25 | import io.r2dbc.spi.ConnectionFactories;
26 | import io.r2dbc.spi.ConnectionFactory;
27 | import java.time.LocalTime;
28 | import java.util.List;
29 | import java.util.concurrent.TimeUnit;
30 | import org.junit.Before;
31 | import org.junit.Rule;
32 | import org.junit.Test;
33 | import org.junit.rules.Timeout;
34 | import org.junit.runner.RunWith;
35 | import org.junit.runners.JUnit4;
36 | import reactor.core.publisher.Mono;
37 |
38 | @RunWith(JUnit4.class)
39 | public class R2dbcMariadbIntegrationTests {
40 |
41 | private static final ImmutableList requiredEnvVars =
42 | ImmutableList.of("MYSQL_USER", "MYSQL_PASS", "MYSQL_DB", "MYSQL_CONNECTION_NAME");
43 |
44 | private static final String CONNECTION_NAME = System.getenv("MYSQL_CONNECTION_NAME");
45 | private static final String DB_NAME = System.getenv("MYSQL_DB");
46 | private static final String DB_USER = System.getenv("MYSQL_USER");
47 | private static final String DB_PASSWORD = System.getenv("MYSQL_PASS");
48 | private static final String IP_TYPE =
49 | System.getenv("IP_TYPE") == null ? "PUBLIC" : System.getenv("IP_TYPE");
50 |
51 | @Rule public Timeout globalTimeout = new Timeout(80, TimeUnit.SECONDS);
52 |
53 | private ConnectionPool connectionPool;
54 |
55 | @Before
56 | public void setUpPool() {
57 | // Check that required env vars are set
58 | requiredEnvVars.forEach(
59 | (varName) ->
60 | assertWithMessage(
61 | String.format(
62 | "Environment variable '%s' must be set to perform these tests.", varName))
63 | .that(System.getenv(varName))
64 | .isNotEmpty());
65 |
66 | // Set up URL parameters
67 | String r2dbcURL =
68 | String.format(
69 | "r2dbc:gcp:mariadb://%s:%s@%s/%s?ipTypes=%s",
70 | DB_USER, DB_PASSWORD, CONNECTION_NAME, DB_NAME, IP_TYPE);
71 |
72 | // Initialize connection pool
73 | ConnectionFactory connectionFactory = ConnectionFactories.get(r2dbcURL);
74 | ConnectionPoolConfiguration configuration =
75 | ConnectionPoolConfiguration.builder(connectionFactory).build();
76 |
77 | this.connectionPool = new ConnectionPool(configuration);
78 | }
79 |
80 | @Test
81 | public void pooledConnectionTest() {
82 | List rows =
83 | Mono.from(this.connectionPool.create())
84 | .flatMapMany(connection -> connection.createStatement("SELECT NOW() as TS").execute())
85 | .flatMap(result -> result.map((r, meta) -> r.get("TS", LocalTime.class)))
86 | .collectList()
87 | .block();
88 |
89 | assertThat(rows.size()).isEqualTo(1);
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/r2dbc/mysql/src/main/java/com/google/cloud/sql/core/GcpConnectionFactoryProviderMysql.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Google Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static io.r2dbc.spi.ConnectionFactoryOptions.Builder;
20 | import static io.r2dbc.spi.ConnectionFactoryOptions.DRIVER;
21 |
22 | import io.asyncer.r2dbc.mysql.MySqlConnectionFactoryProvider;
23 | import io.asyncer.r2dbc.mysql.constant.SslMode;
24 | import io.netty.handler.ssl.SslContextBuilder;
25 | import io.r2dbc.spi.ConnectionFactory;
26 | import io.r2dbc.spi.ConnectionFactoryOptions;
27 | import io.r2dbc.spi.ConnectionFactoryProvider;
28 | import java.util.function.Function;
29 |
30 | /** {@link ConnectionFactoryProvider} for proxied access to GCP MySQL instances. */
31 | public class GcpConnectionFactoryProviderMysql extends GcpConnectionFactoryProvider {
32 |
33 | /** MySQL driver option value. */
34 | private static final String MYSQL_DRIVER = "mysql";
35 |
36 | static {
37 | InternalConnectorRegistry.addArtifactId("cloud-sql-connector-r2dbc-mysql");
38 | }
39 |
40 | @Override
41 | boolean supportedProtocol(String protocol) {
42 | return protocol.equals(MYSQL_DRIVER);
43 | }
44 |
45 | @Override
46 | ConnectionFactory tcpSocketConnectionFactory(
47 | ConnectionConfig config,
48 | Builder builder,
49 | Function customizer) {
50 | builder
51 | .option(MySqlConnectionFactoryProvider.SSL_CONTEXT_BUILDER_CUSTOMIZER, customizer)
52 | .option(MySqlConnectionFactoryProvider.SSL_MODE, SslMode.TUNNEL)
53 | .option(MySqlConnectionFactoryProvider.TCP_NO_DELAY, true)
54 | .option(MySqlConnectionFactoryProvider.TCP_KEEP_ALIVE, true);
55 |
56 | return new CloudSqlConnectionFactory(config, MySqlConnectionFactoryProvider::new, builder);
57 | }
58 |
59 | @Override
60 | ConnectionFactory unixSocketConnectionFactory(Builder optionBuilder, String socket) {
61 | optionBuilder.option(MySqlConnectionFactoryProvider.UNIX_SOCKET, socket);
62 | return new MySqlConnectionFactoryProvider().create(optionBuilder.build());
63 | }
64 |
65 | @Override
66 | Builder createBuilder(ConnectionFactoryOptions connectionFactoryOptions) {
67 | return connectionFactoryOptions.mutate().option(DRIVER, MYSQL_DRIVER);
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/r2dbc/mysql/src/main/resources/META-INF/services/io.r2dbc.spi.ConnectionFactoryProvider:
--------------------------------------------------------------------------------
1 | com.google.cloud.sql.core.GcpConnectionFactoryProviderMysql
2 |
--------------------------------------------------------------------------------
/r2dbc/mysql/src/test/java/com/google/cloud/sql/core/R2dbcMysqlIntegrationTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static com.google.common.truth.Truth.assertWithMessage;
21 |
22 | import com.google.common.collect.ImmutableList;
23 | import io.r2dbc.pool.ConnectionPool;
24 | import io.r2dbc.pool.ConnectionPoolConfiguration;
25 | import io.r2dbc.spi.ConnectionFactories;
26 | import io.r2dbc.spi.ConnectionFactory;
27 | import java.time.Instant;
28 | import java.util.List;
29 | import java.util.concurrent.TimeUnit;
30 | import org.junit.Before;
31 | import org.junit.Rule;
32 | import org.junit.Test;
33 | import org.junit.rules.Timeout;
34 | import org.junit.runner.RunWith;
35 | import org.junit.runners.JUnit4;
36 | import reactor.core.publisher.Mono;
37 |
38 | @RunWith(JUnit4.class)
39 | public class R2dbcMysqlIntegrationTests {
40 |
41 | private static final ImmutableList requiredEnvVars =
42 | ImmutableList.of("MYSQL_USER", "MYSQL_PASS", "MYSQL_DB", "MYSQL_CONNECTION_NAME");
43 |
44 | private static final String CONNECTION_NAME = System.getenv("MYSQL_CONNECTION_NAME");
45 | private static final String DB_NAME = System.getenv("MYSQL_DB");
46 | private static final String DB_USER = System.getenv("MYSQL_USER");
47 | private static final String DB_PASSWORD = System.getenv("MYSQL_PASS");
48 | private static final String IP_TYPE =
49 | System.getenv("IP_TYPE") == null ? "PUBLIC" : System.getenv("IP_TYPE");
50 |
51 | @Rule public Timeout globalTimeout = new Timeout(80, TimeUnit.SECONDS);
52 |
53 | private ConnectionPool connectionPool;
54 |
55 | @Before
56 | public void setUpPool() {
57 | // Check that required env vars are set
58 | requiredEnvVars.forEach(
59 | (varName) ->
60 | assertWithMessage(
61 | String.format(
62 | "Environment variable '%s' must be set to perform these tests.", varName))
63 | .that(System.getenv(varName))
64 | .isNotEmpty());
65 |
66 | // Set up URL parameters
67 | String r2dbcURL =
68 | String.format(
69 | "r2dbc:gcp:mysql://%s:%s@%s/%s?ipTypes=%s",
70 | DB_USER, DB_PASSWORD, CONNECTION_NAME, DB_NAME, IP_TYPE);
71 |
72 | // Initialize connection pool
73 | ConnectionFactory connectionFactory = ConnectionFactories.get(r2dbcURL);
74 | ConnectionPoolConfiguration configuration =
75 | ConnectionPoolConfiguration.builder(connectionFactory).build();
76 |
77 | this.connectionPool = new ConnectionPool(configuration);
78 | }
79 |
80 | @Test
81 | public void pooledConnectionTest() {
82 | List rows =
83 | Mono.from(this.connectionPool.create())
84 | .flatMapMany(connection -> connection.createStatement("SELECT NOW() as TS").execute())
85 | .flatMap(result -> result.map((r, meta) -> r.get("TS", Instant.class)))
86 | .collectList()
87 | .block();
88 |
89 | assertThat(rows.size()).isEqualTo(1);
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/r2dbc/postgres/src/main/java/com/google/cloud/sql/core/GcpConnectionFactoryProviderPostgres.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Google Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static io.r2dbc.spi.ConnectionFactoryOptions.Builder;
20 | import static io.r2dbc.spi.ConnectionFactoryOptions.DRIVER;
21 |
22 | import io.netty.handler.ssl.SslContextBuilder;
23 | import io.r2dbc.postgresql.PostgresqlConnectionFactoryProvider;
24 | import io.r2dbc.postgresql.client.SSLMode;
25 | import io.r2dbc.spi.ConnectionFactory;
26 | import io.r2dbc.spi.ConnectionFactoryOptions;
27 | import io.r2dbc.spi.ConnectionFactoryProvider;
28 | import java.util.function.Function;
29 |
30 | /** {@link ConnectionFactoryProvider} for proxied access to GCP Postgres instances. */
31 | public class GcpConnectionFactoryProviderPostgres extends GcpConnectionFactoryProvider {
32 |
33 | /** Postgres driver option value. */
34 | private static final String POSTGRESQL_DRIVER = "postgresql";
35 | /** Legacy postgres driver option value. */
36 | private static final String LEGACY_POSTGRESQL_DRIVER = "postgres";
37 |
38 | static {
39 | InternalConnectorRegistry.addArtifactId("cloud-sql-connector-r2dbc-postgres");
40 | }
41 |
42 | @Override
43 | boolean supportedProtocol(String protocol) {
44 | return protocol.equals(POSTGRESQL_DRIVER) || protocol.equals(LEGACY_POSTGRESQL_DRIVER);
45 | }
46 |
47 | @Override
48 | ConnectionFactory tcpSocketConnectionFactory(
49 | ConnectionConfig config,
50 | Builder builder,
51 | Function customizer) {
52 | builder
53 | .option(PostgresqlConnectionFactoryProvider.SSL_CONTEXT_BUILDER_CUSTOMIZER, customizer)
54 | .option(PostgresqlConnectionFactoryProvider.SSL_MODE, SSLMode.TUNNEL)
55 | .option(PostgresqlConnectionFactoryProvider.TCP_NODELAY, true)
56 | .option(PostgresqlConnectionFactoryProvider.TCP_KEEPALIVE, true);
57 |
58 | return new CloudSqlConnectionFactory(config, PostgresqlConnectionFactoryProvider::new, builder);
59 | }
60 |
61 | @Override
62 | ConnectionFactory unixSocketConnectionFactory(Builder optionBuilder, String socket) {
63 | optionBuilder.option(PostgresqlConnectionFactoryProvider.SOCKET, socket);
64 | return new PostgresqlConnectionFactoryProvider().create(optionBuilder.build());
65 | }
66 |
67 | @Override
68 | Builder createBuilder(ConnectionFactoryOptions connectionFactoryOptions) {
69 | return connectionFactoryOptions.mutate().option(DRIVER, POSTGRESQL_DRIVER);
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/r2dbc/postgres/src/main/resources/META-INF/services/io.r2dbc.spi.ConnectionFactoryProvider:
--------------------------------------------------------------------------------
1 | com.google.cloud.sql.core.GcpConnectionFactoryProviderPostgres
2 |
--------------------------------------------------------------------------------
/r2dbc/postgres/src/test/java/com/google/cloud/sql/core/R2dbcPostgresIntegrationTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static com.google.common.truth.Truth.assertWithMessage;
21 |
22 | import com.google.common.collect.ImmutableList;
23 | import io.r2dbc.pool.ConnectionPool;
24 | import io.r2dbc.pool.ConnectionPoolConfiguration;
25 | import io.r2dbc.spi.ConnectionFactories;
26 | import io.r2dbc.spi.ConnectionFactory;
27 | import java.time.Instant;
28 | import java.util.List;
29 | import java.util.concurrent.TimeUnit;
30 | import org.junit.Before;
31 | import org.junit.Rule;
32 | import org.junit.Test;
33 | import org.junit.rules.Timeout;
34 | import org.junit.runner.RunWith;
35 | import org.junit.runners.JUnit4;
36 | import reactor.core.publisher.Mono;
37 |
38 | @RunWith(JUnit4.class)
39 | public class R2dbcPostgresIntegrationTests {
40 |
41 | private static final String CONNECTION_NAME = System.getenv("POSTGRES_CONNECTION_NAME");
42 | private static final String DB_NAME = System.getenv("POSTGRES_DB");
43 | private static final String DB_USER = System.getenv("POSTGRES_USER");
44 | private static final String DB_PASSWORD = System.getenv("POSTGRES_PASS");
45 | private static final String IP_TYPE =
46 | System.getenv("IP_TYPE") == null ? "PUBLIC" : System.getenv("IP_TYPE");
47 | private static final ImmutableList requiredEnvVars =
48 | ImmutableList.of("POSTGRES_USER", "POSTGRES_PASS", "POSTGRES_DB", "POSTGRES_CONNECTION_NAME");
49 | @Rule public Timeout globalTimeout = new Timeout(80, TimeUnit.SECONDS);
50 |
51 | private ConnectionFactory connectionPool;
52 |
53 | @Before
54 | public void setUpPool() {
55 | // Check that required env vars are set
56 | requiredEnvVars.forEach(
57 | (varName) ->
58 | assertWithMessage(
59 | String.format(
60 | "Environment variable '%s' must be set to perform these tests.", varName))
61 | .that(System.getenv(varName))
62 | .isNotEmpty());
63 |
64 | // Set up URL parameters
65 | String r2dbcURL =
66 | String.format(
67 | "r2dbc:gcp:postgres://%s:%s@%s/%s?ipTypes=%s",
68 | DB_USER, DB_PASSWORD, CONNECTION_NAME, DB_NAME, IP_TYPE);
69 |
70 | // Initialize connection pool
71 | ConnectionFactory connectionFactory = ConnectionFactories.get(r2dbcURL);
72 | ConnectionPoolConfiguration configuration =
73 | ConnectionPoolConfiguration.builder(connectionFactory).build();
74 |
75 | this.connectionPool = new ConnectionPool(configuration);
76 | }
77 |
78 | @Test
79 | public void pooledConnectionTest() {
80 | List rows =
81 | Mono.from(this.connectionPool.create())
82 | .flatMapMany(connection -> connection.createStatement("SELECT NOW() as TS").execute())
83 | .flatMap(result -> result.map((r, meta) -> r.get("TS", Instant.class)))
84 | .collectList()
85 | .block();
86 |
87 | assertThat(rows.size()).isEqualTo(1);
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/r2dbc/postgres/src/test/java/com/google/cloud/sql/core/R2dbcPostgresPoolRemoteValidationIntegrationTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static com.google.common.truth.Truth.assertWithMessage;
21 |
22 | import com.google.common.collect.ImmutableList;
23 | import io.r2dbc.pool.ConnectionPool;
24 | import io.r2dbc.pool.ConnectionPoolConfiguration;
25 | import io.r2dbc.spi.ConnectionFactories;
26 | import io.r2dbc.spi.ConnectionFactory;
27 | import io.r2dbc.spi.ValidationDepth;
28 | import java.time.Instant;
29 | import java.util.List;
30 | import java.util.concurrent.TimeUnit;
31 | import org.junit.Before;
32 | import org.junit.Rule;
33 | import org.junit.Test;
34 | import org.junit.rules.Timeout;
35 | import org.junit.runner.RunWith;
36 | import org.junit.runners.JUnit4;
37 | import reactor.core.publisher.Mono;
38 |
39 | @RunWith(JUnit4.class)
40 | public class R2dbcPostgresPoolRemoteValidationIntegrationTests {
41 |
42 | private static final String CONNECTION_NAME = System.getenv("POSTGRES_CONNECTION_NAME");
43 | private static final String DB_NAME = System.getenv("POSTGRES_DB");
44 | private static final String DB_USER = System.getenv("POSTGRES_USER");
45 | private static final String DB_PASSWORD = System.getenv("POSTGRES_PASS");
46 | private static final String IP_TYPE =
47 | System.getenv("IP_TYPE") == null ? "PUBLIC" : System.getenv("IP_TYPE");
48 | private static final ImmutableList requiredEnvVars =
49 | ImmutableList.of("POSTGRES_USER", "POSTGRES_PASS", "POSTGRES_DB", "POSTGRES_CONNECTION_NAME");
50 | @Rule public Timeout globalTimeout = new Timeout(80, TimeUnit.SECONDS);
51 |
52 | private ConnectionFactory connectionPool;
53 |
54 | @Before
55 | public void setUpPool() {
56 | // Check that required env vars are set
57 | requiredEnvVars.forEach(
58 | (varName) ->
59 | assertWithMessage(
60 | String.format(
61 | "Environment variable '%s' must be set to perform these tests.", varName))
62 | .that(System.getenv(varName))
63 | .isNotEmpty());
64 |
65 | // Set up URL parameters
66 | String r2dbcURL =
67 | String.format(
68 | "r2dbc:gcp:postgres://%s:%s@%s/%s?ipTypes=%s",
69 | DB_USER, DB_PASSWORD, CONNECTION_NAME, DB_NAME, IP_TYPE);
70 |
71 | // Initialize connection pool with REMOTE validation
72 | ConnectionFactory connectionFactory = ConnectionFactories.get(r2dbcURL);
73 | ConnectionPoolConfiguration configuration =
74 | ConnectionPoolConfiguration.builder(connectionFactory)
75 | .validationDepth(ValidationDepth.REMOTE)
76 | .build();
77 |
78 | this.connectionPool = new ConnectionPool(configuration);
79 | }
80 |
81 | @Test
82 | public void pooledConnectionTest() {
83 | List rows =
84 | Mono.from(this.connectionPool.create())
85 | .flatMapMany(connection -> connection.createStatement("SELECT NOW() as TS").execute())
86 | .flatMap(result -> result.map((r, meta) -> r.get("TS", Instant.class)))
87 | .collectList()
88 | .block();
89 |
90 | assertThat(rows.size()).isEqualTo(1);
91 | }
92 | }
93 |
--------------------------------------------------------------------------------
/r2dbc/sqlserver/src/main/java/com/google/cloud/sql/core/GcpConnectionFactoryProviderMssql.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Google Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static io.r2dbc.spi.ConnectionFactoryOptions.Builder;
20 | import static io.r2dbc.spi.ConnectionFactoryOptions.DRIVER;
21 |
22 | import io.netty.handler.ssl.SslContextBuilder;
23 | import io.r2dbc.mssql.MssqlConnectionFactoryProvider;
24 | import io.r2dbc.spi.ConnectionFactory;
25 | import io.r2dbc.spi.ConnectionFactoryOptions;
26 | import io.r2dbc.spi.ConnectionFactoryProvider;
27 | import java.util.function.Function;
28 |
29 | /** {@link ConnectionFactoryProvider} for proxied access to GCP MsSQL instances. */
30 | public class GcpConnectionFactoryProviderMssql extends GcpConnectionFactoryProvider {
31 |
32 | static {
33 | InternalConnectorRegistry.addArtifactId("cloud-sql-connector-r2dbc-mssql");
34 | }
35 |
36 | /** MsSQL driver option value. */
37 | private static final String MSSQL_DRIVER = "mssql";
38 |
39 | @Override
40 | boolean supportedProtocol(String protocol) {
41 | return protocol.equals(MSSQL_DRIVER);
42 | }
43 |
44 | @Override
45 | ConnectionFactory tcpSocketConnectionFactory(
46 | ConnectionConfig config,
47 | Builder builder,
48 | Function customizer) {
49 | builder
50 | .option(MssqlConnectionFactoryProvider.SSL_TUNNEL, customizer)
51 | .option(MssqlConnectionFactoryProvider.TCP_NODELAY, true)
52 | .option(MssqlConnectionFactoryProvider.TCP_KEEPALIVE, true);
53 |
54 | return new CloudSqlConnectionFactory(config, MssqlConnectionFactoryProvider::new, builder);
55 | }
56 |
57 | @Override
58 | ConnectionFactory unixSocketConnectionFactory(Builder optionBuilder, String socket) {
59 | throw new RuntimeException("UNIX socket connections are not supported");
60 | }
61 |
62 | @Override
63 | Builder createBuilder(ConnectionFactoryOptions connectionFactoryOptions) {
64 | return connectionFactoryOptions.mutate().option(DRIVER, MSSQL_DRIVER);
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/r2dbc/sqlserver/src/main/resources/META-INF/services/io.r2dbc.spi.ConnectionFactoryProvider:
--------------------------------------------------------------------------------
1 | com.google.cloud.sql.core.GcpConnectionFactoryProviderMssql
2 |
--------------------------------------------------------------------------------
/r2dbc/sqlserver/src/test/java/com/google/cloud/sql/core/R2dbcSqlserverIntegrationTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Google LLC
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * https://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.google.cloud.sql.core;
18 |
19 | import static com.google.common.truth.Truth.assertThat;
20 | import static com.google.common.truth.Truth.assertWithMessage;
21 |
22 | import com.google.common.collect.ImmutableList;
23 | import io.r2dbc.pool.ConnectionPool;
24 | import io.r2dbc.pool.ConnectionPoolConfiguration;
25 | import io.r2dbc.spi.ConnectionFactories;
26 | import io.r2dbc.spi.ConnectionFactory;
27 | import java.util.List;
28 | import java.util.concurrent.TimeUnit;
29 | import org.junit.Before;
30 | import org.junit.Rule;
31 | import org.junit.Test;
32 | import org.junit.rules.Timeout;
33 | import org.junit.runner.RunWith;
34 | import org.junit.runners.JUnit4;
35 | import reactor.core.publisher.Mono;
36 |
37 | @RunWith(JUnit4.class)
38 | public class R2dbcSqlserverIntegrationTests {
39 |
40 | private static final ImmutableList requiredEnvVars =
41 | ImmutableList.of(
42 | "SQLSERVER_USER", "SQLSERVER_PASS", "SQLSERVER_DB", "SQLSERVER_CONNECTION_NAME");
43 |
44 | private static final String CONNECTION_NAME = System.getenv("SQLSERVER_CONNECTION_NAME");
45 | private static final String DB_NAME = System.getenv("SQLSERVER_DB");
46 | private static final String DB_USER = System.getenv("SQLSERVER_USER");
47 | private static final String DB_PASSWORD = System.getenv("SQLSERVER_PASS");
48 | private static final String IP_TYPE =
49 | System.getenv("IP_TYPE") == null ? "PUBLIC" : System.getenv("IP_TYPE");
50 |
51 | @Rule public Timeout globalTimeout = new Timeout(80, TimeUnit.SECONDS);
52 |
53 | private ConnectionPool connectionPool;
54 |
55 | @Before
56 | public void setUpPool() {
57 | // Check that required env vars are set
58 | requiredEnvVars.forEach(
59 | (varName) ->
60 | assertWithMessage(
61 | String.format(
62 | "Environment variable '%s' must be set to perform these tests.", varName))
63 | .that(System.getenv(varName))
64 | .isNotEmpty());
65 |
66 | // Set up URL parameters
67 | String r2dbcURL =
68 | String.format(
69 | "r2dbc:gcp:mssql://%s:%s@%s/%s?ipTypes=%s",
70 | DB_USER, DB_PASSWORD, CONNECTION_NAME, DB_NAME, IP_TYPE);
71 |
72 | // Initialize connection pool
73 | ConnectionFactory connectionFactory = ConnectionFactories.get(r2dbcURL);
74 | ConnectionPoolConfiguration configuration =
75 | ConnectionPoolConfiguration.builder(connectionFactory).build();
76 |
77 | this.connectionPool = new ConnectionPool(configuration);
78 | }
79 |
80 | @Test
81 | public void pooledConnectionTest() {
82 | List rows =
83 | Mono.from(this.connectionPool.create())
84 | .flatMapMany(connection -> connection.createStatement("SELECT 1 as TS").execute())
85 | .flatMap(result -> result.map((r, meta) -> r.get("TS", Integer.class)))
86 | .collectList()
87 | .block();
88 |
89 | assertThat(rows.size()).isEqualTo(1);
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/versions.txt:
--------------------------------------------------------------------------------
1 | # Format:
2 | # module:released-version:current-version
3 |
4 | jdbc-socket-factory-parent:1.25.1:1.25.2-SNAPSHOT
5 | jdbc-socket-factory-core:1.25.1:1.25.2-SNAPSHOT
6 | mariadb-socket-factory:1.25.1:1.25.2-SNAPSHOT
7 | mysql-socket-factory:1.25.1:1.25.2-SNAPSHOT
8 | mysql-socket-factory-connector-j-8:1.25.1:1.25.2-SNAPSHOT
9 | postgres-socket-factory:1.25.1:1.25.2-SNAPSHOT
10 | cloud-sql-connector-jdbc-sqlserver:1.25.1:1.25.2-SNAPSHOT
11 | cloud-sql-connector-r2dbc-core:1.25.1:1.25.2-SNAPSHOT
12 | cloud-sql-connector-r2dbc-mariadb:1.25.1:1.25.2-SNAPSHOT
13 | cloud-sql-connector-r2dbc-mysql:1.25.1:1.25.2-SNAPSHOT
14 | cloud-sql-connector-r2dbc-postgres:1.25.1:1.25.2-SNAPSHOT
15 | cloud-sql-connector-r2dbc-sqlserver:1.25.1:1.25.2-SNAPSHOT
16 |
--------------------------------------------------------------------------------