introduce import and unmanage option for createDnsZone and deleteDnsZone

sudo87 · sudo87 · commit 4972c36f32ed · 2026-04-30T17:01:02.000+05:30
diff --git a/api/src/main/java/org/apache/cloudstack/api/ApiConstants.java b/api/src/main/java/org/apache/cloudstack/api/ApiConstants.java
@@ -1378,7 +1378,8 @@ public class ApiConstants {
     public static final String OLD_STATE = "oldState";
     public static final String NEW_STATE = "newState";
     public static final String OLD_HOST_NAME = "oldHostName";
-
+    public static final String IMPORT = "import";
+    public static final String UNMANAGE = "unmanage";
 
     public static final String PARAMETER_DESCRIPTION_ACTIVATION_RULE = "Quota tariff's activation rule. It can receive a JS script that results in either " +
             "a boolean or a numeric value: if it results in a boolean value, the tariff value will be applied according to the result; if it results in a numeric value, the " +
diff --git a/api/src/main/java/org/apache/cloudstack/api/command/user/dns/CreateDnsZoneCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/user/dns/CreateDnsZoneCmd.java
@@ -66,6 +66,11 @@ public class CreateDnsZoneCmd extends BaseAsyncCreateCmd {
     @Parameter(name = ApiConstants.DESCRIPTION, type = CommandType.STRING, description =  "The description of the DNS zone")
     private String description;
 
+    @Parameter(name = ApiConstants.IMPORT, type = CommandType.BOOLEAN, entityType = DnsZoneResponse.class,
+            description = "If true, imports an existing DNS zone from the DNS provider into CloudStack. " +
+                    "If false, creates the zone in the DNS provider and registers it in CloudStack.")
+    private Boolean importDnsZone = false;
+
     /////////////////////////////////////////////////////
     /////////////////// Accessors ///////////////////////
     /////////////////////////////////////////////////////
@@ -115,7 +120,7 @@ public void create() throws ResourceAllocationException {
     @Override
     public void execute() {
         try {
-            DnsZone result = dnsProviderManager.provisionDnsZone(getEntityId());
+            DnsZone result = dnsProviderManager.provisionDnsZone(getEntityId(), isImportDnsZone());
             if (result != null) {
                 DnsZoneResponse response = dnsProviderManager.createDnsZoneResponse(result);
                 response.setResponseName(getCommandName());
@@ -142,4 +147,8 @@ public String getEventType() {
     public String getEventDescription() {
         return "creating DNS zone: " + getName();
     }
+
+    public Boolean isImportDnsZone() {
+        return Boolean.TRUE.equals(importDnsZone);
+    }
 }
diff --git a/api/src/main/java/org/apache/cloudstack/api/command/user/dns/DeleteDnsZoneCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/user/dns/DeleteDnsZoneCmd.java
@@ -51,6 +51,11 @@ public class DeleteDnsZoneCmd extends BaseAsyncCmd {
             description = "The ID of the DNS zone")
     private Long id;
 
+    @Parameter(name = ApiConstants.UNMANAGE, type = CommandType.BOOLEAN, entityType = DnsZoneResponse.class,
+            description = "If true, removes the DNS zone from CloudStack; if false, " +
+                    "removes it from both CloudStack and the DNS provider.")
+    private Boolean unmanage = false;
+
     /////////////////////////////////////////////////////
     /////////////////// Accessors ///////////////////////
     /////////////////////////////////////////////////////
@@ -66,7 +71,7 @@ public Long getId() {
     @Override
     public void execute() {
         try {
-            boolean result = dnsProviderManager.deleteDnsZone(getId());
+            boolean result = dnsProviderManager.deleteDnsZone(getId(), isUnmanage());
             if (result) {
                 SuccessResponse response = new SuccessResponse(getCommandName());
                 setResponseObject(response);
@@ -97,4 +102,8 @@ public String getEventType() {
     public String getEventDescription() {
         return "Deleting DNS Zone ID: " + getId();
     }
+
+    public Boolean isUnmanage() {
+        return Boolean.TRUE.equals(unmanage);
+    }
 }
diff --git a/api/src/main/java/org/apache/cloudstack/dns/DnsProvider.java b/api/src/main/java/org/apache/cloudstack/dns/DnsProvider.java
@@ -41,4 +41,5 @@ public interface DnsProvider extends Adapter {
     String updateRecord(DnsServer server, DnsZone zone, DnsRecord record) throws DnsProviderException;
     String deleteRecord(DnsServer server, DnsZone zone, DnsRecord record) throws DnsProviderException;
     boolean dnsRecordExists(DnsServer server, DnsZone zone, String recordName, String recordType) throws DnsProviderException;
+    boolean dnsZoneExists(DnsServer server, DnsZone zone);
 }
diff --git a/api/src/main/java/org/apache/cloudstack/dns/DnsProviderManager.java b/api/src/main/java/org/apache/cloudstack/dns/DnsProviderManager.java
@@ -52,10 +52,10 @@ public interface DnsProviderManager extends Manager, PluggableService {
     // Allocates the DB row (State: Inactive)
     DnsZone allocateDnsZone(CreateDnsZoneCmd cmd);
     // Calls the Plugin (State: Inactive -> Active)
-    DnsZone provisionDnsZone(long zoneId);
+    DnsZone provisionDnsZone(long zoneId, boolean isImport);
 
     DnsZone updateDnsZone(UpdateDnsZoneCmd cmd);
-    boolean deleteDnsZone(Long id);
+    boolean deleteDnsZone(Long id, boolean isUnmanage);
     ListResponse<DnsZoneResponse> listDnsZones(ListDnsZonesCmd cmd);
 
     DnsRecordResponse createDnsRecord(CreateDnsRecordCmd cmd);
diff --git a/api/src/test/java/org/apache/cloudstack/api/command/user/dns/CreateDnsZoneCmdTest.java b/api/src/test/java/org/apache/cloudstack/api/command/user/dns/CreateDnsZoneCmdTest.java
@@ -127,7 +127,7 @@ public void testExecuteSuccess() throws Exception {
         DnsZoneResponse mockResponse = new DnsZoneResponse();
         mockResponse.setName("example.com");
 
-        when(dnsProviderManager.provisionDnsZone(ENTITY_ID)).thenReturn(mockZone);
+        when(dnsProviderManager.provisionDnsZone(ENTITY_ID, false)).thenReturn(mockZone);
         when(dnsProviderManager.createDnsZoneResponse(mockZone)).thenReturn(mockResponse);
 
         cmd.execute();
@@ -142,7 +142,7 @@ public void testExecuteReturnsNull() throws Exception {
         CreateDnsZoneCmd cmd = createCmd();
         cmd.setEntityId(ENTITY_ID);
 
-        when(dnsProviderManager.provisionDnsZone(ENTITY_ID)).thenReturn(null);
+        when(dnsProviderManager.provisionDnsZone(ENTITY_ID, false)).thenReturn(null);
         cmd.execute();
     }
 
@@ -151,7 +151,7 @@ public void testExecuteThrowsException() throws Exception {
         CreateDnsZoneCmd cmd = createCmd();
         cmd.setEntityId(ENTITY_ID);
 
-        when(dnsProviderManager.provisionDnsZone(ENTITY_ID)).thenThrow(new RuntimeException("Provider error"));
+        when(dnsProviderManager.provisionDnsZone(ENTITY_ID, false)).thenThrow(new RuntimeException("Provider error"));
         cmd.execute();
     }
 }
diff --git a/api/src/test/java/org/apache/cloudstack/api/command/user/dns/DeleteDnsZoneCmdTest.java b/api/src/test/java/org/apache/cloudstack/api/command/user/dns/DeleteDnsZoneCmdTest.java
@@ -79,26 +79,26 @@ public void testEventDescription() throws Exception {
     @Test
     public void testExecuteSuccess() throws Exception {
         DeleteDnsZoneCmd cmd = createCmd();
-        when(dnsProviderManager.deleteDnsZone(ENTITY_ID)).thenReturn(true);
+        when(dnsProviderManager.deleteDnsZone(ENTITY_ID, false)).thenReturn(true);
 
         cmd.execute();
 
         SuccessResponse response = (SuccessResponse) cmd.getResponseObject();
         assertNotNull(response);
-        verify(dnsProviderManager).deleteDnsZone(ENTITY_ID);
+        verify(dnsProviderManager).deleteDnsZone(ENTITY_ID, false);
     }
 
     @Test(expected = ServerApiException.class)
     public void testExecuteReturnsFalse() throws Exception {
         DeleteDnsZoneCmd cmd = createCmd();
-        when(dnsProviderManager.deleteDnsZone(ENTITY_ID)).thenReturn(false);
+        when(dnsProviderManager.deleteDnsZone(ENTITY_ID, false)).thenReturn(false);
         cmd.execute();
     }
 
     @Test(expected = ServerApiException.class)
     public void testExecuteThrowsException() throws Exception {
         DeleteDnsZoneCmd cmd = createCmd();
-        when(dnsProviderManager.deleteDnsZone(ENTITY_ID)).thenThrow(new RuntimeException("Error"));
+        when(dnsProviderManager.deleteDnsZone(ENTITY_ID, false)).thenThrow(new RuntimeException("Error"));
         cmd.execute();
     }
 }
diff --git a/engine/schema/src/main/resources/META-INF/db/schema-42210to42300.sql b/engine/schema/src/main/resources/META-INF/db/schema-42210to42300.sql
@@ -118,6 +118,15 @@ CALL `cloud`.`IDEMPOTENT_ADD_COLUMN`('cloud.vpc_offerings','conserve_mode', 'tin
 --- Disable/enable NICs
 CALL `cloud`.`IDEMPOTENT_ADD_COLUMN`('cloud.nics','enabled', 'TINYINT(1) NOT NULL DEFAULT 1 COMMENT ''Indicates whether the NIC is enabled or not'' ');
 
+--- Quota tariff/usage mapping
+CREATE TABLE IF NOT EXISTS `cloud_usage`.`quota_tariff_usage` (
+    `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+    `tariff_id` bigint(20) unsigned NOT NULL COMMENT 'ID of the tariff of the Quota usage detail calculated, foreign key to quota_tariff table',
+    `quota_usage_id` bigint(20) unsigned NOT NULL COMMENT 'ID of the aggregation of Quota usage details, foreign key to quota_usage table',
+    `quota_used` decimal(20,8) NOT NULL COMMENT 'Amount of quota used',
+    PRIMARY KEY (`id`),
+    CONSTRAINT `fk_quota_tariff_usage__tariff_id` FOREIGN KEY (`tariff_id`) REFERENCES `cloud_usage`.`quota_tariff` (`id`),
+    CONSTRAINT `fk_quota_tariff_usage__quota_usage_id` FOREIGN KEY (`quota_usage_id`) REFERENCES `cloud_usage`.`quota_usage` (`id`));
 
 -- ======================================================================
 -- DNS Framework Schema
diff --git a/plugins/dns/powerdns/src/main/java/org/apache/cloudstack/dns/powerdns/PowerDnsClient.java b/plugins/dns/powerdns/src/main/java/org/apache/cloudstack/dns/powerdns/PowerDnsClient.java
@@ -240,7 +240,20 @@ public Iterable<JsonNode> listRecords(String baseUrl, Integer port, String apiKe
         return rrsets.isArray() ? rrsets : Collections.emptyList();
     }
 
-    public boolean dnsRecordExists(String baseUrl, Integer port, String apiKey,
+    public boolean zoneExists(String baseUrl, Integer port, String apiKey, String externalServerId, String zoneName) {
+        try {
+            validateServerId(baseUrl, port, apiKey, externalServerId);
+            String normalizedZone = normalizeZone(zoneName);
+            String encodedZone = URLEncoder.encode(normalizedZone, StandardCharsets.UTF_8);
+            HttpGet request = new HttpGet(buildUrl(baseUrl, port, "/servers/" + externalServerId + "/zones/" + encodedZone));
+            execute(request, apiKey, 200);
+            return true;
+        } catch (DnsProviderException | IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    public boolean recordExists(String baseUrl, Integer port, String apiKey,
                                 String externalServerId, String zoneName,
                                 String recordName, String type) throws DnsProviderException {
 
diff --git a/plugins/dns/powerdns/src/main/java/org/apache/cloudstack/dns/powerdns/PowerDnsProvider.java b/plugins/dns/powerdns/src/main/java/org/apache/cloudstack/dns/powerdns/PowerDnsProvider.java
@@ -159,10 +159,15 @@ public List<DnsRecord> listRecords(DnsServer server, DnsZone zone) throws DnsPro
     }
 
     public boolean dnsRecordExists(DnsServer server, DnsZone zone, String recordName, String recordType) throws DnsProviderException {
-        return client.dnsRecordExists(server.getUrl(), server.getPort(), server.getDnsApiKey(),
+        return client.recordExists(server.getUrl(), server.getPort(), server.getDnsApiKey(),
                 server.getDetail(PDNS_SERVER_ID), zone.getName(), recordName, recordType);
     }
 
+    @Override
+    public boolean dnsZoneExists(DnsServer server, DnsZone zone) {
+        return client.zoneExists(server.getUrl(), server.getPort(), server.getDnsApiKey(), server.getDetail(PDNS_SERVER_ID), zone.getName());
+    }
+
     void validateRequiredServerAndZoneFields(DnsServer server, DnsZone zone) {
         validateRequiredServerFields(server);
         if (StringUtils.isBlank(zone.getName())) {
diff --git a/plugins/dns/powerdns/src/test/java/org/apache/cloudstack/dns/powerdns/PowerDnsClientTest.java b/plugins/dns/powerdns/src/test/java/org/apache/cloudstack/dns/powerdns/PowerDnsClientTest.java
@@ -354,7 +354,7 @@ public void testExecuteThrowsUnexpectedStatus() throws Exception {
         client.validateServerId("http://pdns", 8081, "apikey", "abc");
     }
     // Route helper: GET /servers/abc → validate; GET /zones/... → zone response
-    private void mockDnsRecordExists(String zoneJson) throws IOException {
+    private void mockRecordExists(String zoneJson) throws IOException {
         when(httpClientMock.execute(any(HttpUriRequest.class))).thenAnswer(new Answer<CloseableHttpResponse>() {
             @Override
             public CloseableHttpResponse answer(InvocationOnMock invocation) {
@@ -373,42 +373,42 @@ public CloseableHttpResponse answer(InvocationOnMock invocation) {
     }
 
     @Test
-    public void testDnsRecordExistsZoneNodeNull() throws Exception {
+    public void testRecordExistsZoneNodeNull() throws Exception {
         // execute() returns null → zoneNode == null → false
-        mockDnsRecordExists(null);
-        boolean result = client.dnsRecordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
+        mockRecordExists(null);
+        boolean result = client.recordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
         assertEquals(false, result);
     }
 
     @Test
-    public void testDnsRecordExistsMissingRrSetsField() throws Exception {
+    public void testRecordExistsMissingRrSetsField() throws Exception {
         // response has no "rrsets" key → !zoneNode.has(RR_SETS) → false
-        mockDnsRecordExists("{}");
-        boolean result = client.dnsRecordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
+        mockRecordExists("{}");
+        boolean result = client.recordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
         assertEquals(false, result);
     }
 
     @Test
-    public void testDnsRecordExistsRrSetsNotArray() throws Exception {
+    public void testRecordExistsRrSetsNotArray() throws Exception {
         // rrsets is a scalar string, not an ArrayNode → isArray() == false → false
-        mockDnsRecordExists("{\"rrsets\":\"not-an-array\"}");
-        boolean result = client.dnsRecordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
+        mockRecordExists("{\"rrsets\":\"not-an-array\"}");
+        boolean result = client.recordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
         assertEquals(false, result);
     }
 
     @Test
-    public void testDnsRecordExistsEmptyRrSetsArray() throws Exception {
+    public void testRecordExistsEmptyRrSetsArray() throws Exception {
         // rrsets is an empty array → isArray() == true && isEmpty() == true → false
-        mockDnsRecordExists("{\"rrsets\":[]}");
-        boolean result = client.dnsRecordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
+        mockRecordExists("{\"rrsets\":[]}");
+        boolean result = client.recordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
         assertEquals(false, result);
     }
 
     @Test
-    public void testDnsRecordExistsNonEmptyRrSetsArray() throws Exception {
+    public void testRecordExistsNonEmptyRrSetsArray() throws Exception {
         // rrsets is a non-empty array → isArray() == true && !isEmpty() → true
-        mockDnsRecordExists("{\"rrsets\":[{\"name\":\"www.example.com.\",\"type\":\"A\"}]}");
-        boolean result = client.dnsRecordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
+        mockRecordExists("{\"rrsets\":[{\"name\":\"www.example.com.\",\"type\":\"A\"}]}");
+        boolean result = client.recordExists("http://pdns", 8081, "apikey", "abc", "example.com", "www", "A");
         assertEquals(true, result);
     }
 
diff --git a/server/src/main/java/org/apache/cloudstack/dns/DnsProviderManagerImpl.java b/server/src/main/java/org/apache/cloudstack/dns/DnsProviderManagerImpl.java
@@ -316,7 +316,7 @@ public boolean deleteDnsServer(DeleteDnsServerCmd cmd) {
                 List<DnsZoneVO> dnsZones = dnsZoneDao.findDnsZonesByServerId(dnsServerId);
                 for (DnsZoneVO dnsZone : dnsZones) {
                     try {
-                        deleteDnsZone(dnsZone.getId());
+                        deleteDnsZone(dnsZone.getId(), false);
                     } catch (Exception ex) {
                         logger.error("Error cleaning up DNS zone: {} during DNS server: {} deletion", dnsZone.getName(), dnsServer.getName());
                     }
@@ -328,7 +328,7 @@ public boolean deleteDnsServer(DeleteDnsServerCmd cmd) {
 
     @Override
     @ActionEvent(eventType = EventTypes.EVENT_DNS_ZONE_DELETE, eventDescription = "Deleting DNS Zone")
-    public boolean deleteDnsZone(Long zoneId) {
+    public boolean deleteDnsZone(Long zoneId, boolean isUnmanage) {
         DnsZoneVO dnsZone = dnsZoneDao.findById(zoneId);
         if (dnsZone == null) {
             throw new InvalidParameterValueException("DNS zone not found for the given ID.");
@@ -361,14 +361,16 @@ public boolean deleteDnsZone(Long zoneId) {
             }
 
             // Remove DNS zone from provider and cleanup DB
-            try {
-                provider.deleteZone(server, dnsZone);
-                logger.debug("Deleted DNS zone: {} from provider", dnsZoneName);
-            } catch (DnsNotFoundException ex) {
-                logger.warn("DNS zone: {} is not present in the provider, proceeding with cleanup", dnsZoneName);
-            } catch (Exception ex) {
-                logger.error("Failed to delete DNS zone from provider", ex);
-                throw new CloudRuntimeException(String.format("Failed to delete DNS zone: %s.", dnsZoneName));
+            if (!isUnmanage) {
+                try {
+                    provider.deleteZone(server, dnsZone);
+                    logger.debug("Deleted DNS zone: {} from provider", dnsZoneName);
+                } catch (DnsNotFoundException ex) {
+                    logger.warn("DNS zone: {} is not present in the provider, proceeding with cleanup", dnsZoneName);
+                } catch (Exception ex) {
+                    logger.error("Failed to delete DNS zone from provider", ex);
+                    throw new CloudRuntimeException(String.format("Failed to delete DNS zone: %s.", dnsZoneName));
+                }
             }
             return dnsZoneDao.remove(zoneId);
         });
@@ -585,16 +587,22 @@ public DnsZone allocateDnsZone(CreateDnsZoneCmd cmd) {
     }
 
     @Override
-    public DnsZone provisionDnsZone(long dnsZoneId) {
+    public DnsZone provisionDnsZone(long dnsZoneId, boolean isImport) {
         DnsZoneVO dnsZone = dnsZoneDao.findById(dnsZoneId);
         if (dnsZone == null) {
             throw new CloudRuntimeException("DNS zone not found during provisioning");
         }
         DnsServerVO server = dnsServerDao.findById(dnsZone.getDnsServerId());
         try {
             DnsProvider provider = getProviderByType(server.getProviderType());
-            String externalReferenceId = provider.provisionZone(server, dnsZone);
-            dnsZone.setExternalReference(externalReferenceId);
+            if (isImport) {
+                if (!provider.dnsZoneExists(server, dnsZone)) {
+                    throw new CloudRuntimeException(String.format("DNS zone '%s' cannot be imported because it does not exist in the DNS provider", dnsZone));
+                }
+            } else {
+                String externalReferenceId = provider.provisionZone(server, dnsZone);
+                dnsZone.setExternalReference(externalReferenceId);
+            }
             dnsZone.setState(DnsZone.State.Active);
             dnsZoneDao.update(dnsZone.getId(), dnsZone);
             logger.debug("DNS zone: {} created successfully on DNS server: {} with ID: {}", dnsZone.getName(), server.getName(), dnsZoneId);
diff --git a/server/src/main/java/org/apache/cloudstack/dns/DnsProviderUtil.java b/server/src/main/java/org/apache/cloudstack/dns/DnsProviderUtil.java
@@ -70,12 +70,42 @@ public static String normalizeDomainForDb(String domain) {
             normalized = normalized.substring(0, normalized.length() - 1);
         }
         // Validate domain, allow local/private TLDs
-        if (!validator.isValid(normalized)) {
+        boolean valid = isValidInternalDnsZoneName(normalized) || validator.isValid(normalized);
+        if (!valid) {
             throw new IllegalArgumentException("Invalid domain name: " + domain);
         }
         return normalized;
     }
 
+    static boolean isValidInternalDnsZoneName(String domain) {
+        // Total length limit (DNS standard)
+        if (domain.length() > 253) {
+            return false;
+        }
+
+        String[] labels = domain.split("\\.");
+        // Must have at least 2 labels (zone + suffix like internal/test/etc.)
+        if (labels.length < 2) {
+            return false;
+        }
+        for (String label : labels) {
+            if (label.isEmpty() || label.length() > 63) {
+                return false;
+            }
+
+            // Must start and end with alphanumeric (even if underscores exist inside)
+            if (!label.matches("^[a-z0-9](?:[a-z0-9_-]{0,61}[a-z0-9])?$")) {
+                return false;
+            }
+
+            // Prevent obviously invalid cases like "__" only labels
+            if (label.equals("_")) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     // DNS wire form: lowercase, validated, WITH trailing dot (used in record values)
     public static String normalizeDnsRecordValue(String value, DnsRecord.RecordType recordType) {
         if (StringUtils.isBlank(value)) {
diff --git a/server/src/test/java/org/apache/cloudstack/dns/DnsProviderManagerImplTest.java b/server/src/test/java/org/apache/cloudstack/dns/DnsProviderManagerImplTest.java
diff --git a/ui/public/locales/en.json b/ui/public/locales/en.json
diff --git a/ui/src/config/section/network.js b/ui/src/config/section/network.js
diff --git a/ui/src/views/network/dns/CreateDnsZone.vue b/ui/src/views/network/dns/CreateDnsZone.vue
diff --git a/ui/src/views/network/dns/DeleteDnsZone.vue b/ui/src/views/network/dns/DeleteDnsZone.vue
diff --git a/ui/src/views/network/dns/DnsRecordsTab.vue b/ui/src/views/network/dns/DnsRecordsTab.vue

Original file line number	Diff line number	Diff line change
`@@ -41,4 +41,5 @@ public interface DnsProvider extends Adapter {`
`41`	`41`	`String updateRecord(DnsServer server, DnsZone zone, DnsRecord record) throws DnsProviderException;`
`42`	`42`	`String deleteRecord(DnsServer server, DnsZone zone, DnsRecord record) throws DnsProviderException;`
`43`	`43`	`boolean dnsRecordExists(DnsServer server, DnsZone zone, String recordName, String recordType) throws DnsProviderException;`
	`44`	`+ boolean dnsZoneExists(DnsServer server, DnsZone zone);`
`44`	`45`	`}`