<feature>[ZCF-5485] resubmit zstack after revert

compute/src/main/java/org/zstack/compute/vm/VmAllocateNicFlow.java

@@ -21,6 +21,8 @@
 import org.zstack.header.image.ImagePlatform;
 import org.zstack.header.message.APIMessage;
 import org.zstack.header.network.l3.*;
+import org.zstack.header.network.NetworkDependencyAdmissionExtensionPoint;
+import org.zstack.header.network.NetworkDependencyAdmissionRequest;
 import org.zstack.header.vm.*;
 import org.zstack.network.l3.L3NetworkManager;
 import org.zstack.resourceconfig.ResourceConfig;
@@ -121,6 +123,15 @@ public void run(final FlowTrigger trigger, final Map data) {
                 return;
             }
 
+            ErrorCode admissionError = admitDependency(nw.getUuid(),
+                    NetworkDependencyAdmissionRequest.DEPENDENCY_VM_NIC, null,
+                    NetworkDependencyAdmissionRequest.OPERATION_CREATE_VM_NIC);
+            if (admissionError != null) {
+                errs.add(admissionError);
+                wcomp.allDone();
+                return;
+            }
+
             // Persist VmNicVO first so that ResourceVO entry exists before extensions
             // (e.g. SDN controllers) attempt to create SystemTags referencing the NIC UUID.
             VmNicVO nicVO = vnicFactory.createVmNic(nic, spec);
