:Best practice: Prohibit the MAX_PT function

Step 1: Configure a custom event bus

1. Log on to the EventBridge console. In the left-side navigation pane, click Event Bus.

2. Click the icon to Create Custom Event Bus.

   1. In the Event Bus section, enter a Name for the custom event bus, and then click Next step to configure the event source.

   2. Click Skip to bypass the Event Source, Rule, and Target configurations. You must also enter a Description.

3. In the left-side navigation pane, click Event Bus. Find the event bus you created and click its name to go to the overview page.

   • In the left-side navigation pane, click Event Rules, and then click Create Rule.

   • In this best practice, the custom EventBridge event bus is defined to receive file commit and file deployment event messages from DataWorks. The following sample shows the core parameter settings.

     1. Configure basic info: Specify a custom name for the rule.

     2. Configure event pattern.

        • Event Source Type: Select Custom Event Source.

        • Event Source: Leave this unconfigured.

        • Pattern content: Enter the following content in JSON format.

          {
              "source": [
                  "acs.dataworks"
              ],
              "type": [
                  "dataworks:FileChange:CommitFile",
                  "dataworks:FileChange:DeployFile"
              ]
          }

          • source: Defines the product name identifier of the event, which is acs.dataworks.

          • type: Defines the event type identifier for the product. Set this parameter to dataworks:FileChange:CommitFile and dataworks:FileChange:DeployFile.

        • Event pattern debugging: Modify the values for source and type, and then test the event. If the test is successful, click Next Step. Click Test to verify whether a custom event matches the pattern. If the test passes, the page displays a message indicating that the match succeeded and the event can be triggered.

     3. Configure targets.

        • Service Type: Select HTTPS or HTTP. For more information about service types, see Manage event rules.

        • URL: Enter the URL to receive messages from the custom event bus. For example, enter https://server_address:port_number/extensions/consumer.

        • Body: Select Complete Event.

        • Network Type: Select Public Network.

Step 2: Configure an event distribution channel

1. Log on to the DataWorks console. In the target region, click More > Open Platform in the left-side navigation pane. Click Go to Open Platform to open the Developer Backend page.

2. On the Developer Backend page, click OpenEvent in the left-side navigation pane. On the page that appears, click Add Event Distribution Channel and configure the parameters in the dialog box.

   • Workspace for Distribution of Event Messages: Select the workspace that you created.

   • Specify Custom Event Bus in EventBridge for Distribution of Event Messages: Select the event bus that you created in Step 1.

3. After you save the event distribution channel, find the channel and click Enable in the Operation column to enable it.

Step 3: Register and configure an extension

1. Log on to the DataWorks console. In the target region, click More > Open Platform in the left-side navigation pane. Click Go to Open Platform to open the Developer Backend page.

2. On the Developer Backend page, click Extension in the left-side navigation pane. Then, click Register Extension and configure the parameters in the dialog box.

   1. Deployment Method: Select Deploy based on self-managed service.

   2. Register extension

      • Extension Name: Enter a custom name.

      • Extension Point Event: Select Pre-event for Node Commit and Pre-event for Node Deployment.

      • Workspace for Testing: After you configure this parameter, you can test the extension in the specified workspace after it is created but before it is submitted.

      • Parameter Configurations for Extension

        Use this parameter to control the scope of the extension. In the specified workspace:

        • When a node is committed (Pre-event for Node Commit), the extension check is not triggered, and the commit process is not blocked.

        • When a node is deployed (Pre-event for Node Deployment), the extension check is triggered. If the validation fails, the deployment process is blocked.

        Set the parameter to extension.project.commit-file.disabled=YourProjectId. Replace YourProjectId with the ID of the workspace where the extension is disabled for the specified extension point event.

      • Options for Extension: Use this to define the response options for failed validations. In the following example, the available options are Alert and Disable.

        {
          "type":"object",
          "properties":{
            "checkStatus":{
              "type":"number",
              "title":"Check method for MAX_PT function",
              "x-decorator":"FormItem",
              "x-component":"Radio.Group",
              "x-decorator-props":{
                "tooltip":"Description file"
              },
              "x-component-props":{
                "dataSource":[
                  {
                    "value":"WARN",
                    "label":"Alert"
                  },
                  {
                    "value":"FAIL",
                    "label":"Disable"
                  }
                ],
                "mode":"multiple"
              }
            }
          }
        }

3. After you complete the configurations, click Determine to save the registered extension.

4. In the Operation column for the extension you created, click Submit to start the review process.

   Note

   • Extensions are reviewed by the DataWorks platform. The review is typically completed within three business days.

   • To test the extension you created, you must configure a Workspace for Testing.

5. After the extension is approved, click Publish in the Actions column.

6. Click the Manage Extensions button to open the Management Center > Extension page. Select the extension that you created, enable it, and click Settings to configure the control level for MAX_PT function usage in the workspace.

