: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 to go to the event bus page.

2. Click the button to Create Custom Event Bus.

   1. In the Bus section, configure the Custom Event Bus Name, and then click Next step to proceed to the event source configuration.

   2. Click Skip to skip the configuration of Event Source, Rule, and Target Module. Enter a Description.

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

   • In the left-side navigation pane, click Event Rules to go to the event rules page, and then click Create Rule to create an event rule.

   • In this example, the custom EventBridge bus is configured to receive file commit and file deployment event messages from DataWorks. The following section describes the configuration demo and key parameters.

     1. Configure Basic Information: Customize the rule name.

     2. Pattern Content.

        • Event Source Type: Select custom event source.

        • Event Source: Leave this field empty.

        • Pattern Content: Write in JSON format. The configuration is as follows.

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

          • source: Defines the product name identifier acs.dataworks.

          • type: Defines the event type identifiers under the product. Set this to dataworks:FileChange:CommitFile and dataworks:FileChange:DeployFile.

        • Event Pattern Debugging: Fill in and modify the source and type values, and then perform an event test. After the test succeeds, click Next. Click Test to verify that the custom event matches the pattern. If the test passes, the page displays Match passed, event can be triggered normally.

     3. Configure Event Target.

        • Service Type: Select HTTPS or HTTP. For more service types, see Event targets.

        • URL: Enter the URL that receives messages pushed by the custom bus, such as https://server-address:port/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 settings in the dialog.

   • Workspace for Event Distribution: Select a workspace that you have created.

   • Custom Bus in Eventbridge for Distribution: Select the event bus created in Step 1.

3. After you save the event distribution channel, in the Operation column of the channel, click Enable to enable the new event distribution channel.

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. On the page that appears, click Register Extension and configure the settings in the dialog.

   1. Deployment method: Select Deploy via self-built service.

   2. Register the extension

      • Extension Name: Enter a custom name.

      • Extension Point Event: Select Before File Commit and Before File Deploy.

      • Workspace for Testing: After you configure this setting, you can test the extension in the specified workspace before submitting it.

      • Parameter Configurations for Extension

        You can use this parameter to control the scope of the extension. In the specified workspace:

        • Submitting a node (Before File Commit) does not trigger extension validation or block the submit process.

        • Deploying a node (Before File Deploy) triggers extension validation. If validation fails, the deployment process is blocked.

        Set this to extension.project.commit-file.disabled=YourProjectId, where YourProjectId is the workspace ID in which the extension point event does not take effect.

      • Options for Extension: Used to define response methods when validation fails. In this example, the specified response methods include alert and block.

        {
          "type":"object",
          "properties":{
            "checkStatus":{
              "type":"number",
              "title":"MAX-PT function check method",
              "x-decorator":"FormItem",
              "x-component":"Radio.Group",
              "x-decorator-props":{
                "tooltip":"Description file"
              },
              "x-component-props":{
                "dataSource":[
                  {
                    "value":"WARN",
                    "label":"Warning"
                  },
                  {
                    "value":"FAIL",
                    "label":"Disabled"
                  }
                ],
                "mode":"multiple"
              }
            }
          }
        }

        The fields in the options configuration are described as follows:

        • checkStatus: A custom field name (component name, must be unique) defined by the extension developer in the options configuration. The extension server reads the value configured by the workspace administrator for the workspace through this field name.

        • title: The title of the option. For values, see the parameter parsing and configuration examples in Advanced feature: Extension options configuration. In this example, the title is MAX-PT Function Check Method.

        • x-component: The form component used by the option. In this example, a radio button component (Radio.Group) is used.

        • dataSource: The selectable options for the radio button component, where label is the text displayed on the UI and value is the corresponding identifier. This example provides two values: Alert (WARN) and Block (FAIL), which allow the workspace administrator to select the response method when the MAX_PT function is detected during extension enablement.

        Combined with the sample code in this topic, you can understand the value flow of checkStatus: When the workspace administrator enables the extension, they select either Alert or Block from MAX-PT Function Check Method. The extension server reads this configuration through GetOptionValueForProject, retrieves the administrator's selection through jsonObject.getString("checkStatus"), and returns the result to DataWorks through setCheckResult as a callback, which either alerts or blocks the deployment process of the node.

        Note

        checkStatus is only one configuration example that uses the radio button component. The options configuration currently supports seven component types: text, single-line input, multi-line input, single-select dropdown, multi-select dropdown, checkbox, and radio button. For complete component types and configuration methods, see Advanced: Configure extension options.

3. After you complete the configuration, click Determine to save and register the extension.

4. In the Operation column of the created extension, click Submit to submit the extension for review.

   Note

   • The extension review is performed by the DataWorks platform. The review typically takes T+3 business days to complete.

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

5. After the review is approved, click Deploy in the Operation column to bring the extension online.

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

Sample code

This code sample calls the UpdateIDEEventResult API to return the callback result. It uses the messageId parameter in the API to obtain the event details, performs logic to determine whether restricted functions are used, and returns the result to DataWorks through the UpdateIDEEventResult API. For more information, see Develop an extension.

Environment setup: Java 8, 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;
  /**
   * Receive messages pushed by 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 client
      Client client = dataWorksOpenApiClient.createClient();
      try {
        //Current event parameter information
        String messageId = jsonObj.getString("id");
        JSONObject data = jsonObj.getObject("data", JSONObject.class);
        Long projectId = data.getLong("projectId");
        //Initialize event callback
        UpdateIDEEventResultRequest updateIDEEventResultRequest = new UpdateIDEEventResultRequest();
        updateIDEEventResultRequest.setMessageId(messageId);
        updateIDEEventResultRequest.setExtensionCode(extensionParamProperties.getExtensionCode());
        //Query the extension point data snapshot when the extension point event was 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 restricted functions
        if (content.contains(Constants.CHECK_CODE)) {
          //Get the extension option configuration for 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: fill in according to the actual format configured in DataWorks
                  String checkStatus = jsonObject.getString("checkStatus");
                  updateIDEEventResultRequest.setCheckResult(checkStatus);
                  updateIDEEventResultRequest.setCheckResultTip("Restricted functions found in code");
              } else {//Success callback
                  updateIDEEventResultRequest.setCheckResult(EventCheckEnum.OK.getCode());
                  updateIDEEventResultRequest.setCheckResultTip(EventCheckEnum.OK.getName());
              }
              //Callback to DataWorks
              UpdateIDEEventResultResponse response = client.updateIDEEventResult(updateIDEEventResultRequest);
              //Unique request ID for subsequent troubleshooting
              System.out.println("response:" + response.getBody().getRequestId());
          } catch (Exception e) {
              //Error description
              System.out.println("ErrMsg:" + e.getMessage());
          }
      } else {
          System.out.println("Failed to filter other events, please check the configuration steps");
      }
  }
}

Verification steps

1. On the Data Studio page, create a node, write the prohibited MAX_PT function in the node, save and submit the node.

2. Click the Deploy button to go to the create deployment package page and deploy the node. This triggers extension validation.

   Note

   Based on the extension configuration, the extension does not take effect for file submit events in the specified workspace. Therefore, submitting a node that contains the MAX_PT function does not trigger extension validation. The extension is triggered only when you deploy a node that contains the MAX_PT function.