@salesforce/lds-core-release 1.243.0 → 1.245.0

package/README.md

@@ -1,58 +1,3 @@
-# LDS Release
+# LDS Core Release
 
-## Prerequisites
-
-1. make sure you have `python3` on your PATH
-2. make sure you have either run `yarn build:core-artifacts` from the root of the repo to generate the artifacts, or downloaded and unzipped a Github release artifact
-
-## How to run locally
-
-It's really simple, just run `yarn release:python` from this package, then use the prompts to give the path to your release artifact dir and the path to your core.
-
-## Running a release on a Salesforce workspace
-
-This part assumes you have a [Salesforce workspace available](https://sfdc.co/ws), and using the **Core on Git** Workspace template. This script does not handle p4 commands.
-
-1. `cd` out of the core path to something like `/opt/workspace`. Make a working directory for yourself here. `mkdir lds`, and `cd` into it.. `cd lds`
-2. Authenticate to Github.com via the installed github cli. `gh auth login`. Make sure you're logged into your EMU account. Specify that HTTPS is fine for git operations. You'll have to paste an auth code to login.
-3. Download the release artifact for the version you're trying to release. `gh release download {release version} --repo=salesforce-experience-platform-emu/lds-lightning-platform`
-4. Unzip the release artifact. `unzip sfdc.zip`
-5. Run the release script that is included in the artifact. `python3 output/lds/release.py`
-
-   - Answer the prompts to point the script to the right directories. To clarify, this is the `sfdc` directory in the unzipped dir.
-
-     ```
-     python output/lds/release.py
-     Enter the location of the LDS release artifact. Default: ../../output/sfdc: ./output/sfdc
-     Enter the core filepath. Default: /Users/scarraway/repositories/salesforce/core/core-public/core: /opt/workspace/core-public/core
-     Source filepath: output/sfdc
-     ```
-
-   - Validate the changes look correct
-
-6. Create a branch with all the changes and submit for review.
-
-## Troubleshooting
-
-If you see an error with Git LFS when pushing, you may need to force another change to get LFS up to date.
-Example:
-
-```
-Spawned process 5149 to upload telemetry.  Logs at /opt/workspace/gimlet-home/logs/20230712141414/telemetry-upload.nohup.out
-Your token to access the Git-lfs instance (https://gitlfs.soma.salesforce.com/artifactory/api/lfs/gitlfs-coreapp) is valid.
-Preparing lfs
-Git LFS upload failed:  33% (1/3), 4.6 KB | 0 B/s
-  (missing) core/ui-force-components/modules/force/ldsAdaptersUiapi/ldsAdaptersUiapi.js (06dcf9a38c6a94e13f9d687b215f3a55d2243df2e2cf19b4464eac964e2824f2)
-  (missing) core/ui-force-components/modules/force/ldsAdaptersAnalyticsWave/ldsAdaptersAnalyticsWave.js (9479f6181b61748b5a1256d9df726746df8982f5486043cb81d0b08408fac0bc)
-hint: Your push was rejected due to missing or corrupt local objects.
-hint: You can disable this check with: `git config lfs.allowincompletepush true`
-Uploading LFS objects:  33% (1/3), 4.6 KB | 0 B/s, done.
-error: failed to push some refs to 'https://gitcore.soma.salesforce.com/core-2206/core-public.git'
-```
-
-**CAUTION** Do NOT run `git config lfs.allowincompletepush true`. It can lead to NPE when core-on-git is building your branch.
-
-Instead you can
-
-1. Make a whitespace change and re-push those files to your branch.
-2. Use `git lfs pull --include ui-force-components/modules/force/ldsAdaptersAnalyticsWave/ldsAdaptersAnalyticsWave.js` for each file complained about above. This forces your local git to pull down the LFS files. Then make a whitespace change and re-push.
+This package defines a portable [python script](./src/release.py) along with assets to successfully update core with the latest lds-lightning-platform assets. It can be used for local development, integration testing, and the LDS weekly release. Usage is documented [here](../../docs/release/core-release-tasks.md)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@salesforce/lds-core-release",
     "private": false,
-    "version": "1.243.0",
+    "version": "1.245.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS release System",
     "scripts": {

package/src/release.py

@@ -1,35 +1,96 @@
 #!/usr/bin/env python3
-import shutil
+import subprocess;
+import errno;
 from string import Template
 from pathlib import Path
 from typing import List
 from functools import lru_cache
+import asyncio
+import argparse
 
 # resolve static files used by the script
 script_path = Path(__file__).resolve()
 script_directory = script_path.parent
 assets_path = script_directory / 'assets'
 
+async def usingPerforce(coreDir):
+    isPerforceDir = True
+    try:
+        # Run the 'p4 where ...' command using subprocess
+        result = subprocess.run(['p4 where ...'], cwd=coreDir, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+        # Check if the error message indicates the directory is not under client's root
+        if "is not under client's root" in result.stderr:
+            print('Client root error!')
+            isPerforceDir = False
+
+    except subprocess.CalledProcessError as e:
+        print('Got an error trying to verify p4 workspace. Assuming Git.')
+        print(e) 
+        # Handle any errors, but we assume that if 'p4 where' fails, it's not a Perforce directory
+        isPerforceDir = False
+
+    return isPerforceDir
+
+async def checkoutFileP4(corePath: Path, coreDir: Path):
+    # Check if the file exists
+    if not corePath.exists():
+        # If it doesn't exist, add it to Perforce
+        print('New file in perforce. Attempting add.')
+        p4_command = [f'p4 add {corePath}']
+
+        try:
+            subprocess.run(p4_command, cwd=coreDir, check=True, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError as e:
+            print(f"Error adding file to Perforce: {e}")
+            return
+
+        # Create the directory structure if it doesn't exist
+        corePath.parent.mkdir(parents=True, exist_ok=True)
+
+        # Create an empty file
+        try:
+            corePath.touch()
+        except OSError as e:
+            if e.errno == errno.EACCES:
+                print(f"File is not writable. Make sure to run 'p4 edit {corePath}'.")
+            else:
+                print(f"Error creating file: {e}")
+    else:
+        # If the file exists, edit it in Perforce
+        p4_command = [f'p4 edit {corePath}']
+
+        try:
+            subprocess.run(p4_command, cwd=coreDir, check=True, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError as e:
+            print(f"Error editing file in Perforce: {e}")
+
+        # Check if the file is writable
+        try:
+            corePath.touch(mode=0o666, exist_ok=True)
+        except OSError as e:
+            if e.errno == errno.EACCES:
+                print(f"File is not writable. Make sure to run 'p4 edit {corePath}'.")
+            else:
+                print(f"Error checking file access: {e}")
+
 # Python 3 script that does the LDS release.
-def copy_release(source_dir: Path, destination_dir: Path):
+async def copy_release(source_dir: Path, destination_dir: Path, useP4: bool):
     try:
         new_modules = []
 
-        # Create the destination directory if it doesn't exist
-        if not destination_dir.exists():
-            destination_dir.mkdir(parents=True)
-
         # Copy files from the source directory to the destination directory
         for file in Path(source_dir).rglob("*.js"):
             print(f"File detected: {file}")
 
             relative_path = file.relative_to(source_dir)
-            print(f"relative path: {relative_path}")
             destination_file = destination_dir / relative_path
+
+            if(useP4):
+                await checkoutFileP4(destination_file, destination_dir)
+            
             destination_file.parent.mkdir(parents=True, exist_ok=True)
             destination_file.touch(mode= 0o666 ,exist_ok=True)
 
-            print(f"Trying to copy file: {relative_path}")
             # Copy the file
             destination_file.write_bytes(file.read_bytes())
             # Get the directory name (module name)
@@ -43,6 +104,8 @@ def copy_release(source_dir: Path, destination_dir: Path):
                 new_modules.append(module_name)
                 # Create the meta xml file if missing
                 meta_xml_template_bytes = read_js_meta_template()
+                if(useP4):
+                    await checkoutFileP4(meta_xml_file, destination_dir)
                 meta_xml_file.touch(mode= 0o666 ,exist_ok=True)
                 meta_xml_file.write_bytes(meta_xml_template_bytes)
 
@@ -85,36 +148,51 @@ def replace_string_in_file(file_path: Path, old_string: str, new_string: str, su
     except Exception as e:
         print("An error occurred while replacing the string:", e)
 
-def update_ownership_yml(destination_filepath: Path, new_modules: List[str]):
-    if(len(new_modules) == 0):
-        return
-    
+async def update_ownership_yml(destination_filepath: Path, new_modules: List[str], useP4: bool):   
     ownershipYamlPath = destination_filepath / 'ui-force-components' / 'java' / 'resources' / 'ownership.yaml'
     newEntriesString = "\n".join([f"  - modules/force/{module}/**" for module in new_modules]) + "\n  - modules/force/ldsBindings/**"
+    if useP4:
+        await checkoutFileP4(ownershipYamlPath, destination_filepath)
     ownershipYamlPath.chmod(0o666)
     replace_string_in_file(ownershipYamlPath, '  - modules/force/ldsBindings/**', newEntriesString, "Updated ownership.yml")
     return
 
-def update_lwc_workflow_test(destination_filepath: Path, new_modules: List[str]):
-    if(len(new_modules) == 0):
-        return
-    
+async def update_lwc_workflow_test(destination_filepath: Path, new_modules: List[str], useP4: bool):    
     lwcWorkflowTestPath = destination_filepath / 'aura-impl-sfdc' / 'test' / 'func' / 'java' / 'src' / 'aura' / 'impl' / 'sfdc' / 'modules' / 'LWCWorkflowTest.java'
     newEntriesString = "\n".join([f'            "force/{module}",' for module in new_modules]) + '\n            "force/ldsBindings",'
+    if useP4:
+        await checkoutFileP4(lwcWorkflowTestPath, destination_filepath)
+
     lwcWorkflowTestPath.chmod(0o666)
     replace_string_in_file(lwcWorkflowTestPath, '            "force/ldsBindings",', newEntriesString, "Updated LWCWorkflowTest")
     return
 
-# Accept input from the user
-source_filepath = Path(input("Enter the location of the LDS release artifact. Default: ../../output/sfdc: ") or '../../output/sfdc')
-destination_filepath =  Path(input("Enter the core filepath. Default: /Users/scarraway/repositories/salesforce/core/core-public/core: ") or '/Users/scarraway/repositories/salesforce/core/core-public/core')
+async def main():
+    parser = argparse.ArgumentParser(description="The release script for LDS")
+    parser.add_argument("-o", "--outputDir", help="Path to the output directory generated by yarn build:core-artifacts")
+    parser.add_argument("-c", "--coreDir", help="Path to the target core directory")
+    args = parser.parse_args()
+    
+    source_filepath = Path(args.outputDir or input("Enter the location of the LDS release artifact. Default: ./output: ") or './output').expanduser()
+    print("LDS Release artifact path:", source_filepath)
+    if not (source_filepath / 'sfdc').exists():
+        raise SystemExit(f"LDS release artifact directory({source_filepath}) does not seem to exist. Did you provide the correct path? Did you run yarn build:core-artifacts?")
+    destination_filepath = Path(args.coreDir or input("Enter the core filepath. Default: /opt/workspace/core-public/core: ") or '/opt/workspace/core-public/core').expanduser()
+    print("Destination filepath:", destination_filepath)
+    if not (destination_filepath / 'ui-force-components').exists():
+        raise SystemExit(f"Destination core directory does not seem to contain ui-force-components. Did you provide the correct path to your core directory?")
+    # Print the entered filepaths
 
-# Print the entered filepaths
-print("Source filepath:", source_filepath)
-print("Destination filepath:", destination_filepath)
+    
+    useP4 = await usingPerforce(destination_filepath)
+    new_modules = await copy_release(source_filepath / 'sfdc', destination_filepath, useP4)
 
-new_modules = copy_release(source_filepath, destination_filepath)
+    if(len(new_modules) == 0):
+        print(f"No new modules detected")
+        return
+    else:
+        print(f"New modules added: {new_modules}")
+        await update_ownership_yml(destination_filepath, new_modules, useP4)
+        await update_lwc_workflow_test(destination_filepath, new_modules, useP4)
 
-print(f"New modules added: {new_modules}")
-update_ownership_yml(destination_filepath, new_modules)
-update_lwc_workflow_test(destination_filepath, new_modules)
+asyncio.run(main())