You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by bh...@apache.org on 2014/08/24 16:04:31 UTC
[11/50] [abbrv] CLOUDSTACK-6998: GloboDNS,
Integration with external DNS Provider
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/233445ed/plugins/network-elements/globodns/test/com/globo/globodns/cloudstack/resource/GloboDnsResourceTest.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/globodns/test/com/globo/globodns/cloudstack/resource/GloboDnsResourceTest.java b/plugins/network-elements/globodns/test/com/globo/globodns/cloudstack/resource/GloboDnsResourceTest.java
new file mode 100644
index 0000000..0fd0e11
--- /dev/null
+++ b/plugins/network-elements/globodns/test/com/globo/globodns/cloudstack/resource/GloboDnsResourceTest.java
@@ -0,0 +1,447 @@
+package com.globo.globodns.cloudstack.resource;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.any;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InOrder;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import com.cloud.agent.api.Answer;
+import com.globo.globodns.client.GloboDns;
+import com.globo.globodns.client.api.DomainAPI;
+import com.globo.globodns.client.api.ExportAPI;
+import com.globo.globodns.client.api.RecordAPI;
+import com.globo.globodns.client.model.Domain;
+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;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
+@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
+public class GloboDnsResourceTest {
+
+ private GloboDnsResource _globoDnsResource;
+
+ private GloboDns _globoDnsApi;
+ private DomainAPI _domainApi;
+ private RecordAPI _recordApi;
+ private ExportAPI _exportApi;
+
+ private static final Long TEMPLATE_ID = 1l;
+
+ private static long sequenceId = 10l;
+
+ @Before
+ public void setUp() throws Exception {
+ // ComponentContext.initComponentsLifeCycle();
+
+ String name = "GloboDNS";
+ Map<String, Object> params = new HashMap<String, Object>();
+ params.put("zoneId", "1");
+ params.put("guid", "globodns");
+ params.put("name", name);
+ params.put("url", "http://example.com");
+ params.put("username", "username");
+ params.put("password", "password");
+
+ _globoDnsResource = new GloboDnsResource();
+ _globoDnsResource.configure(name, params);
+
+ _globoDnsApi = spy(_globoDnsResource._globoDns);
+ _globoDnsResource._globoDns = _globoDnsApi;
+
+ _domainApi = mock(DomainAPI.class);
+ when(_globoDnsApi.getDomainAPI()).thenReturn(_domainApi);
+
+ _recordApi = mock(RecordAPI.class);
+ when(_globoDnsApi.getRecordAPI()).thenReturn(_recordApi);
+
+ _exportApi = mock(ExportAPI.class);
+ when(_globoDnsApi.getExportAPI()).thenReturn(_exportApi);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ }
+
+ ///////////////////////
+ // Auxiliary Methods //
+ ///////////////////////
+
+ private Domain generateFakeDomain(String domainName, boolean reverse) {
+ Domain domain = new Domain();
+ domain.getDomainAttributes().setId(sequenceId++);
+ domain.getDomainAttributes().setName(domainName);
+ List<Domain> domainList = new ArrayList<Domain>();
+ domainList.add(domain);
+ if (reverse) {
+ when(_domainApi.listReverseByQuery(eq(domainName))).thenReturn(domainList);
+ } else {
+ when(_domainApi.listByQuery(eq(domainName))).thenReturn(domainList);
+ }
+ return domain;
+ }
+
+ private Record generateFakeRecord(Domain domain, String recordName, String recordContent, boolean reverse) {
+ Record record = new Record();
+ if (reverse) {
+ record.getTypePTRRecordAttributes().setName(recordName);
+ record.getTypePTRRecordAttributes().setContent(recordContent);
+ record.getTypePTRRecordAttributes().setDomainId(domain.getId());
+ record.getTypePTRRecordAttributes().setId(sequenceId++);
+ } else {
+ record.getTypeARecordAttributes().setName(recordName);
+ record.getTypeARecordAttributes().setContent(recordContent);
+ record.getTypeARecordAttributes().setDomainId(domain.getId());
+ record.getTypeARecordAttributes().setId(sequenceId++);
+ }
+ List<Record> recordList = new ArrayList<Record>();
+ recordList.add(record);
+ when(_recordApi.listByQuery(eq(domain.getId()), eq(recordName))).thenReturn(recordList);
+ return record;
+ }
+
+ /////////////////////////
+ // Create Domain tests //
+ /////////////////////////
+
+ @Test
+ public void testCreateDomainWithSuccessWhenDomainDoesntExistAndOverrideIsTrue() throws Exception {
+ String domainName = "domain.name.com";
+
+ Domain domain = new Domain();
+ domain.getDomainAttributes().setId(sequenceId++);
+ domain.getDomainAttributes().setName(domainName);
+
+ when(_domainApi.createDomain(eq(domain.getName()), eq(TEMPLATE_ID), eq("M"))).thenReturn(domain);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateDomainCommand(domainName, TEMPLATE_ID));
+ assertNotNull(answer);
+ assertEquals(true, answer.getResult());
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ @Test
+ @SuppressWarnings("unused")
+ public void testCreateDomainWillSucceedWhenDomainAlreadyExistsAndOverrideIsFalse() throws Exception {
+ String domainName = "domain.name.com";
+
+ Domain domain = generateFakeDomain(domainName, false);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateDomainCommand(domainName, TEMPLATE_ID));
+ assertNotNull(answer);
+ assertEquals(true, answer.getResult());
+ }
+
+ /////////////////////////
+ // Create Record tests //
+ /////////////////////////
+
+ @Test
+ @SuppressWarnings("unused")
+ public void testCreateRecordAndReverseWithSuccessWhenDomainExistsAndRecordDoesntExistAndOverrideIsTrue() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "20.30.40.in-addr.arpa";
+ String reverseRecordName = "10";
+ String reverseRecordContent = recordName + "." + domainName;
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, recordIp, false);
+ Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
+ Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, reverseRecordContent, true);
+
+ when(_recordApi.createRecord(eq(domain.getId()), eq(recordName), eq(recordIp), eq("A"))).thenReturn(record);
+ when(_recordApi.createRecord(eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent), eq("PTR"))).thenReturn(record);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, true));
+ assertNotNull(answer);
+ assertEquals(true, answer.getResult());
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ @Test
+ @SuppressWarnings("unused")
+ public void testCreateRecordAndReverseWillFailWhenRecordAlreadyExistsAndOverrideIsFalse() throws Exception {
+ String recordName = "recordname";
+ String newIp = "40.30.20.10";
+ String oldIp = "50.40.30.20";
+ String domainName = "domain.name.com";
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, oldIp, false);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, newIp, domainName, TEMPLATE_ID, false));
+ assertNotNull(answer);
+ assertEquals(false, answer.getResult());
+ }
+
+ @Test
+ @SuppressWarnings("unused")
+ public void testCreateRecordAndReverseWillFailWhenReverseRecordAlreadyExistsAndOverrideIsFalse() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "20.30.40.in-addr.arpa";
+ String reverseRecordName = "10";
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, recordIp, false);
+ Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
+ Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, "X", true);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, false));
+ assertNotNull(answer);
+ assertEquals(false, answer.getResult());
+ }
+
+ @Test
+ public void testCreateRecordAndReverseWhenDomainDoesNotExist() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "20.30.40.in-addr.arpa";
+ String reverseRecordName = "10";
+ String reverseRecordContent = recordName + "." + domainName;
+
+ Domain domain = new Domain();
+ domain.getDomainAttributes().setId(sequenceId++);
+ Domain reverseDomain = new Domain();
+ reverseDomain.getDomainAttributes().setId(sequenceId++);
+
+ Record record = new Record();
+
+ when(_domainApi.listByQuery(domainName)).thenReturn(new ArrayList<Domain>());
+ when(_domainApi.createDomain(eq(domainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(domain);
+ when(_recordApi.createRecord(eq(domain.getId()), eq(recordName), eq(recordIp), eq("A"))).thenReturn(record);
+ when(_domainApi.createReverseDomain(eq(reverseDomainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(reverseDomain);
+ when(_recordApi.createRecord(eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent), eq("PTR"))).thenReturn(record);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, true));
+ assertNotNull(answer);
+ assertEquals(true, answer.getResult());
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ @Test
+ public void testCreateRecordAndReverseWhenDomainDoesNotExistAndOverrideIsFalse() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "20.30.40.in-addr.arpa";
+ String reverseRecordName = "10";
+ String reverseRecordContent = recordName + "." + domainName;
+
+ Domain domain = new Domain();
+ domain.getDomainAttributes().setId(sequenceId++);
+ Domain reverseDomain = new Domain();
+ reverseDomain.getDomainAttributes().setId(sequenceId++);
+
+ Record record = new Record();
+
+ when(_domainApi.listByQuery(domainName)).thenReturn(new ArrayList<Domain>());
+ when(_domainApi.createDomain(eq(domainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(domain);
+ when(_recordApi.createRecord(eq(domain.getId()), eq(recordName), eq(recordIp), eq("A"))).thenReturn(record);
+ when(_domainApi.createReverseDomain(eq(reverseDomainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(reverseDomain);
+ when(_recordApi.createRecord(eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent), eq("PTR"))).thenReturn(record);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, false));
+ assertNotNull(answer);
+ assertEquals(true, answer.getResult());
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ /////////////////////////
+ // Update Record tests //
+ /////////////////////////
+
+ @Test
+ public void testUpdateRecordAndReverseWhenDomainExistsAndOverrideIsTrue() throws Exception {
+ String recordName = "recordname";
+ String oldRecordIp = "40.30.20.10";
+ String newRecordIp = "50.40.30.20";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "30.40.50.in-addr.arpa";
+ String reverseRecordName = "20";
+ String reverseRecordContent = recordName + "." + domainName;
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, oldRecordIp, false);
+ Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
+ Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, "X", true);
+
+ Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, newRecordIp, domainName, TEMPLATE_ID, true));
+
+ // ensure calls in sequence to ensure this call are the only ones.
+ InOrder inOrder = inOrder(_recordApi);
+ inOrder.verify(_recordApi, times(1)).updateRecord(eq(record.getId()), eq(domain.getId()), eq(recordName), eq(newRecordIp));
+ inOrder.verify(_recordApi, times(1)).updateRecord(eq(reverseRecord.getId()), eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent));
+
+ assertNotNull(answer);
+ assertEquals(true, answer.getResult());
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ /////////////////////////
+ // Remove Record tests //
+ /////////////////////////
+
+ @Test
+ public void testRemoveRecordWhenRecordExists() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "20.30.40.in-addr.arpa";
+ String reverseRecordName = "10";
+ String reverseRecordContent = recordName + "." + domainName;
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, recordIp, false);
+ Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
+ Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, reverseRecordContent, true);
+
+ Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, true));
+
+ assertNotNull(answer);
+ assertEquals(true, answer.getResult());
+ verify(_recordApi, times(1)).removeRecord(eq(record.getId()));
+ verify(_recordApi, times(1)).removeRecord(eq(reverseRecord.getId()));
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ @Test
+ public void testRemoveRecordWithSuccessAndReverseRecordNotRemovedWhenReverseRecordExistsWithDifferentValueAndOverrideIsFalse() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "20.30.40.in-addr.arpa";
+ String reverseRecordName = "10";
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, recordIp, false);
+ Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
+ Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, "X", true);
+
+ Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, false));
+
+ assertEquals(true, answer.getResult());
+ verify(_recordApi, times(1)).removeRecord(eq(record.getId()));
+ verify(_recordApi, never()).removeRecord(eq(reverseRecord.getId()));
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ @Test
+ public void testRemoveReverseRecordButNotRemoveRecordWhenRecordExistsWithDifferentValueAndOverrideIsFalse() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+ String reverseDomainName = "20.30.40.in-addr.arpa";
+ String reverseRecordName = "10";
+ String reverseRecordContent = recordName + "." + domainName;
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, "X", false);
+ Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
+ Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, reverseRecordContent, true);
+
+ Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, false));
+
+ assertEquals(true, answer.getResult());
+ verify(_recordApi, never()).removeRecord(eq(record.getId()));
+ verify(_recordApi, times(1)).removeRecord(eq(reverseRecord.getId()));
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ /////////////////////////
+ // Remove Domain tests //
+ /////////////////////////
+
+ @Test
+ public void testRemoveDomainWithSuccessButDomainKeptWhenDomainExistsAndThereAreRecordsAndOverrideIsFalse() throws Exception {
+ String recordName = "recordname";
+ String recordIp = "40.30.20.10";
+ String domainName = "domain.name.com";
+
+ Domain domain = generateFakeDomain(domainName, false);
+ Record record = generateFakeRecord(domain, recordName, "X", false);
+ when(_recordApi.listAll(domain.getId())).thenReturn(Arrays.asList(record));
+
+ Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, false));
+
+ assertEquals(true, answer.getResult());
+ verify(_domainApi, never()).removeDomain(any(Long.class));
+ verify(_exportApi, never()).scheduleExport();
+ }
+
+ @Test
+ public void testRemoveDomainWithSuccessWhenDomainExistsAndThereAreOnlyNSRecordsAndOverrideIsFalse() throws Exception {
+ String domainName = "domain.name.com";
+
+ Domain domain = generateFakeDomain(domainName, false);
+ List<Record> recordList = new ArrayList<Record>();
+ for (int i = 0; i < 10; i++) {
+ Record record = new Record();
+ record.getTypeNSRecordAttributes().setDomainId(domain.getId());
+ record.getTypeNSRecordAttributes().setId(sequenceId++);
+ record.getTypeNSRecordAttributes().setType("NS");
+ recordList.add(record);
+ }
+ when(_recordApi.listAll(domain.getId())).thenReturn(recordList);
+
+ Answer answer = _globoDnsResource.execute(new RemoveDomainCommand(domainName, false));
+
+ assertEquals(true, answer.getResult());
+ verify(_domainApi, times(1)).removeDomain(eq(domain.getId()));
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+ @Test
+ public void testRemoveDomainWithSuccessWhenDomainExistsAndThereAreRecordsAndOverrideIsTrue() throws Exception {
+ String domainName = "domain.name.com";
+
+ Domain domain = generateFakeDomain(domainName, false);
+ List<Record> recordList = new ArrayList<Record>();
+ for (int i = 0; i < 10; i++) {
+ Record record = new Record();
+ record.getTypeNSRecordAttributes().setDomainId(domain.getId());
+ record.getTypeNSRecordAttributes().setId(sequenceId++);
+ record.getTypeNSRecordAttributes().setType(new String[] {"A", "NS", "PTR"}[i % 3]);
+ recordList.add(record);
+ }
+ when(_recordApi.listAll(domain.getId())).thenReturn(recordList);
+
+ Answer answer = _globoDnsResource.execute(new RemoveDomainCommand(domainName, true));
+
+ assertEquals(true, answer.getResult());
+ verify(_domainApi, times(1)).removeDomain(eq(domain.getId()));
+ verify(_exportApi, times(1)).scheduleExport();
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/233445ed/plugins/network-elements/globodns/test/resources/db.properties
----------------------------------------------------------------------
diff --git a/plugins/network-elements/globodns/test/resources/db.properties b/plugins/network-elements/globodns/test/resources/db.properties
new file mode 100644
index 0000000..0dd35f6
--- /dev/null
+++ b/plugins/network-elements/globodns/test/resources/db.properties
@@ -0,0 +1,75 @@
+# 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.
+
+
+# management server clustering parameters, change cluster.node.IP to the machine IP address
+# in which the management server(Tomcat) is running
+cluster.node.IP=127.0.0.1
+cluster.servlet.port=9090
+region.id=1
+
+# CloudStack database settings
+db.cloud.username=cloud
+db.cloud.password=cloud
+db.root.password=
+db.cloud.host=localhost
+db.cloud.port=3306
+db.cloud.name=cloud
+
+# CloudStack database tuning parameters
+db.cloud.maxActive=250
+db.cloud.maxIdle=30
+db.cloud.maxWait=10000
+db.cloud.autoReconnect=true
+db.cloud.validationQuery=SELECT 1
+db.cloud.testOnBorrow=true
+db.cloud.testWhileIdle=true
+db.cloud.timeBetweenEvictionRunsMillis=40000
+db.cloud.minEvictableIdleTimeMillis=240000
+db.cloud.poolPreparedStatements=false
+db.cloud.url.params=prepStmtCacheSize=517&cachePrepStmts=true&prepStmtCacheSqlLimit=4096
+
+# usage database settings
+db.usage.username=cloud
+db.usage.password=cloud
+db.usage.host=localhost
+db.usage.port=3306
+db.usage.name=cloud_usage
+
+# usage database tuning parameters
+db.usage.maxActive=100
+db.usage.maxIdle=30
+db.usage.maxWait=10000
+db.usage.autoReconnect=true
+
+# awsapi database settings
+db.awsapi.username=cloud
+db.awsapi.password=cloud
+db.awsapi.host=localhost
+db.awsapi.port=3306
+db.awsapi.name=cloudbridge
+
+# Simulator database settings
+db.simulator.username=cloud
+db.simulator.password=cloud
+db.simulator.host=localhost
+db.simulator.port=3306
+db.simulator.name=simulator
+db.simulator.maxActive=250
+db.simulator.maxIdle=30
+db.simulator.maxWait=10000
+db.simulator.autoReconnect=true
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/233445ed/plugins/network-elements/globodns/test/resources/log4j.properties
----------------------------------------------------------------------
diff --git a/plugins/network-elements/globodns/test/resources/log4j.properties b/plugins/network-elements/globodns/test/resources/log4j.properties
new file mode 100644
index 0000000..32322a0
--- /dev/null
+++ b/plugins/network-elements/globodns/test/resources/log4j.properties
@@ -0,0 +1,16 @@
+# Define the root logger with appender file
+#log = /var/log/log4j
+#log4j.rootLogger = DEBUG, FILE
+log4j.rootLogger = DEBUG, stdout
+
+# File appender
+#log4j.appender.FILE=org.apache.log4j.FileAppender
+#log4j.appender.FILE.File=${log}/log.out
+#log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
+#log4j.appender.FILE.layout.conversionPattern=%m%n
+
+# Stdout appender
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/233445ed/plugins/pom.xml
----------------------------------------------------------------------
diff --git a/plugins/pom.xml b/plugins/pom.xml
index 0b1b62d..b190ee5 100755
--- a/plugins/pom.xml
+++ b/plugins/pom.xml
@@ -88,6 +88,7 @@
<module>alert-handlers/syslog-alerts</module>
<module>network-elements/internal-loadbalancer</module>
<module>network-elements/vxlan</module>
+ <module>network-elements/globodns</module>
</modules>
<dependencies>
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/233445ed/ui/scripts/system.js
----------------------------------------------------------------------
diff --git a/ui/scripts/system.js b/ui/scripts/system.js
index fe51acb..fdd0f9a 100644
--- a/ui/scripts/system.js
+++ b/ui/scripts/system.js
@@ -7424,7 +7424,211 @@
}
}
}
- }
+ },
+
+ // GloboDns provider detail view
+ GloboDns: {
+ isMaximized: true,
+ type: 'detailView',
+ id: 'globoDnsProvider',
+ label: 'GloboDNS',
+ tabs: {
+ details: {
+ title: 'label.details',
+ fields: [{
+ name: {
+ label: 'label.name'
+ }
+ }, {
+ state: {
+ label: 'label.state'
+ }
+ }],
+ dataProvider: function(args) {
+ refreshNspData("GloboDns");
+ var providerObj;
+ $(nspHardcodingArray).each(function() {
+ if (this.id == "GloboDns") {
+ providerObj = this;
+ return false; //break each loop
+ }
+ });
+ args.response.success({
+ data: providerObj,
+ actionFilter: networkProviderActionFilter('GloboDns')
+ });
+ }
+ },
+ },
+ actions: {
+ add: {
+ label: 'GloboDNS Configuration',
+ createForm: {
+ title: 'GloboDNS Configuration',
+ preFilter: function(args) {},
+ fields: {
+ username: {
+ label: 'Username',
+ validation: {
+ required: true
+ }
+ },
+ password: {
+ label: 'Password',
+ isPassword: true,
+ validation: {
+ required: true
+ }
+ },
+ url: {
+ label: 'URL',
+ validation: {
+ required: true
+ }
+ }
+ }
+ },
+ action: function(args) {
+ if (nspMap["GloboDns"] == null) {
+ $.ajax({
+ url: createURL("addNetworkServiceProvider&name=GloboDns&physicalnetworkid=" + selectedPhysicalNetworkObj.id),
+ dataType: "json",
+ async: true,
+ success: function(json) {
+ var jobId = json.addnetworkserviceproviderresponse.jobid;
+ var addGloboDnsProviderIntervalID = setInterval(function() {
+ $.ajax({
+ url: createURL("queryAsyncJobResult&jobId=" + jobId),
+ dataType: "json",
+ success: function(json) {
+ var result = json.queryasyncjobresultresponse;
+ if (result.jobstatus == 0) {
+ return; //Job has not completed
+ } else {
+ clearInterval(addGloboDnsProviderIntervalID);
+ if (result.jobstatus == 1) {
+ nspMap["GloboDns"] = json.queryasyncjobresultresponse.jobresult.networkserviceprovider;
+ addGloboDnsHost(args, selectedPhysicalNetworkObj, "addGloboDnsHost", "addglobodnshostresponse");
+ } else if (result.jobstatus == 2) {
+ alert("addNetworkServiceProvider&name=GloboDns failed. Error: " + _s(result.jobresult.errortext));
+ }
+ }
+ },
+ error: function(XMLHttpResponse) {
+ var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
+ alert("addNetworkServiceProvider&name=GloboDns failed. Error: " + errorMsg);
+ }
+ });
+ }, g_queryAsyncJobResultInterval);
+ }
+ });
+ } else {
+ addGloboDnsHost(args, selectedPhysicalNetworkObj, "addGloboDnsHost", "addglobodnshostresponse");
+ }
+ },
+ messages: {
+ notification: function(args) {
+ return 'Add GloboDNS';
+ }
+ },
+ notification: {
+ poll: pollAsyncJobResult
+ }
+ },
+ enable: {
+ label: 'label.enable.provider',
+ action: function(args) {
+ $.ajax({
+ url: createURL("updateNetworkServiceProvider&id=" + nspMap["GloboDns"].id + "&state=Enabled"),
+ dataType: "json",
+ success: function(json) {
+ var jid = json.updatenetworkserviceproviderresponse.jobid;
+ args.response.success({
+ _custom: {
+ jobId: jid,
+ getUpdatedItem: function(json) {
+ $(window).trigger('cloudStack.fullRefresh');
+ }
+ }
+ });
+ }
+ });
+ },
+ messages: {
+ confirm: function(args) {
+ return 'message.confirm.enable.provider';
+ },
+ notification: function() {
+ return 'label.enable.provider';
+ }
+ },
+ notification: {
+ poll: pollAsyncJobResult
+ }
+ },
+ disable: {
+ label: 'label.disable.provider',
+ action: function(args) {
+ $.ajax({
+ url: createURL("updateNetworkServiceProvider&id=" + nspMap["GloboDns"].id + "&state=Disabled"),
+ dataType: "json",
+ success: function(json) {
+ var jid = json.updatenetworkserviceproviderresponse.jobid;
+ args.response.success({
+ _custom: {
+ jobId: jid,
+ getUpdatedItem: function(json) {
+ $(window).trigger('cloudStack.fullRefresh');
+ }
+ }
+ });
+ }
+ });
+ },
+ messages: {
+ confirm: function(args) {
+ return 'message.confirm.disable.provider';
+ },
+ notification: function() {
+ return 'label.disable.provider';
+ }
+ },
+ notification: {
+ poll: pollAsyncJobResult
+ }
+ },
+ destroy: {
+ label: 'label.shutdown.provider',
+ action: function(args) {
+ $.ajax({
+ url: createURL("deleteNetworkServiceProvider&id=" + nspMap["GloboDns"].id),
+ dataType: "json",
+ success: function(json) {
+ var jid = json.deletenetworkserviceproviderresponse.jobid;
+ args.response.success({
+ _custom: {
+ jobId: jid
+ }
+ });
+
+ $(window).trigger('cloudStack.fullRefresh');
+ }
+ });
+ },
+ messages: {
+ confirm: function(args) {
+ return 'message.confirm.shutdown.provider';
+ },
+ notification: function(args) {
+ return 'label.shutdown.provider';
+ }
+ },
+ notification: {
+ poll: pollAsyncJobResult
+ }
+ }
+ }
+ }
}
}
},
@@ -19809,7 +20013,30 @@
});
}
});
- }
+ }
+
+ function addGloboDnsHost(args, physicalNetworkObj, apiCmd, apiCmdRes) {
+ var array1 = [];
+ array1.push("&physicalnetworkid=" + physicalNetworkObj.id);
+ array1.push("&username=" + todb(args.data.username));
+ array1.push("&password=" + todb(args.data.password));
+ array1.push("&url=" + todb(args.data.url));
+
+ $.ajax({
+ url: createURL(apiCmd + array1.join("")),
+ dataType: "json",
+ type: "POST",
+ success: function(json) {
+ var jid = json[apiCmdRes].jobid;
+ args.response.success({
+ _custom: {
+ jobId: jid,
+ }
+ });
+ }
+ });
+ }
+
var afterCreateZonePhysicalNetworkTrafficTypes = function (args, newZoneObj, newPhysicalnetwork) {
$.ajax({
@@ -20495,6 +20722,9 @@
case "NuageVsp":
nspMap["nuageVsp"] = items[i];
break;
+ case "GloboDns":
+ nspMap["GloboDns"] = items[i];
+ break;
}
}
}
@@ -20598,6 +20828,11 @@
name: 'Palo Alto',
state: nspMap.pa ? nspMap.pa.state: 'Disabled'
});
+ nspHardcodingArray.push({
+ id: 'GloboDns',
+ name: 'GloboDNS',
+ state: nspMap.GloboDns ? nspMap.GloboDns.state : 'Disabled'
+ });
}
if ($.grep(nspHardcodingArray, function(e) { return e.id == 'Ovs'; }).length == 0 ) {