| /* |
| * 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; |
| } |
| |
| } |
