/*
* 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 com.globo.globodns.cloudstack.resource;
import java.util.List;
import java.util.Map;
import javax.naming.ConfigurationException;
import org.apache.log4j.Logger;
import com.cloud.agent.IAgentControl;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.Command;
import com.cloud.agent.api.MaintainAnswer;
import com.cloud.agent.api.MaintainCommand;
import com.cloud.agent.api.PingCommand;
import com.cloud.agent.api.ReadyAnswer;
import com.cloud.agent.api.ReadyCommand;
import com.cloud.agent.api.StartupCommand;
import com.cloud.host.Host;
import com.cloud.host.Host.Type;
import com.cloud.resource.ServerResource;
import com.cloud.utils.component.ManagerBase;
import com.globo.globodns.client.GloboDns;
import com.globo.globodns.client.GloboDnsException;
import com.globo.globodns.client.model.Authentication;
import com.globo.globodns.client.model.Domain;
import com.globo.globodns.client.model.Export;
import com.globo.globodns.client.model.Record;
import com.globo.globodns.cloudstack.commands.CreateOrUpdateDomainCommand;
import com.globo.globodns.cloudstack.commands.CreateOrUpdateRecordAndReverseCommand;
import com.globo.globodns.cloudstack.commands.RemoveDomainCommand;
import com.globo.globodns.cloudstack.commands.RemoveRecordCommand;
import com.globo.globodns.cloudstack.commands.SignInCommand;
public class GloboDnsResource extends ManagerBase implements ServerResource {
private String _zoneId;
private String _guid;
private String _name;
private String _username;
private String _url;
private String _password;
protected GloboDns _globoDns;
private static final String IPV4_RECORD_TYPE = "A";
private static final String REVERSE_RECORD_TYPE = "PTR";
private static final String REVERSE_DOMAIN_SUFFIX = "in-addr.arpa";
private static final String DEFAULT_AUTHORITY_TYPE = "M";
private static final Logger s_logger = Logger.getLogger(GloboDnsResource.class);
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
_zoneId = (String)params.get("zoneId");
if (_zoneId == null) {
throw new ConfigurationException("Unable to find zone");
}
_guid = (String)params.get("guid");
if (_guid == null) {
throw new ConfigurationException("Unable to find guid");
}
_name = (String)params.get("name");
if (_name == null) {
throw new ConfigurationException("Unable to find name");
}
_url = (String)params.get("url");
if (_url == null) {
throw new ConfigurationException("Unable to find url");
}
_username = (String)params.get("username");
if (_username == null) {
throw new ConfigurationException("Unable to find username");
}
_password = (String)params.get("password");
if (_password == null) {
throw new ConfigurationException("Unable to find password");
}
_globoDns = GloboDns.buildHttpApi(_url, _username, _password);
return true;
}
@Override
public boolean start() {
return true;
}
@Override
public boolean stop() {
return true;
}
@Override
public Type getType() {
return Host.Type.L2Networking;
}
@Override
public StartupCommand[] initialize() {
s_logger.trace("initialize called");
StartupCommand cmd = new StartupCommand(getType());
cmd.setName(_name);
cmd.setGuid(_guid);
cmd.setDataCenter(_zoneId);
cmd.setPod("");
cmd.setPrivateIpAddress("");
cmd.setStorageIpAddress("");
cmd.setVersion(GloboDnsResource.class.getPackage().getImplementationVersion());
return new StartupCommand[] {cmd};
}
@Override
public PingCommand getCurrentStatus(long id) {
return new PingCommand(getType(), id);
}
@Override
public void disconnected() {
return;
}
@Override
public IAgentControl getAgentControl() {
return null;
}
@Override
public void setAgentControl(IAgentControl agentControl) {
return;
}
@Override
public Answer executeRequest(Command cmd) {
if (cmd instanceof ReadyCommand) {
return new ReadyAnswer((ReadyCommand)cmd);
} else if (cmd instanceof MaintainCommand) {
return new MaintainAnswer((MaintainCommand)cmd);
} else if (cmd instanceof SignInCommand) {
return execute((SignInCommand)cmd);
} else if (cmd instanceof RemoveDomainCommand) {
return execute((RemoveDomainCommand)cmd);
} else if (cmd instanceof RemoveRecordCommand) {
return execute((RemoveRecordCommand)cmd);
} else if (cmd instanceof CreateOrUpdateDomainCommand) {
return execute((CreateOrUpdateDomainCommand)cmd);
} else if (cmd instanceof CreateOrUpdateRecordAndReverseCommand) {
return execute((CreateOrUpdateRecordAndReverseCommand)cmd);
}
return Answer.createUnsupportedCommandAnswer(cmd);
}
public Answer execute(SignInCommand cmd) {
try {
Authentication auth = _globoDns.getAuthAPI().signIn(cmd.getEmail(), cmd.getPassword());
if (auth != null) {
return new Answer(cmd, true, "Signed in successfully");
} else {
return new Answer(cmd, false, "Unable to sign in on GloboDNS");
}
} catch (GloboDnsException e) {
return new Answer(cmd, false, e.getMessage());
}
}
public Answer execute(RemoveDomainCommand cmd) {
try {
Domain domain = searchDomain(cmd.getNetworkDomain(), false);
if (domain != null) {
if (!cmd.isOverride()) {
for (Record record : _globoDns.getRecordAPI().listAll(domain.getId())) {
if (record.getTypeNSRecordAttributes().getId() == null) {
s_logger.warn("There are records in domain " + cmd.getNetworkDomain() + " and override is not enable. I will not delete this domain.");
return new Answer(cmd, true, "Domain keeped");
}
}
}
_globoDns.getDomainAPI().removeDomain(domain.getId());
scheduleExportChangesToBind();
} else {
s_logger.warn("Domain " + cmd.getNetworkDomain() + " already been deleted.");
}
return new Answer(cmd, true, "Domain removed");
} catch (GloboDnsException e) {
return new Answer(cmd, false, e.getMessage());
}
}
public Answer execute(RemoveRecordCommand cmd) {
boolean needsExport = false;
try {
if (removeRecord(cmd.getRecordName(), cmd.getRecordIp(), cmd.getNetworkDomain(), false, cmd.isOverride())) {
needsExport = true;
}
// remove reverse
String reverseGloboDnsName = generateReverseDomainNameFromNetworkIp(cmd.getRecordIp());
String reverseRecordName = generateReverseRecordNameFromNetworkIp(cmd.getRecordIp());
String reverseRecordContent = cmd.getRecordName() + '.' + cmd.getNetworkDomain();
if (removeRecord(reverseRecordName, reverseRecordContent, reverseGloboDnsName, true, cmd.isOverride())) {
needsExport = true;
}
return new Answer(cmd, true, "Record removed");
} catch (GloboDnsException e) {
return new Answer(cmd, false, e.getMessage());
} finally {
if (needsExport) {
scheduleExportChangesToBind();
}
}
}
public Answer execute(CreateOrUpdateRecordAndReverseCommand cmd) {
boolean needsExport = false;
try {
Domain domain = searchDomain(cmd.getNetworkDomain(), false);
if (domain == null) {
domain = _globoDns.getDomainAPI().createDomain(cmd.getNetworkDomain(), cmd.getReverseTemplateId(), DEFAULT_AUTHORITY_TYPE);
s_logger.warn("Domain " + cmd.getNetworkDomain() + " doesn't exist, maybe someone removed it. It was automatically created with template "
+ cmd.getReverseTemplateId());
}
boolean created = createOrUpdateRecord(domain.getId(), cmd.getRecordName(), cmd.getRecordIp(), IPV4_RECORD_TYPE, cmd.isOverride());
if (!created) {
String msg = "Unable to create record " + cmd.getRecordName() + " at " + cmd.getNetworkDomain();
if (!cmd.isOverride()) {
msg += ". Override record option is false, maybe record already exist.";
}
return new Answer(cmd, false, msg);
} else {
needsExport = true;
}
String reverseRecordContent = cmd.getRecordName() + '.' + cmd.getNetworkDomain();
if (createOrUpdateReverse(cmd.getRecordIp(), reverseRecordContent, cmd.getReverseTemplateId(), cmd.isOverride())) {
needsExport = true;
} else {
if (!cmd.isOverride()) {
String msg = "Unable to create reverse record " + cmd.getRecordName() + " for ip " + cmd.getRecordIp();
msg += ". Override record option is false, maybe record already exist.";
return new Answer(cmd, false, msg);
}
}
return new Answer(cmd);
} catch (GloboDnsException e) {
return new Answer(cmd, false, e.getMessage());
} finally {
if (needsExport) {
scheduleExportChangesToBind();
}
}
}
protected boolean createOrUpdateReverse(String networkIp, String reverseRecordContent, Long templateId, boolean override) {
String reverseDomainName = generateReverseDomainNameFromNetworkIp(networkIp);
Domain reverseDomain = searchDomain(reverseDomainName, true);
if (reverseDomain == null) {
reverseDomain = _globoDns.getDomainAPI().createReverseDomain(reverseDomainName, templateId, DEFAULT_AUTHORITY_TYPE);
s_logger.info("Created reverse domain " + reverseDomainName + " with template " + templateId);
}
// create reverse
String reverseRecordName = generateReverseRecordNameFromNetworkIp(networkIp);
return createOrUpdateRecord(reverseDomain.getId(), reverseRecordName, reverseRecordContent, REVERSE_RECORD_TYPE, override);
}
public Answer execute(CreateOrUpdateDomainCommand cmd) {
boolean needsExport = false;
try {
Domain domain = searchDomain(cmd.getDomainName(), false);
if (domain == null) {
// create
domain = _globoDns.getDomainAPI().createDomain(cmd.getDomainName(), cmd.getTemplateId(), DEFAULT_AUTHORITY_TYPE);
s_logger.info("Created domain " + cmd.getDomainName() + " with template " + cmd.getTemplateId());
if (domain == null) {
return new Answer(cmd, false, "Unable to create domain " + cmd.getDomainName());
} else {
needsExport = true;
}
} else {
s_logger.warn("Domain " + cmd.getDomainName() + " already exist.");
}
return new Answer(cmd);
} catch (GloboDnsException e) {
return new Answer(cmd, false, e.getMessage());
} finally {
if (needsExport) {
scheduleExportChangesToBind();
}
}
}
/**
* Try to remove a record from bindZoneName. If record was removed returns true.
* @param recordName
* @param bindZoneName
* @return true if record exists and was removed.
*/
protected boolean removeRecord(String recordName, String recordValue, String bindZoneName, boolean reverse, boolean override) {
Domain domain = searchDomain(bindZoneName, reverse);
if (domain == null) {
s_logger.warn("Domain " + bindZoneName + " doesn't exists in GloboDNS. Record " + recordName + " has already been removed.");
return false;
}
Record record = searchRecord(recordName, domain.getId());
if (record == null) {
s_logger.warn("Record " + recordName + " in domain " + bindZoneName + " has already been removed.");
return false;
} else {
if (!override && !record.getContent().equals(recordValue)) {
s_logger.warn("Record " + recordName + " in domain " + bindZoneName + " have different value from " + recordValue
+ " and override is not enable. I will not delete it.");
return false;
}
_globoDns.getRecordAPI().removeRecord(record.getId());
}
return true;
}
/**
* Create a new record in Zone, or update it if record has been exists.
* @param domainId
* @param name
* @param ip
* @param type
* @return if record was created or updated.
*/
private boolean createOrUpdateRecord(Long domainId, String name, String ip, String type, boolean override) {
Record record = this.searchRecord(name, domainId);
if (record == null) {
// Create new record
record = _globoDns.getRecordAPI().createRecord(domainId, name, ip, type);
s_logger.info("Created record " + record.getName() + " in domain " + domainId);
} else {
if (!ip.equals(record.getContent())) {
if (Boolean.TRUE.equals(override)) {
// ip is incorrect. Fix.
_globoDns.getRecordAPI().updateRecord(record.getId(), domainId, name, ip);
} else {
return false;
}
}
}
return true;
}
/**
* GloboDns export all changes to Bind server.
*/
public void scheduleExportChangesToBind() {
try {
Export export = _globoDns.getExportAPI().scheduleExport();
if (export != null) {
s_logger.info("GloboDns Export: " + export.getResult());
}
} catch (GloboDnsException e) {
s_logger.warn("Error on scheduling export. Although everything was persist, someone need to manually force export in GloboDns", e);
}
}
/**
* Try to find bindZoneName in GloboDns.
* @param name
* @return Domain object or null if domain not exists.
*/
private Domain searchDomain(String name, boolean reverse) {
if (name == null) {
return null;
}
List<Domain> candidates;
if (reverse) {
candidates = _globoDns.getDomainAPI().listReverseByQuery(name);
} else {
candidates = _globoDns.getDomainAPI().listByQuery(name);
}
for (Domain candidate : candidates) {
if (name.equals(candidate.getName())) {
return candidate;
}
}
return null;
}
/**
* Find recordName in domain.
* @param recordName
* @param domainId Id of BindZoneName. Maybe you need use searchDomain before to use BindZoneName.
* @return Record or null if not exists.
*/
private Record searchRecord(String recordName, Long domainId) {
if (recordName == null || domainId == null) {
return null;
}
List<Record> candidates = _globoDns.getRecordAPI().listByQuery(domainId, recordName);
// GloboDns search name in name and content. We need to iterate to check if recordName exists only in name
for (Record candidate : candidates) {
if (recordName.equalsIgnoreCase(candidate.getName())) {
s_logger.debug("Record " + recordName + " in domain id " + domainId + " found in GloboDNS");
return candidate;
}
}
s_logger.debug("Record " + recordName + " in domain id " + domainId + " not found in GloboDNS");
return null;
}
/**
* Generate reverseBindZoneName of network. We ALWAYS use /24.
* @param networkIp
* @return Bind Zone Name reverse of network specified by networkIp
*/
private String generateReverseDomainNameFromNetworkIp(String networkIp) {
String[] octets = networkIp.split("\\.");
String reverseDomainName = octets[2] + '.' + octets[1] + '.' + octets[0] + '.' + REVERSE_DOMAIN_SUFFIX;
return reverseDomainName;
}
private String generateReverseRecordNameFromNetworkIp(String networkIp) {
String[] octets = networkIp.split("\\.");
String reverseRecordName = octets[3];
return reverseRecordName;
}
}