@@ -263,6 +274,15 @@ private void addVmNicConfig(VmNicVO vmNicVO, VmInstanceSpec vmSpec, VmNicSpec ni
 
         VmNicParam vmNicParm = vmNicParms.get(0);
 
+        if (vmNicParm.getInboundBandwidth() != null || vmNicParm.getOutboundBandwidth() != null) {
+            ErrorCode admissionError = admitDependency(vmNicVO.getL3NetworkUuid(),
+                    NetworkDependencyAdmissionRequest.DEPENDENCY_VM_NIC_QOS, null,
+                    NetworkDependencyAdmissionRequest.OPERATION_ADD_VM_NIC_QOS);
+            if (admissionError != null) {
+                throw new org.zstack.header.exception.CloudRuntimeException(admissionError.getDetails());
+            }
+        }
+
         // add vmnic bandwidth systemtag
         if (vmNicParm.getInboundBandwidth() != null || vmNicParm.getOutboundBandwidth() != null) {
             VmNicQosConfigBackend backend = vmMgr.getVmNicQosConfigBackend(vmSpec.getVmInventory().getType());
@@ -277,6 +297,19 @@ private void addVmNicConfig(VmNicVO vmNicVO, VmInstanceSpec vmSpec, VmNicSpec ni
         }
     }
 
+    private ErrorCode admitDependency(String resourceUuid, String dependencyType, String operationUuid, String operationStep) {
+        NetworkDependencyAdmissionRequest request = new NetworkDependencyAdmissionRequest(
+                resourceUuid, dependencyType, operationUuid, operationStep);
+        for (NetworkDependencyAdmissionExtensionPoint extension :
+                pluginRgty.getExtensionList(NetworkDependencyAdmissionExtensionPoint.class)) {
+            ErrorCode errorCode = extension.admit(request);
+            if (errorCode != null) {
+                return errorCode;
+            }
+        }
+        return null;
+    }
+
     private void callBeforeAllocateVmNicExtensions(VmNicInventory nic, VmInstanceSpec spec, Completion completion) {
         List<BeforeAllocateVmNicExtensionPoint> exts = pluginRgty.getExtensionList(BeforeAllocateVmNicExtensionPoint.class);
         if (exts.isEmpty()) {

conf/db/upgrade/V5.5.38__schema.sql

@@ -20,3 +20,74 @@ CREATE TABLE IF NOT EXISTS `zstack`.`SnmpEngineVO` (
     `lastOpDate` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' ON UPDATE CURRENT_TIMESTAMP,
     PRIMARY KEY (`uuid`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+-- ZNS segment binding state and controller inventory
+
+CREATE TABLE IF NOT EXISTS `zstack`.`ZnsControllerStateVO` (
+    `sdnControllerUuid` varchar(32) NOT NULL,
+    `activeScanToken` varchar(255) DEFAULT NULL,
+    `activeScanStartedAt` timestamp NULL DEFAULT NULL,
+    `migrationState` varchar(32) NOT NULL DEFAULT 'NotStarted',
+    `compatibilityMode` varchar(32) NOT NULL DEFAULT 'LEGACY',
+    `compatibilityEpoch` bigint NOT NULL DEFAULT 0,
+    `remoteCompatibilityEpoch` bigint DEFAULT NULL,
+    `capabilityDigest` varchar(64) DEFAULT NULL,
+    `migrationDigest` varchar(64) DEFAULT NULL,
+    `pendingContractEpoch` bigint DEFAULT NULL,
+    `pendingContractRequestDigest` varchar(64) DEFAULT NULL,
+    `lastSuccessfulScanDate` timestamp NULL DEFAULT NULL,
+    `lastErrorCode` varchar(128) DEFAULT NULL,
+    `lastErrorDetails` text DEFAULT NULL,
+    `lastOpDate` timestamp NOT NULL DEFAULT '2000-01-01 00:00:00' ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`sdnControllerUuid`),
+    CONSTRAINT `fkZnsControllerStateVOSdnControllerVO`
+        FOREIGN KEY (`sdnControllerUuid`) REFERENCES `zstack`.`SdnControllerVO` (`uuid`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `zstack`.`ZnsSegmentInventoryVO` (
+    `uuid` varchar(32) NOT NULL,
+    `sdnControllerUuid` varchar(32) NOT NULL,
+    `znsSegmentUuid` varchar(36) NOT NULL,
+    `name` varchar(255) NOT NULL,
+    `transportZoneUuid` varchar(36) NOT NULL,
+    `availability` varchar(32) NOT NULL,
+    `reasonCode` varchar(128) DEFAULT NULL,
+    `lastSeenToken` varchar(36) NOT NULL,
+    `lastSeenDate` timestamp NOT NULL DEFAULT '2000-01-01 00:00:00',
+    `createDate` timestamp NOT NULL DEFAULT '2000-01-01 00:00:00',
+    `lastOpDate` timestamp NOT NULL DEFAULT '2000-01-01 00:00:00' ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`uuid`),
+    UNIQUE KEY `uk_zns_seg_inv_controller_segment` (`sdnControllerUuid`, `znsSegmentUuid`),
+    KEY `idx_zns_seg_inv_candidate` (`sdnControllerUuid`, `transportZoneUuid`, `availability`),
+    CONSTRAINT `fkZnsSegmentInventoryVOSdnControllerVO`
+        FOREIGN KEY (`sdnControllerUuid`) REFERENCES `zstack`.`SdnControllerVO` (`uuid`) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `zstack`.`ZnsSegmentRefVO` (
+    `uuid` varchar(32) NOT NULL,
+    `sdnControllerUuid` varchar(32) NOT NULL,
+    `znsSegmentUuid` varchar(36) DEFAULT NULL,
+    `zoneUuid` varchar(32) NOT NULL,
+    `l2NetworkUuid` varchar(32) NOT NULL,
+    `accountUuid` varchar(32) NOT NULL,
+    `l3NetworkUuid` varchar(32) DEFAULT NULL,
+    `znsTenantRouterUuid` varchar(36) DEFAULT NULL,
+    `state` varchar(32) NOT NULL,
+    `operationUuid` varchar(36) DEFAULT NULL,
+    `operationStep` varchar(32) DEFAULT NULL,
+    `operationDigest` varchar(64) DEFAULT NULL,
+    `appliedConfigVersion` bigint DEFAULT NULL,
+    `lastErrorCode` varchar(128) DEFAULT NULL,
+    `lastErrorDetails` text DEFAULT NULL,
+    `createDate` timestamp NOT NULL DEFAULT '2000-01-01 00:00:00',
+    `lastOpDate` timestamp NOT NULL DEFAULT '2000-01-01 00:00:00' ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`uuid`),
+    UNIQUE KEY `uk_zns_seg_ref_controller_segment_zone`
+        (`sdnControllerUuid`, `znsSegmentUuid`, `zoneUuid`),
+    UNIQUE KEY `uk_zns_seg_ref_l2` (`l2NetworkUuid`),
+    KEY `idx_zns_seg_ref_account` (`accountUuid`),
+    KEY `idx_zns_seg_ref_state` (`sdnControllerUuid`, `state`),
+    CONSTRAINT `fkZnsSegmentRefVOSdnControllerVO`
+        FOREIGN KEY (`sdnControllerUuid`) REFERENCES `zstack`.`SdnControllerVO` (`uuid`) ON DELETE CASCADE,
+    CONSTRAINT `chk_zns_seg_ref_segment_state`
+        CHECK (`znsSegmentUuid` IS NOT NULL OR `state` = 'MigrationFailed')
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;

conf/serviceConfig/sdnController.xml

@@ -45,6 +45,10 @@
         <serviceId>query</serviceId>
     </message>
 
+    <message>
+        <name>org.zstack.sdnController.header.APIPullSdnControllerMsg</name>
+    </message>
+
     <message>
         <name>org.zstack.network.hostNetworkInterface.APIQueryPhysicalSwitchMsg</name>
         <serviceId>query</serviceId>

conf/springConfigXml/sdnController.xml

@@ -26,6 +26,7 @@
             <zstack:extension interface="org.zstack.sdnController.SdnControllerManager" />
             <zstack:extension interface="org.zstack.header.network.l2.L2NetworkCreateExtensionPoint" />
             <zstack:extension interface="org.zstack.header.network.l2.L2NetworkDeleteExtensionPoint" />
+            <zstack:extension interface="org.zstack.header.network.l2.L2DeleteConfirmExtensionPoint" />
             <zstack:extension interface="org.zstack.network.securitygroup.SecurityGroupGetSdnBackendExtensionPoint"/>
             <zstack:extension interface="org.zstack.header.network.l3.AfterAddIpRangeExtensionPoint"/>
             <zstack:extension interface="org.zstack.header.network.l3.IpRangeDeletionExtensionPoint"/>

core/src/main/java/org/zstack/core/rest/RESTFacadeImpl.java

@@ -107,6 +107,15 @@ private interface AsyncHttpWrapper {
     private interface HttpCallHandlerWrapper {
         String handle(HttpEntity<String> entity);
 
+        default void handle(HttpEntity<String> entity, HttpServletResponse response) {
+            String body = handle(entity);
+            if (body == null) {
+                response.setStatus(HttpStatus.SC_OK);
+            } else {
+                response.setStatus(HttpStatus.SC_OK, body);
+            }
+        }
+
         HttpCallHandler getHandler();
     }
 
@@ -346,12 +355,7 @@ void sendCommand(HttpServletRequest req, HttpServletResponse rsp) {
                 return;
             }
 
-            String ret = handler.handle(entity);
-            if (ret == null) {
-                rsp.setStatus(HttpStatus.SC_OK);
-            } else {
-                rsp.setStatus(HttpStatus.SC_OK, ret);
-            }
+            handler.handle(entity, rsp);
         } catch (IOException e) {
             logger.warn(e.getMessage(), e);
         } catch (Throwable t) {
@@ -1051,6 +1055,42 @@ public HttpCallHandler getHandler() {
         httpCallhandlers.put(path, wrapper);
     }
 
+    @Override
+    public <T> void registerSyncHttpStatusBodyCallHandler(String path, final Class<T> objectType,
+                                                           final SyncHttpStatusBodyCallHandler<T> handler) {
+        if (httpCallhandlers.containsKey(path)) {
+            throw new CloudRuntimeException("duplicate SyncHttpStatusBodyCallHandler for path[" + path + "]");
+        }
+        httpCallhandlers.put(path, new HttpCallHandlerWrapper() {
+            @Override
+            public String handle(HttpEntity<String> entity) {
+                SyncHttpResponse response = handler.handleSyncHttpCall(JSONObjectUtil.toObject(entity.getBody(), objectType));
+                return response == null ? null : response.getBody();
+            }
+
+            @Override
+            public void handle(HttpEntity<String> entity, HttpServletResponse servletResponse) {
+                SyncHttpResponse response = handler.handleSyncHttpCall(JSONObjectUtil.toObject(entity.getBody(), objectType));
+                if (response == null) {
+                    servletResponse.setStatus(HttpStatus.SC_OK);
+                    return;
+                }
+                servletResponse.setStatus(response.getStatus());
+                if (response.getBody() != null) {
+                    servletResponse.setHeader("Content-Type", "application/json");
+                    try {
+                        servletResponse.getWriter().write(response.getBody());
+                    } catch (IOException e) {
+                        throw new CloudRuntimeException(e);
+                    }
+                }
+            }
+
+            @Override
+            public HttpCallHandler getHandler() { return handler; }
+        });
+    }
+
     @Override
     public String getBaseUrl() {
         return baseUrl;

header/src/main/java/org/zstack/header/network/CompleteZnsSegmentMutationMsg.java

@@ -0,0 +1,22 @@
+package org.zstack.header.network;
+
+import org.zstack.header.message.NeedReplyMessage;
+
+public class CompleteZnsSegmentMutationMsg extends NeedReplyMessage {
+    private String resourceUuid;
+    private String operationUuid;
+    private boolean success;
+    private String errorCode;
+    private String errorDetails;
+
+    public String getResourceUuid() { return resourceUuid; }
+    public void setResourceUuid(String value) { resourceUuid = value; }
+    public String getOperationUuid() { return operationUuid; }
+    public void setOperationUuid(String value) { operationUuid = value; }
+    public boolean isSuccess() { return success; }
+    public void setSuccess(boolean value) { success = value; }
+    public String getErrorCode() { return errorCode; }
+    public void setErrorCode(String value) { errorCode = value; }
+    public String getErrorDetails() { return errorDetails; }
+    public void setErrorDetails(String value) { errorDetails = value; }
+}

header/src/main/java/org/zstack/header/network/NetworkConfigLocalContinuation.java

@@ -0,0 +1,7 @@
+package org.zstack.header.network;
+
+import org.zstack.header.core.Completion;
+
+public interface NetworkConfigLocalContinuation {
+    void run(NetworkConfigMutation mutation, Completion completion);
+}

header/src/main/java/org/zstack/header/network/NetworkConfigMutation.java

@@ -0,0 +1,28 @@
+package org.zstack.header.network;
+
+import java.util.Collections;
+import java.util.Map;
+
+/** Immutable description of a versioned network mutation shared by owner and controller MNs. */
+public final class NetworkConfigMutation {
+    private final String resourceUuid;
+    private final String operationUuid;
+    private final long expectedConfigVersion;
+    private final String operationStep;
+    private final Map<String, Object> fields;
+
+    public NetworkConfigMutation(String resourceUuid, String operationUuid, long expectedConfigVersion,
+                                 String operationStep, Map<String, Object> fields) {
+        this.resourceUuid = resourceUuid;
+        this.operationUuid = operationUuid;
+        this.expectedConfigVersion = expectedConfigVersion;
+        this.operationStep = operationStep;
+        this.fields = fields == null ? Collections.emptyMap() : Collections.unmodifiableMap(new java.util.HashMap<>(fields));
+    }
+
+    public String getResourceUuid() { return resourceUuid; }
+    public String getOperationUuid() { return operationUuid; }
+    public long getExpectedConfigVersion() { return expectedConfigVersion; }
+    public String getOperationStep() { return operationStep; }
+    public Map<String, Object> getFields() { return fields; }
+}

header/src/main/java/org/zstack/header/network/NetworkConfigMutationExtensionPoint.java

@@ -0,0 +1,7 @@
+package org.zstack.header.network;
+
+import org.zstack.header.core.Completion;
+
+public interface NetworkConfigMutationExtensionPoint {
+    void prepare(NetworkConfigMutation mutation, Completion completion);
+}

header/src/main/java/org/zstack/header/network/NetworkDependencyAdmissionExtensionPoint.java

@@ -0,0 +1,7 @@
+package org.zstack.header.network;
+
+import org.zstack.header.errorcode.ErrorCode;
+
+public interface NetworkDependencyAdmissionExtensionPoint {
+    ErrorCode admit(NetworkDependencyAdmissionRequest request);
+}

header/src/main/java/org/zstack/header/network/NetworkDependencyAdmissionRequest.java

@@ -0,0 +1,25 @@
+package org.zstack.header.network;
+
+public final class NetworkDependencyAdmissionRequest {
+    public static final String DEPENDENCY_VM_NIC = "VmNic";
+    public static final String DEPENDENCY_VM_NIC_QOS = "VmNicQos";
+    public static final String OPERATION_CREATE_VM_NIC = "CREATE_VM_NIC";
+    public static final String OPERATION_ADD_VM_NIC_QOS = "ADD_VM_NIC_QOS";
+
+    private final String resourceUuid;
+    private final String dependencyType;
+    private final String operationUuid;
+    private final String operationStep;
+
+    public NetworkDependencyAdmissionRequest(String resourceUuid, String dependencyType,
+                                             String operationUuid, String operationStep) {
+        this.resourceUuid = resourceUuid;
+        this.dependencyType = dependencyType;
+        this.operationUuid = operationUuid;
+        this.operationStep = operationStep;
+    }
+    public String getResourceUuid() { return resourceUuid; }
+    public String getDependencyType() { return dependencyType; }
+    public String getOperationUuid() { return operationUuid; }
+    public String getOperationStep() { return operationStep; }
+}

header/src/main/java/org/zstack/header/network/PrepareZnsSegmentMutationMsg.java

@@ -0,0 +1,13 @@
+package org.zstack.header.network;
+
+import org.zstack.header.message.NeedReplyMessage;
+
+public class PrepareZnsSegmentMutationMsg extends NeedReplyMessage {
+    private NetworkConfigMutation mutation;
+    private String controllerUuid;
+
+    public NetworkConfigMutation getMutation() { return mutation; }
+    public void setMutation(NetworkConfigMutation value) { mutation = value; }
+    public String getControllerUuid() { return controllerUuid; }
+    public void setControllerUuid(String value) { controllerUuid = value; }
+}

header/src/main/java/org/zstack/header/network/ProjectedMutationPolicy.java

@@ -0,0 +1,36 @@
+package org.zstack.header.network;
+
+/** Pure validation used by projected updates and subtype conversions before any DB write. */
+public final class ProjectedMutationPolicy {
+    private ProjectedMutationPolicy() {
+    }
+
+    public static void requireSourceType(String actual, String expected) {
+        if (expected == null || expected.isEmpty()) {
+            return;
+        }
+        if (!expected.equals(actual)) {
+            throw new IllegalArgumentException(String.format("stale projected source type: expected %s but found %s", expected, actual));
+        }
+    }
+
+    public static void requireL2Conversion(String sourceType, String targetType, boolean hasDependencies) {
+        requireSourceType(sourceType, "L2NoVlanNetwork");
+        if (!"L2VlanNetwork".equals(targetType) && !"L2NoVlanNetwork".equals(targetType)) {
+            throw new IllegalArgumentException("unsupported projected L2 conversion target: " + targetType);
+        }
+        if (hasDependencies) {
+            throw new IllegalArgumentException("projected L2 conversion has prohibited dependencies");
+        }
+    }
+
+    public static void requireL3Conversion(String sourceType, String targetType, boolean hasDependencies) {
+        requireSourceType(sourceType, "L3BasicNetwork");
+        if (!"L3BasicNetwork".equals(targetType) && !"L3VpcNetwork".equals(targetType)) {
+            throw new IllegalArgumentException("unsupported projected L3 conversion target: " + targetType);
+        }
+        if (hasDependencies) {
+            throw new IllegalArgumentException("projected L3 conversion has prohibited dependencies");
+        }
+    }
+}

header/src/main/java/org/zstack/header/network/l2/ConvertL2VlanModeMsg.java

@@ -0,0 +1,15 @@
+package org.zstack.header.network.l2;
+
+import org.zstack.header.message.NeedReplyMessage;
+
+public class ConvertL2VlanModeMsg extends NeedReplyMessage {
+    private String l2NetworkUuid;
+    private String expectedSourceType;
+    private String targetType;
+    public String getL2NetworkUuid() { return l2NetworkUuid; }
+    public void setL2NetworkUuid(String value) { l2NetworkUuid = value; }
+    public String getExpectedSourceType() { return expectedSourceType; }
+    public void setExpectedSourceType(String value) { expectedSourceType = value; }
+    public String getTargetType() { return targetType; }
+    public void setTargetType(String value) { targetType = value; }
+}