Sample code

This sample code calls the UpdateIDEEventResult API to return the processing result. It uses the messageId parameter in the API to retrieve detailed event information, checks whether the restricted function is included, and then returns the result to DataWorks by using UpdateIDEEventResult. For more information, see Develop an extension.

Build environment: Java 8 and the Maven build tool.

package com.aliyun.dataworks.demo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.aliyun.dataworks.config.Constants;
import com.aliyun.dataworks.config.EventCheckEnum;
import com.aliyun.dataworks.config.ExtensionParamProperties;
import com.aliyun.dataworks.services.DataWorksOpenApiClient;
import com.aliyun.dataworks_public20200518.Client;
import com.aliyun.dataworks_public20200518.models.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * @author dataworks demo
 */
@RestController
@RequestMapping("/extensions")
public class ExtensionsController {
  @Autowired(required = false)
  private DataWorksOpenApiClient dataWorksOpenApiClient;
  @Autowired
  private ExtensionParamProperties extensionParamProperties;
  /**
   * Receives messages pushed from EventBridge.
   *
   * @param jsonParam
   */
  @PostMapping("/consumer")
  public void consumerEventBridge(@RequestBody String jsonParam) {
    JSONObject jsonObj = JSON.parseObject(jsonParam);
    String eventCode = jsonObj.getString(Constants.EVENT_CODE_FILED);
    if (Constants.COMMIT_FILE_EVENT_CODE.equals(eventCode) || Constants.DEPLOY_FILE_EVENT_CODE.equals(eventCode)) {
      // Initialize the client.
      Client client = dataWorksOpenApiClient.createClient();
      try {
        // Get information about the current event parameters.
        String messageId = jsonObj.getString("id");
        JSONObject data = jsonObj.getObject("data", JSONObject.class);
        Long projectId = data.getLong("projectId");
        // Initialize the event callback.
        UpdateIDEEventResultRequest updateIDEEventResultRequest = new UpdateIDEEventResultRequest();
        updateIDEEventResultRequest.setMessageId(messageId);
        updateIDEEventResultRequest.setExtensionCode(extensionParamProperties.getExtensionCode());
        // Query the data snapshot of the extension point when the extension point event is triggered.
        GetIDEEventDetailRequest getIDEEventDetailRequest = new GetIDEEventDetailRequest();
        getIDEEventDetailRequest.setMessageId(messageId);
        getIDEEventDetailRequest.setProjectId(projectId);
        GetIDEEventDetailResponse getIDEEventDetailResponse = client.getIDEEventDetail(getIDEEventDetailRequest);
        String content = getIDEEventDetailResponse.getBody().getEventDetail().getCommittedFile().getContent();
        // Check whether the code contains the restricted function.
        if (content.contains(Constants.CHECK_CODE)) {
          // Obtain the configuration of the extension options in the workspace.
          GetOptionValueForProjectRequest getOptionValueForProjectRequest = new GetOptionValueForProjectRequest();
          getOptionValueForProjectRequest.setProjectId(String.valueOf(projectId));
          getOptionValueForProjectRequest.setExtensionCode(extensionParamProperties.getExtensionCode());
                  GetOptionValueForProjectResponse getOptionValueForProjectResponse = client.getOptionValueForProject(getOptionValueForProjectRequest);
                  JSONObject jsonObject = JSON.parseObject(getOptionValueForProjectResponse.getBody().getOptionValue());
                  // Note: You must fill in the format based on the actual settings in DataWorks.
                  String checkStatus = jsonObject.getString("checkStatus");
                  updateIDEEventResultRequest.setCheckResult(checkStatus);
                  updateIDEEventResultRequest.setCheckResultTip("The code contains a restricted function.");
              } else {// Successful callback.
                  updateIDEEventResultRequest.setCheckResult(EventCheckEnum.OK.getCode());
                  updateIDEEventResultRequest.setCheckResultTip(EventCheckEnum.OK.getName());
              }
              // Send the callback to DataWorks.
              UpdateIDEEventResultResponse response = client.updateIDEEventResult(updateIDEEventResultRequest);
              // The unique ID of the request, used for subsequent troubleshooting.
              System.out.println("response:" + response.getBody().getRequestId());
          } catch (Exception e) {
              // The error description.
              System.out.println("ErrMsg:" + e.getMessage());
          }
      } else {
          System.out.println("Failed to filter other events. Check the configuration steps.");
      }
  }
}

Verification steps

1. On the Data Development page, create a node. In the node, edit the code to include the prohibited MAX_PT function, then save and commit the node.

2. Click the Publish button. On the Create Deployment Package page, deploy the node directly. This triggers the extension check.

   Note

   According to the extension configuration, the check does not apply to file commit events in the specified workspace. Therefore, the extension check is not triggered when you commit a node that contains the MAX_PT function. The check is triggered only when you deploy the node that contains the MAX_PT function.