[**Part-1] Add github Release Workflow

[cschuchardt88]

Change Log

• Added release.yml
• Needs PR Fixed Path and Property for *.csproj files #3306

Self automated release for neo-cli. Build windows version of libleveldb and adds to release of neo-cli.

HOW TO USE

STEP 1

STEP 2

STEP 3

STEP 4

STEP 5

Wait for job to complete.

---

Zip/Tarball File Contents

Release Page

Jobs

Type of change

• Optimization (the change is only an optimization)
• Style (the change is only a code style for better maintenance or standard purpose)
• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to not work as expected)
• This change requires a documentation update

How Has This Been Tested?

Locally and github

Checklist:

• My code follows the style guidelines of this project
• I have performed a self-review of my code
• I have commented my code, particularly in hard-to-understand areas
• I have made corresponding changes to the documentation
• My changes generate no new warnings
• I have added tests that prove my fix is effective or that my feature works
• New and existing unit tests pass locally with my changes
• Any dependent changes have been merged and published in downstream modules

[vncoelho]

maybe this can be a script that is called here

[vncoelho]

@cschuchardt88 , move this Cleanup to a script

[cschuchardt88]

what would the extension be for the file? Type of shell to use? Bash?

[vncoelho]

Bourne Again Shell looks good.

[Jim8y]

@cschuchardt88 what is the blocker of this pr?

[vncoelho]

I think you could comment the lines about cache and etc.

[vncoelho]

too much parameters as well..

[Jim8y]

Too much parameter? Like those are not necessary?

[vncoelho]

I think that a README or comments are necessary, there are several details

[cschuchardt88]

These are all the settings i found to work.

[vncoelho]

Maybe as readme

[vncoelho]

name: Release (neo-cli)

# Trigger the workflow on a release event when a new release is published
on:
  release:
    types: [published]

# Define environment variables
env:
  DOTNET_VERSION: 8.0.x
  CONFIGURATION: Release
  DIST_PATH: /tmp/dist
  OUTPUT_PATH: /tmp/out

