org.apache.brooklyn.entity.proxy.ProxySslConfig Maven / Gradle / Ivy
Show all versions of brooklyn-software-webapp Show documentation
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.brooklyn.entity.proxy;
import java.io.Serializable;
import java.util.Map;
import org.apache.brooklyn.util.core.flags.FlagUtils;
import org.apache.brooklyn.util.core.flags.SetFromFlag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Objects;
public class ProxySslConfig implements Serializable {
private static final long serialVersionUID = -2692754611458939617L;
private static final Logger log = LoggerFactory.getLogger(ProxySslConfig.class);
public static Builder builder() {
return new Builder();
}
public static class Builder {
@SetFromFlag protected String certificateSourceUrl;
@SetFromFlag protected String keySourceUrl;
@SetFromFlag protected String clientCertificateSourceUrl;
@SetFromFlag protected String certificateDestination;
@SetFromFlag protected String keyDestination;
@SetFromFlag protected String clientCertificateDestination;
@SetFromFlag protected boolean verifyClient = false;
@SetFromFlag protected boolean targetIsSsl = false;
@SetFromFlag protected boolean reuseSessions = false;
public Builder certificateSourceUrl(String val) {
certificateSourceUrl = val; return this;
}
public Builder keySourceUrl(String val) {
keySourceUrl = val; return this;
}
public Builder clientCertificateSourceUrl(String val) {
clientCertificateSourceUrl = val; return this;
}
public Builder certificateDestination(String val) {
certificateDestination = val; return this;
}
public Builder keyDestination(String val) {
keyDestination = val; return this;
}
public Builder clientCertificateDestination(String val) {
clientCertificateDestination = val; return this;
}
public Builder verifyClient(boolean val) {
verifyClient = val; return this;
}
public Builder targetIsSsl(boolean val) {
targetIsSsl = val; return this;
}
public Builder reuseSessions(boolean val) {
reuseSessions = val; return this;
}
public ProxySslConfig build() {
ProxySslConfig result = new ProxySslConfig(this);
return result;
}
}
public static ProxySslConfig fromMap(Map map) {
Builder b = new Builder();
Map unused = FlagUtils.setFieldsFromFlags(map, b);
if (!unused.isEmpty()) log.warn("Unused flags when populating "+b+" (ignoring): "+unused);
return b.build();
}
private String certificateSourceUrl;
private String keySourceUrl;
private String clientCertificateSourceUrl;
private String certificateDestination;
private String keyDestination;
private String clientCertificateDestination;
private boolean verifyClient = false;
private boolean targetIsSsl = false;
private boolean reuseSessions = false;
public ProxySslConfig() { }
protected ProxySslConfig(Builder builder) {
certificateSourceUrl = builder.certificateSourceUrl;
keySourceUrl = builder.keySourceUrl;
clientCertificateSourceUrl = builder.clientCertificateSourceUrl;
certificateDestination = builder.certificateDestination;
keyDestination = builder.keyDestination;
clientCertificateDestination = builder.clientCertificateDestination;
verifyClient = builder.verifyClient;
targetIsSsl = builder.targetIsSsl;
reuseSessions = builder.reuseSessions;
}
/**
* URL for the SSL certificates required at the server.
*
* Corresponding nginx settings:
*
* ssl on;
* ssl_certificate www.example.com.crt;
* ssl_certificate_key www.example.com.key;
*
* Okay (in nginx) for key to be null if certificate contains both as per setup at
* http://nginx.org/en/docs/http/configuring_https_servers.html
*
* Proxy object can be set on nginx instance to apply site-wide,
* and to put multiple servers in the certificate file
*
* The brooklyn entity will install the certificate/key(s) on the server.
* (however it will not currently merge multiple certificates.
* if conflicting certificates are attempted to be installed nginx will complain.)
*/
public String getCertificateSourceUrl() {
return certificateSourceUrl;
}
public void setCertificateSourceUrl(String certificateSourceUrl) {
this.certificateSourceUrl = certificateSourceUrl;
}
/** @see #getCertificateSourceUrl()} */
public String getKeySourceUrl() {
return keySourceUrl;
}
public void setKeySourceUrl(String keySourceUrl) {
this.keySourceUrl = keySourceUrl;
}
public String getClientCertificateSourceUrl() {
return clientCertificateSourceUrl;
}
public void setClientCertificateSourceUrl(String clientCertificateSourceUrl) {
this.clientCertificateSourceUrl = clientCertificateSourceUrl;
}
/**
* Sets the {@code ssl_certificate_path} to be used within the generated
* {@link LoadBalancer} configuration.
*
* If set to null, Brooklyn will use an auto generated path.
*
* If {@link #getCertificateSourceUrl() certificateSourceUrl} is set *
* then Brooklyn will copy the certificate the destination.
*
* Setting this field is useful if there is a {@code certificate} on the
* nginx machine you want to make use of.
*/
public String getCertificateDestination() {
return certificateDestination;
}
public void setCertificateDestination(String certificateDestination) {
this.certificateDestination = certificateDestination;
}
/**
* Sets the {@code ssl_certificate_key} path to be used within the generated
* {@link LoadBalancer} configuration.
*
* If set to null, Brooklyn will use an auto generated path.
*
* If {@link #getKeySourceUrl() keySourceUrl} is set then Brooklyn will copy the
* certificate to the destination.
*
* Setting this field is useful if there is a {@code certificate_key} on the
* nginx machine you want to make use of.
*/
public String getKeyDestination() {
return keyDestination;
}
public void setKeyDestination(String keyDestination) {
this.keyDestination = keyDestination;
}
public String getClientCertificateDestination() {
return clientCertificateDestination;
}
public void setClientCertificateDestination(String clientCertificateDestination) {
this.clientCertificateDestination = clientCertificateDestination;
}
/**
* Whether to verify the client using certificates; default false.
*/
public boolean getVerifyClient() {
return verifyClient;
}
public void setVerifyClient(boolean verifyClient) {
this.verifyClient = verifyClient;
}
/**
* Whether the downstream server (if mapping) also expects https; default false.
*/
public boolean getTargetIsSsl() {
return targetIsSsl;
}
public void setTargetIsSsl(boolean targetIsSsl) {
this.targetIsSsl = targetIsSsl;
}
/**
* Whether to reuse SSL validation in the server (performance).
*
* Corresponds to nginx setting {@code proxy_ssl_session_reuse on|off}.
*/
public boolean getReuseSessions() {
return reuseSessions;
}
public void setReuseSessions(boolean reuseSessions) {
this.reuseSessions = reuseSessions;
}
@Override
public int hashCode() {
return Objects.hashCode(certificateSourceUrl, keySourceUrl, certificateDestination, keyDestination,
clientCertificateSourceUrl, clientCertificateDestination, verifyClient, reuseSessions, targetIsSsl);
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ProxySslConfig other = (ProxySslConfig) obj;
return Objects.equal(certificateSourceUrl, other.certificateSourceUrl) &&
Objects.equal(certificateDestination, other.certificateDestination) &&
Objects.equal(keyDestination, other.keyDestination) &&
Objects.equal(keySourceUrl, other.keySourceUrl) &&
Objects.equal(clientCertificateSourceUrl, other.clientCertificateSourceUrl) &&
Objects.equal(clientCertificateDestination, other.clientCertificateDestination) &&
Objects.equal(verifyClient, other.verifyClient) &&
Objects.equal(reuseSessions, other.reuseSessions) &&
Objects.equal(targetIsSsl, other.targetIsSsl);
}
}