jobs:
  build-leveldb:
    name: Build leveldb (windows-latest)
    runs-on: windows-latest
    strategy:
      matrix:
        arch: [x64, arm64]

    steps:
    # Step to lookup cache for the LevelDB build distribution
    - name: Lookup Cache Distribution
      id: cache-leveldb
      uses: actions/cache@v4
      with:
        path: ./leveldb/build/Release/*
        key: leveldb-windows-${{ matrix.arch }}
        enableCrossOsArchive: true
        lookup-only: true

    # Conditionally checkout LevelDB repository if cache is not found
    - if: ${{ steps.cache-leveldb.outputs.cache-hit != 'true' }}
      name: Checkout Repository Code (leveldb)
      uses: actions/checkout@v4
      with:
        repository: google/leveldb
        path: leveldb
        submodules: true
        fetch-depth: 0

    # Conditionally setup MSBuild if cache is not found
    - if: ${{ steps.cache-leveldb.outputs.cache-hit != 'true' }}
      name: Setup MSBuild
      uses: microsoft/setup-msbuild@v2

    # Conditionally setup LevelDB build directory if cache is not found
    - if: ${{ steps.cache-leveldb.outputs.cache-hit != 'true' }}
      name: Setup LevelDb
      working-directory: ./leveldb
      run: mkdir -p ./build/Release

    # Conditionally create build files for LevelDB if cache is not found
    - if: ${{ steps.cache-leveldb.outputs.cache-hit != 'true' }}
      name: Create Build Files (win-${{ matrix.arch }})
      working-directory: ./leveldb/build
      run: cmake -DBUILD_SHARED_LIBS=ON -A ${{ matrix.arch }} ..

    # Conditionally build LevelDB using MSBuild if cache is not found
    - if: ${{ steps.cache-leveldb.outputs.cache-hit != 'true' }}
      name: Build (MSBuild)
      working-directory: ./leveldb/build
      run: msbuild ./leveldb.sln /p:Configuration=Release

    # Conditionally cache the LevelDB distribution if it was built
    - if: ${{ steps.cache-leveldb.outputs.cache-hit != 'true' }}
      name: Cache Distribution
      uses: actions/cache/save@v4
      with:
        path: ./leveldb/build/Release/*
        key: leveldb-windows-${{ matrix.arch }}
        enableCrossOsArchive: true

  build-neo-cli:
    needs: [build-leveldb]
    name: Build & Publish TarBalls (${{ matrix.runtime }})
    runs-on: ubuntu-latest
    strategy:
      matrix:
        runtime: [linux-x64, linux-arm64, win-x64, win-arm64, osx-x64, osx-arm64]

    steps:
    # Step to set the application version from the release tag
    - name: Set Application Version (Environment Variable)
      run: |
        APP_VERSION=$(echo '${{ github.event.release.tag_name }}' | cut -d 'v' -f 2)
        echo "APP_VERSION=$APP_VERSION" >> $GITHUB_ENV

    # Checkout the neo-cli repository code
    - name: Checkout Repository Code
      uses: actions/checkout@v4
      with:
        fetch-depth: 0

    # Setup .NET environment
    - name: Setup .NET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    # Publish the neo-cli project
    - name: .NET Publish (neo-cli)
      run: |
        dotnet publish ./src/Neo.CLI \
        --version-suffix ${{ matrix.runtime }} \ # Append runtime identifier to version
        --framework net8.0 \ # Target .NET 8.0 framework
        --configuration ${{ env.CONFIGURATION }} \ # Use Release configuration
        --runtime ${{ matrix.runtime }} \ # Specify runtime identifier (e.g., win-x64, linux-arm64)
        --self-contained true \ # Include the .NET runtime with the application
        --output ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }} \ # Output path for the published application
        --verbosity normal \ # Normal verbosity level
        -p:VersionPrefix=${{ env.APP_VERSION }} \ # Set the version prefix to the application version
        -p:RuntimeIdentifier=${{ matrix.runtime }} \ # Set the runtime identifier property
        -p:SelfContained=true \ # Ensure the application is self-contained
        -p:IncludeNativeLibrariesForSelfExtract=false \ # Do not include native libraries for self-extraction
        -p:PublishTrimmed=false \ # Do not trim unused code
        -p:PublishSingleFile=true \ # Publish as a single file
        -p:PublishReadyToRun=true \ # Enable ReadyToRun compilation
        -p:EnableCompressionInSingleFile=true \ # Enable compression in the single file
        -p:DebugType=embedded \ # Embed debug information
        -p:ServerGarbageCollection=true # Enable server garbage collection

    # Build the LevelDBStore plugin
    - name: .NET Build (LevelDBStore)
      run: |
        dotnet build ./src/Plugins/LevelDBStore \
        --version-suffix ${{ matrix.runtime }} \ # Append runtime identifier to version
        --framework net8.0 \ # Target .NET 8.0 framework
        --configuration ${{ env.CONFIGURATION }} \ # Use Release configuration
        --output ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}/Plugins/LevelDBStore \ # Output path for the built plugin
        --verbosity normal \ # Normal verbosity level
        -p:VersionPrefix=${{ env.APP_VERSION }} # Set the version prefix to the application version

    # Remove unnecessary files from the LevelDBStore plugin output
    - name: Remove files (junk)
      working-directory: ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}/Plugins/LevelDBStore
      run: |
        rm -v Neo*
        rm -v *.pdb
        rm -v *.xml

    # Remove XML comment files from the neo-cli output
    - name: Remove Xml Comment Files
      working-directory: ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}
      run: rm -v *.xml

    # Get cached LevelDB distribution for Windows x64 if applicable
    - if: ${{ startsWith(matrix.runtime, 'win-x64') }}
      name: Get Distribution Caches (win-x64)
      uses: actions/cache@v4
      with:
        path: ./leveldb/build/Release/*
        key: leveldb-windows-x64
        enableCrossOsArchive: true
        fail-on-cache-miss: true

    # Get cached LevelDB distribution for Windows arm64 if applicable
    - if: ${{ startsWith(matrix.runtime, 'win-arm64') }}
      name: Get Distribution Caches (win-arm64)
      uses: actions/cache@v4
      with:
        path: ./leveldb/build/Release/*
        key: leveldb-windows-arm64
        enableCrossOsArchive: true
        fail-on-cache-miss: true

    # Copy LevelDB files to the output directory for Windows
    - if: ${{ startsWith(matrix.runtime, 'win') }}
      name: Copy Files (leveldb) (win)
      run: cp -v ./leveldb/build/Release/leveldb.dll ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}/libleveldb.dll

    # Create the distribution directory
    - name: Create Distribution Directory
      run: mkdir -p ${{ env.DIST_PATH }}

    # Create a tarball file for Linux distributions
    - name: Create Tarball File (linux)
      if: ${{ startsWith(matrix.runtime, 'linux') }}
      working-directory: ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}
      run: tar -czvf ${{ env.DIST_PATH }}/neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.tar.gz .

    # Create a tarball file for macOS distributions
    - name: Create Tarball File (osx)
      if: ${{ startsWith(matrix.runtime, 'osx') }}
      working-directory: ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}
      run: tar -cJf ${{ env.DIST_PATH }}/neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.tar.xz .

    # Create a zip file for Windows distributions
    - name: Create Zip File (win)
      if: ${{ startsWith(matrix.runtime, 'win') }}
      working-directory: ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}
      run: zip ${{ env.DIST_PATH }}/neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.zip -r *

    # Create checksum files for Linux distributions
    - name: Create Checksum Files (linux)
      if: ${{ startsWith(matrix.runtime, 'linux') }}
      working-directory: ${{ env.DIST_PATH }}
      env:
        FILENAME: neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}
      run: |
          sha256sum ${{ env.FILENAME }}.tar.gz > ${{ env.FILENAME }}.sha256

    # Create checksum files for macOS distributions
    - name: Create Checksum Files (osx)
      if: ${{ startsWith(matrix.runtime, 'osx') }}
      working-directory: ${{ env.DIST_PATH }}
      env:
        FILENAME: neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}
      run: |
          sha256sum ${{ env.FILENAME }}.tar.xz > ${{ env.FILENAME }}.sha256

    # Create checksum files for Windows distributions
    - name: Create Checksum Files (win)
      if: ${{ startsWith(matrix.runtime, 'win') }}
      working-directory: ${{ env.DIST_PATH }}
      env:
        FILENAME: neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}
      run: |
          sha256sum ${{ env.FILENAME }}.zip > ${{ env.FILENAME }}.sha256

    # List the contents of the distribution and output directories
    - name: Output/Distribution Directory Contents
      run: |
        ls -la ${{ env.DIST_PATH }}
        ls -la ${{ env.OUTPUT_PATH }}/${{ matrix.runtime }}

    # Upload tarball files for Linux distributions
    - name: Upload Tarball File (linux)
      if: ${{ startsWith(matrix.runtime, 'linux') }}
      uses: actions/upload-release-asset@latest
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      with:
          upload_url: ${{ github.event.release.upload_url }}
          asset_path: ${{ env.DIST_PATH }}/neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.tar.gz
          asset_name: neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.tar.gz
          asset_content_type: application/x-gtar

    # Upload tarball files for macOS distributions
    - name: Upload Tarball File (osx)
      if: ${{ startsWith(matrix.runtime, 'osx') }}
      uses: actions/upload-release-asset@latest
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      with:
          upload_url: ${{ github.event.release.upload_url }}
          asset_path: ${{ env.DIST_PATH }}/neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.tar.xz
          asset_name: neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.tar.xz
          asset_content_type: application/x-gtar

    # Upload zip files for Windows distributions
    - name: Upload Zip File (win)
      if: ${{ startsWith(matrix.runtime, 'win') }}
      uses: actions/upload-release-asset@latest
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      with:
          upload_url: ${{ github.event.release.upload_url }}
          asset_path: ${{ env.DIST_PATH }}/neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.zip
          asset_name: neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.zip
          asset_content_type: application/zip

    # Upload checksum files for all distributions
    - name: Upload Checksum File (all)
      uses: actions/upload-release-asset@latest
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      with:
          upload_url: ${{ github.event.release.upload_url }}
          asset_path: ${{ env.DIST_PATH }}/neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.sha256
          asset_name: neo-cli.v${{ env.APP_VERSION }}-${{ matrix.runtime }}.sha256
          asset_content_type: text/plain

  cleanup:
    needs: [build-neo-cli]
    runs-on: ubuntu-latest
    steps:
      # Cleanup step to delete old caches
      - name: Cleanup
        run: |
          gh extension install actions/gh-actions-cache
          
          echo "Fetching list of cache key"
          cacheKeysForPR=$(gh actions-cache list -R $REPO -B $BRANCH -L 100 | cut -f 1 )

          ## Setting this to not fail the workflow while deleting cache keys. 
          set +e
          echo "Deleting caches..."
          for cacheKey in $cacheKeysForPR
          do
              if [ "$cacheKey" != "leveldb-windows-x64" ] && [ "$cacheKey" != "leveldb-windows-arm64" ]
              then
                gh actions-cache delete $cacheKey -R $REPO -B $BRANCH --confirm
              fi
          done
          echo "Done"
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          REPO: ${{ github.repository }}
          BRANCH: ${{ github.ref }}

[cschuchardt88]

@vncoelho Ill be updating it.

@Jim8y Blocker is waiting for PR #3306

@shargon dont merge

[cschuchardt88]

@superboyiii can you test it?

[cschuchardt88]

give codesign --force --deep -s - neo-cli a try

Works!

Can you retest this PR again. I updated to run codesign command to sign the application. Download the osx binary and run it to see it crashes again. But re-run the workflow in this PR, since I updated it.

[AnnaShaleva]

So how about the manually-triggered builds, don't we need them?

[cschuchardt88]

What are you talking about this is automatic on a publish release

[superboyiii]

give codesign --force --deep -s - neo-cli a try

Works!

Can you retest this PR again. I updated to run codesign command to sign the application. Download the osx binary and run it to see it crashes again. But re-run the workflow in this PR, since I updated it.

Sure

[cschuchardt88]

This PR resolves issue #3357 on release. But not for locally development. So @superboyiii you dont need to update the Directory.Build.props file anymore for VersionPerfix.

[superboyiii]

@cschuchardt88 Tried osx arm-x64, it works smoothly. Already codesigned.

[Jim8y]

LGTM, since this will only be used by NGD, so as long as it works for ngd as expected.

[cschuchardt88]

LGTM, since this will only be used by NGD, so as long as it works for ngd as expected.

Doesn't require dotnet to be installed also.

[cschuchardt88]

@cschuchardt88 Tried osx arm-x64, it works smoothly. Already codesigned.

@superboyiii
Can you test with oracle and other plugins, that require extra dotnet libraries to see if it works.

[superboyiii]

@cschuchardt88 Tried osx arm-x64, it works smoothly. Already codesigned.

@superboyiii Can you test with oracle and other plugins, that require extra dotnet libraries to see if it works.

Works well with Plugins