Taskfile.yml

---
version: '3'

metadata:
  package:
    download: '{{.REPO}}/releases/download/v{{.TAG}}/Fmi-{{.TAG}}-{{.PLATFORM_ARCH}}.zip'
    file: 'dse/build/_dist/Fmi-{{coalesce .TAG .PACKAGE_VERSION "not-specified"}}-{{.PLATFORM_ARCH}}.zip'
  container:
    repository: ghcr.io/boschglobal/dse-fmi

  models:
    dse.fmi.mcl:
      name: fmimcl
      displayName: dse.fmi.mcl
      path: fmimcl
      mcl: true
      workflows:
        - generate-fmimcl
        - generate-modelcfmu
        - generate-gatewayfmu
        - patch-signalgroup
      platforms:
        - linux-amd64
        - linux-x86
        - linux-i386
        - windows-x64
        - windows-x86
      channels:
        - alias: signal_channel
        - alias: network_channel

    dse.fmi.example.direct:
      name: direct
      displayName: dse.fmi.example.direct
      path: examples/direct/sim/model/direct
      workflows:
        - info
      platforms:
        - linux-amd64
        - linux-x86
        - linux-i386
        - windows-x64
        - windows-x86
      channels:
        - alias: in_vector
        - alias: out_vector

vars:
  # When running from E2E tests (i.e. Docker in Docker), the FMI_SIMDIR (for
  # Docker commands) must be set to the host relative path.
  FMI_SIMDIR: '{{if .SIM}}{{.ENTRYWORKDIR}}/{{.SIM}}{{else}}{{.PWD}}{{end}}'
  FMI_OUTDIR: '{{if .OUTDIR}}{{.ENTRYWORKDIR}}/{{.OUT}}{{else}}{{.PWD}}/out{{end}}'
  # Container image specification.
  FMI_REPO: 'https://github.com/boschglobal/dse.fmi'
  FMI_REGISTRY: ghcr.io/boschglobal
  FMI_TAG: '{{.TAG | default "latest"}}'
  FMI_USER:
    sh: id -u
  FMI_GROUP:
    sh: id -g

tasks:

  info:
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:info
    vars:
      FMI_IMAGE: '{{if .FMI_IMAGE}}{{.FMI_IMAGE}}{{else}}{{.FMI_REGISTRY}}/dse-fmi:{{.FMI_TAG}}{{end}}'
    cmds:
      - echo "** Taskfile global vars (FMI Namespace) **"
      - echo FMI_SIMDIR={{.FMI_SIMDIR}}
      - echo FMI_OUTDIR={{.FMI_OUTDIR}}
      - echo FMI_REPO={{.FMI_REPO}}
      - echo FMI_REGISTRY={{.FMI_REGISTRY}}
      - echo FMI_TAG={{.FMI_TAG}}
      - echo "** Taskfile Include vars **"
      - echo ENTRYWORKDIR={{.ENTRYWORKDIR}}
      - echo SIM={{.SIM}}
      - echo TAG={{.TAG}}
      - echo "** Runtime/Other vars **"
      - echo PACKAGE_VERSION={{.PACKAGE_VERSION}}
      - echo PLATFORM_ARCH={{.PLATFORM_ARCH}}
      - echo USER_WORKING_DIR={{.USER_WORKING_DIR}}

  generate-fmimcl:
    desc: Generate an FMI MCL from an existing FMU.
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:generate-fmimcl
    vars:
      MODEL_NAME: '{{.MODEL_NAME | default ""}}'
      # FMU_DIR: '{{.FMU_DIR}}'
      OUT_DIR: '{{.OUT_DIR | default "out/model"}}'
      # MCL_PATH: '{{.MCL_PATH}}'
      FMU_MODELDESC: '{{.FMU_DIR}}/modelDescription.xml'
      SIGNAL_GROUP: "{{if .SIGNAL_GROUP}}'{{.SIGNAL_GROUP}}'{{else}}'{{.OUT_DIR}}/signalgroup.yaml'{{end}}"
    env:
      FMU_DIR: '{{.FMU_DIR}}'
    cmds:
      - task: info
      - task: gen-fmimcl
        vars:
          MODEL_NAME: '{{.MODEL_NAME}}'
          FMU_DIR: '{{.FMU_DIR}}'
          OUT_DIR: '{{.OUT_DIR}}'
          MCL_PATH: '{{.MCL_PATH}}'
          PLATFORM: '{{coalesce .PLATFORM .PLATFORM_ARCH}}'
      - task: gen-signalgroup
        vars:
          MODEL_NAME: '{{.MODEL_NAME}}'
          INPUT: '{{.FMU_MODELDESC}}'
          OUTPUT: '{{.SIGNAL_GROUP}}'
    requires:
      vars: [FMU_DIR, MCL_PATH]
    metadata:
      vars:
        MODEL_NAME:
          required: false
          hint: The model name used for this FMU.
        FMU_DIR:
          required: true
          hint: URI identifying an FMU (select from 'uses' or manually enter a path).
        OUT_DIR:
          required: true
          hint: Directory where the model should be created (sim relative).
          default: out/model
        MCL_PATH:
          required: true
          hint: Path where the FMI MCL shared library is located.
        FMU_MODELDESC:
          required: false
          hint: Path where the FMI modelDescription.xml should be created.
          default: '{{.FMU_DIR}}/modelDescription.xml'
        SIGNAL_GROUP:
          required: false
          hint: Path where the associated Signal Group should be created.
          default: '{{.OUT_DIR}}/signalgroup.yaml'
        PLATFORM:
          required: false
          hint: Platform of the FMU being generated (normally set automatically).
      generates:
        - data/model.yaml
        - data/signalgroup.yaml

  generate-modelcfmu:
    aliases: [generate-fmimodelc]
    desc: Generate a FMI ModelC FMU from an existing (DSE/ModelC) Simer simulation.
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:generate-modelcfmu
    vars: {}
    cmds:
      - task: info
      - task: gen-modelcfmu-annotations
        vars:
          SIM_DIR: '{{.SIM_DIR}}'
          RULESET: 'signal-direction'
          INDEX: '{{.INDEX}}'
          SIGNAL_GROUPS: '{{.SIGNAL_GROUPS}}'
      - task: gen-modelcfmu
        vars:
          SIM_DIR: '{{.SIM_DIR}}'
          FMU_NAME: '{{.FMU_NAME}}'
          PLATFORM: '{{coalesce .PLATFORM .PLATFORM_ARCH}}'
          INDEX: '{{.INDEX}}'
          SIGNAL_GROUPS: '{{.SIGNAL_GROUPS}}'
          VERSION: '{{.VERSION}}'
          UUID: '{{.UUID}}'
          FMI_VERSION: '{{.FMI_VERSION}}'
          OUT_DIR: '{{.OUT_DIR}}'
    requires:
      vars: [FMU_NAME]
    metadata:
      vars:
        SIM_DIR:
          required: false
          hint: |
            URI identifying the simulation (Simer layout) to
            be packaged as an FMU. A container relative path, defaults to
            container working directory.
          default: /sim
        FMU_NAME:
          required: true
          hint: Name of the generated FMU.
        PLATFORM:
          required: false
          hint: Platform of the FMU being generated (normally set automatically).
        SIGNAL_GROUPS:
          required: true
          hint: Comma-delimited list of SignalGroup names. Matches 'doc.Metadata.Name'.
        VERSION:
          required: false
          hint: Version of the generated FMU.
        UUID:
          required: false
          hint: UUID of the generated FMU.
        FMI_VERSION:
          required: false
          hint: FMI version of the generated FMU (i.e. 2 or 3).
        OUT_DIR:
          required: false
          hint: |
            URI identifying the output folder for the FMU. A container relative
            path, defaults to /out. Should not be a sub-path of the SIM folder.
          default: /out

  generate-gatewayfmu:
    aliases: [generate-fmigateway]
    desc: Generate a FMI Gateway FMU from existing Signal Groups.
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:generate-gatewayfmu
    cmds:
      - task: info
      - task: gen-gatewayfmu
        vars:
          SIGNAL_GROUPS: '{{.SIGNAL_GROUPS}}'
          OUT_DIR: '{{.OUT_DIR}}'
          VERSION: '{{.VERSION}}'
          FMI_VERSION: '{{.FMI_VERSION}}'
          UUID: '{{.UUID}}'
          FMU_NAME: '{{.FMU_NAME | default "Gateway"}}'
          MODEL_IDENTIFIER: '{{.MODEL_IDENTIFIER}}'
          ANNOTATIONS: '{{.ANNOTATIONS}}'
          STACK: '{{.STACK}}'
          RUNTIME: '{{.RUNTIME}}'
          PLATFORM: '{{.PLATFORM}}'
    requires:
      vars: [SIGNAL_GROUPS]
    metadata:
      vars:
        SIGNAL_GROUPS:
          required: true
          hint: Signalgroups represented by this Gateway.
        OUT_DIR:
          required: false
          hint: Path where the FMU should be created.
          default: out
        RUNTIME:
          required: false
          hint: Runtime environment for the FMU.
        VERSION:
          required: false
          hint: Version of the generated FMU.
        FMI_VERSION:
          required: false
          hint: FMI version of the generated FMU (i.e. 2 or 3).
        UUID:
          required: false
          hint: UUID of the generated FMU.
        FMU_NAME:
          required: false
          hint: ModelName field in the FMU modelDescription.xml.
          default: Gateway
        MODEL_IDENTIFIER:
          required: false
          hint: MODEL_IDENTIFIER field in the FMU modelDescription.xml.
        ANNOTATIONS:
          required: false
          hint: extra arbitary information as annotations in dictionary format.

  gen-fmimcl:
    internal: true
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:gen-mcl
    vars:
      FMI_IMAGE: '{{if .FMI_IMAGE}}{{.FMI_IMAGE}}{{else}}{{.FMI_REGISTRY}}/dse-fmi:{{.FMI_TAG}}{{end}}'
      # FMU_DIR: '{{.FMU_DIR}}'
      OUT_DIR: '{{.OUT_DIR | default "out/model"}}'
      # MCL_PATH: '{{.MCL_PATH}}'
      PLATFORM: "{{if .PLATFORM}}--platform '{{.PLATFORM}}'{{else}}{{end}}"
      MODEL_NAME: "{{if .MODEL_NAME}}--name '{{.MODEL_NAME}}'{{else}}{{end}}"
    cmds:
      - docker run --rm
          --user {{.FMI_USER}}:{{.FMI_GROUP}}
          -v {{.FMI_SIMDIR}}:/sim
          {{.FMI_IMAGE}}
          gen-fmimcl
            --fmu {{.FMU_DIR}}
            --outdir {{.OUT_DIR}}
            --mcl {{.MCL_PATH}}
            {{.PLATFORM}}
            {{.MODEL_NAME}}
    requires:
      vars: [FMU_DIR, MCL_PATH]

  gen-signalgroup:
    internal: true
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:gen-signalgroup
    vars:
      FMI_IMAGE: '{{if .FMI_IMAGE}}{{.FMI_IMAGE}}{{else}}{{.FMI_REGISTRY}}/dse-fmi:{{.FMI_TAG}}{{end}}'
      MODEL_NAME: "{{if .MODEL_NAME}}--name '{{.MODEL_NAME}}'{{else}}{{end}}"
    cmds:
      - docker run --rm
          --user {{.FMI_USER}}:{{.FMI_GROUP}}
          -v {{.FMI_SIMDIR}}:/sim
          {{.FMI_IMAGE}}
          gen-signalgroup
            --input {{.INPUT}}
            --output {{.OUTPUT}}
            {{.MODEL_NAME}}
    requires:
      vars: [INPUT, OUTPUT]

  gen-modelcfmu:
    aliases: [gen-fmu]
    internal: true
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:gen-modelcfmu
    vars:
      FMI_IMAGE: '{{if .FMI_IMAGE}}{{.FMI_IMAGE}}{{else}}{{.FMI_REGISTRY}}/dse-fmi:{{.FMI_TAG}}{{end}}'
      SIM_DIR: "{{if .SIM_DIR}}--sim '{{.SIM_DIR}}'{{else}}{{end}}"
      # FMU_NAME: '{{.FMU_NAME}}'
      PLATFORM: "{{if .PLATFORM}}--platform '{{.PLATFORM}}'{{else}}{{end}}"
      SIGNAL_GROUPS: "{{if .SIGNAL_GROUPS}}--signalgroups '{{.SIGNAL_GROUPS}}'{{else}}{{end}}"
      VERSION: "{{if .VERSION}}--version '{{.VERSION}}'{{else}}{{end}}"
      UUID: "{{if .UUID}}--uuid '{{.UUID}}'{{else}}{{end}}"
      FMI_VERSION: "{{if .FMI_VERSION}}--fmiVersion '{{.FMI_VERSION}}'{{else}}{{end}}"
      OUT_DIR: "{{if .OUT_DIR}}--outdir '{{.OUT_DIR}}'{{else}}{{end}}"
    cmds:
      - echo "USING {{.FMI_IMAGE}} CMD {{.TASK}}"
      - docker run --rm
          --user {{.FMI_USER}}:{{.FMI_GROUP}}
          -v {{.FMI_SIMDIR}}:/sim
          -v {{.FMI_OUTDIR}}:/out
          {{.FMI_IMAGE}}
          gen-modelcfmu
            {{.SIM_DIR}}
            --name {{.FMU_NAME}}
            {{.OUT_DIR}}
            {{.PLATFORM}}
            {{.SIGNAL_GROUPS}}
            {{.VERSION}}
            {{.UUID}}
            {{.FMI_VERSION}}
    requires:
      vars: [FMU_NAME]

  gen-modelcfmu-annotations:
    internal: true
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:gen-modelcfmu-annotations
    vars:
      FMI_IMAGE: '{{if .FMI_IMAGE}}{{.FMI_IMAGE}}{{else}}{{.FMI_REGISTRY}}/dse-fmi:{{.FMI_TAG}}{{end}}'
      SIM_DIR: "{{if .SIM_DIR}}--sim '{{.SIM_DIR}}'{{else}}{{end}}"
      SIGNAL_GROUPS: "{{if .SIGNAL_GROUPS}}--signalgroups '{{.SIGNAL_GROUPS}}'{{else}}{{end}}"
      RULEFILE: "{{if .RULEFILE}}--rule '{{.RULEFILE}}'{{else}}{{end}}"
      RULESET: "{{if .RULESET}}--ruleset '{{.RULESET}}'{{else}}{{end}}"
      INDEX: "{{if .INDEX}}--index{{else}}{{end}}"
    cmds:
      - echo "USING {{.FMI_IMAGE}} CMD {{.TASK}}"
      - docker run --rm
          --user {{.FMI_USER}}:{{.FMI_GROUP}}
          -v {{.FMI_SIMDIR}}:/sim
          {{.FMI_IMAGE}}
          gen-modelcfmu-annotations
            {{.SIM_DIR}}
            {{.SIGNAL_GROUPS}}
            {{.RULEFILE}}
            {{.RULESET}}
            {{.INDEX}}
    requires:
      vars: []

  gen-gatewayfmu:
    internal: true
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:gen-gateway
    vars:
      FMI_IMAGE: '{{if .FMI_IMAGE}}{{.FMI_IMAGE}}{{else}}{{.FMI_REGISTRY}}/dse-fmi:{{.FMI_TAG}}{{end}}'
      SIGNAL_GROUPS: "{{if .SIGNAL_GROUPS}}--signalgroups '{{.SIGNAL_GROUPS}}'{{else}}{{end}}"
      OUT_DIR: "{{if .OUT_DIR}}--outdir '{{.OUT_DIR}}'{{else}}{{end}}"
      RUNTIME: "{{if .RUNTIME}}--runtime '{{.RUNTIME}}'{{else}}{{end}}"
      VERSION: "{{if .VERSION}}--version '{{.VERSION}}'{{else}}{{end}}"
      FMI_VERSION: "{{if .FMI_VERSION}}--fmiVersion '{{.FMI_VERSION}}'{{else}}{{end}}"
      UUID: "{{if .UUID}}--uuid '{{.UUID}}'{{else}}{{end}}"
      FMU_NAME: "{{if .FMU_NAME}}--name '{{.FMU_NAME}}'{{else}}{{end}}"
      MODEL_IDENTIFIER: "{{if .MODEL_IDENTIFIER}}--modelidentifier '{{.MODEL_IDENTIFIER}}'{{else}}{{end}}"
      ANNOTATIONS: '{{if .ANNOTATIONS}}--annotations {{squote .ANNOTATIONS}}{{else}}{{end}}'
      STACK: "{{if .STACK}}--stack '{{.STACK}}'{{else}}{{end}}"
      PLATFORM: "{{if .PLATFORM}}--platform '{{.PLATFORM}}'{{else}}{{end}}"
    cmds:
      - echo "USING {{.FMI_IMAGE}} CMD {{.TASK}}"
      - docker run --rm
          --user {{.FMI_USER}}:{{.FMI_GROUP}}
          -v {{.FMI_SIMDIR}}:/sim
          -v {{.FMI_OUTDIR}}:/out
          {{.FMI_IMAGE}}
          gen-gatewayfmu
            {{.SIGNAL_GROUPS}}
            {{.OUT_DIR}}
            {{.RUNTIME}}
            {{.VERSION}}
            {{.FMI_VERSION}}
            {{.UUID}}
            {{.FMU_NAME}}
            {{.MODEL_IDENTIFIER}}
            {{.ANNOTATIONS}}
            {{.STACK}}
            {{.PLATFORM}}
    requires:
      vars: [SIGNAL_GROUPS]

  patch-signalgroup:
    desc: |
      Patch changes into a generated Signal Group.

      Patch format:
      ´´´csv
      source,target
      input_1,input_1_patched
      input_2,input_2_patched
      output_1,output_1_patched
      output_2,inactive
      ´´´
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:patch-signalgroup
    vars:
      FMI_IMAGE: '{{if .FMI_IMAGE}}{{.FMI_IMAGE}}{{else}}{{.FMI_REGISTRY}}/dse-fmi:{{.FMI_TAG}}{{end}}'
      INPUT: '{{.INPUT}}'
      PATCH: '{{.PATCH}}'
      REMOVE_UNKNOWN: '{{if .REMOVE_UNKNOWN}}--remove-unknown{{else}}{{end}}'
    cmds:
      - echo "USING {{.FMI_IMAGE}} CMD {{.TASK}}"
      - docker run --rm
          --user {{.FMI_USER}}:{{.FMI_GROUP}}
          -v {{.FMI_SIMDIR}}:/sim
          {{.FMI_IMAGE}}
          patch-signalgroup
            --input {{.INPUT}}
            --patch {{.PATCH}}
            {{.REMOVE_UNKNOWN}}
    requires:
      vars: [INPUT, PATCH]
    metadata:
      vars:
        INPUT:
          required: true
          hint: Path identifying the Signal Group to be patched.
        PATCH:
          required: true
          hint: URI identifying the patch file to use.
        REMOVE_UNKNOWN:
          required: false
          hint: Remove unknown items (i.e. not in the patch file).
  package-legacy-gateway-fmu:
    desc: Package Legacy Gateway FMU
    run: always
    dir: '{{.USER_WORKING_DIR}}'
    label: dse:fmi:package-legacy-gateway-fmu
    vars:
      FMU_NAME: '{{.FMU_NAME | default "FMU"}}'
      FMI_VERSION: '{{.FMI_VERSION | default "1.1.43"}}'
      MODELC_VERSION: '{{.MODELC_VERSION | default "2.3.7"}}'
      GW_MODEL: '{{.GW_MODEL | default ""}}'
      GW_MODEL_FILES: '{{.GW_MODEL_FILES | default ""}}'
      STATIC_FILES: '{{.STATIC_FILES | default ""}}'

      FMI_x64: Fmi-{{.FMI_VERSION}}-windows-x64
      MODELC_x64: ModelC-{{.MODELC_VERSION}}-windows-x64
      MODELC_x86: ModelC-{{.MODELC_VERSION}}-windows-x86

      OUT_DIR: '{{.OUT_DIR | default "out"}}'
      DIST: '{{.OUT_DIR}}/dist'
      RELEASE: '{{.OUT_DIR}}/release/{{.FMU_NAME}}'
      RESOURCES: '{{.RELEASE}}/resources'
      BINARIES: '{{.RELEASE}}/binaries'
      LICENSES: '{{.RELEASE}}/licenses'
      MODELS: '{{.RESOURCES}}/model'
      TOOLS: '{{.RESOURCES}}/tools'
      SIMER_WIN: '{{.TOOLS}}/simer-windows'
      SIM_MODELS: '{{.OUT_DIR}}/sim/model'
      DOWNLOADS: '{{.OUT_DIR}}/downloads'

      TMP_DIR:
        sh: mktemp -d

    requires:
      vars: [GW_MODEL]

    cmds:
      # Clean & Prepare dirs
      - rm -rf {{.DIST}} {{.RELEASE}}
      - mkdir -p {{.DIST}} {{.RESOURCES}} {{.BINARIES}} {{.LICENSES}} {{.MODELS}} {{.TOOLS}} {{.DOWNLOADS}} {{.TMP_DIR}}
      - |
        echo "=== Packaging {{.FMU_NAME}} FMU ==="
        {{- if or (hasPrefix "2.0" .MODELC_VERSION) (hasPrefix "2.1" .MODELC_VERSION) (hasPrefix "2.2" .MODELC_VERSION) }}
            # ModelC (<2.3.7) : Redis + ModelC extraction

            echo "Copying Redis runtime files..."
            # Redis files from simer-windows
            rsync -av --exclude='x64/' --exclude='x86/' {{.OUT_DIR}}/sim/bin/. {{.TOOLS}}/Redis-x64-3.0.504/

            echo "Downloading ModelC dependencies..."
            # Download ModelC x64
            echo "Downloading ModelC x64..."
            curl --retry 5 --retry-delay 3 --fail --location \
              -o {{.TMP_DIR}}/{{.MODELC_x64}}.zip \
              https://github.com/boschglobal/dse.modelc/releases/download/v{{.MODELC_VERSION}}/{{.MODELC_x64}}.zip

            # Download ModelC x86
            echo "Downloading ModelC x86..."
            curl --retry 5 --retry-delay 3 --fail --location \
              -o {{.TMP_DIR}}/{{.MODELC_x86}}.zip \
              https://github.com/boschglobal/dse.modelc/releases/download/v{{.MODELC_VERSION}}/{{.MODELC_x86}}.zip


            echo "Extracting ModelC packages..."
            unzip -q -o {{.TMP_DIR}}/{{.MODELC_x64}}.zip -d {{.TMP_DIR}}
            mkdir -p {{.TOOLS}}/modelc/windows/x64
            cp -r {{.TMP_DIR}}/{{.MODELC_x64}}/. {{.TOOLS}}/modelc/windows/x64/

            unzip -q -o {{.TMP_DIR}}/{{.MODELC_x86}}.zip -d {{.TMP_DIR}}
            mkdir -p {{.TOOLS}}/modelc/windows/x86
            cp -r {{.TMP_DIR}}/{{.MODELC_x86}}/. {{.TOOLS}}/modelc/windows/x86/

            echo "Copying license files..."
            cp -r {{.TOOLS}}/modelc/windows/x64/licenses/. {{.LICENSES}}/
        {{- else }}
            # ModelC (>=2.3.7) : Simer bundle
            mkdir -p {{.SIMER_WIN}}
            echo "Copying Simer-windows binaries..."
            cp -r {{.OUT_DIR}}/sim/bin/. {{.SIMER_WIN}}/bin
            echo "Copying license files..."
            cp -r {{.OUT_DIR}}/sim/licenses/. {{.LICENSES}}
        {{- end }}

        echo "Copying simulation models..."
        cp -r {{.SIM_MODELS}}/. {{.MODELS}}/

        echo "Downloading FMI runtime dependencies..."
        # Download FMI runtime
        curl --retry 5 --retry-delay 3 --fail --location \
          -o {{.DOWNLOADS}}/{{.FMI_x64}}.zip \
          https://github.com/boschglobal/dse.fmi/releases/download/v{{.FMI_VERSION}}/{{.FMI_x64}}.zip

        mkdir -p {{.BINARIES}}/win64
        echo "Extracting FMI runtime libraries..."
        unzip -j -o {{.DOWNLOADS}}/{{.FMI_x64}}.zip \
          {{.FMI_x64}}/bin/libmodelc.dll \
          -d {{.BINARIES}}/win64

        unzip -j -o {{.DOWNLOADS}}/{{.FMI_x64}}.zip \
          {{.FMI_x64}}/fmigateway/lib/libfmi2gateway.dll \
          -d {{.BINARIES}}/win64

        # Copy Gateway resources
        {{- $files := splitList "," .GW_MODEL_FILES }}
        {{- range $f := $files }}
        {{- $file := trim $f }}
        {{- if eq $file "modelDescription.xml" }}
        cp {{$.SIM_MODELS}}/{{$.GW_MODEL}}/{{$file}} {{$.RELEASE}}
        {{- else }}
        cp {{$.SIM_MODELS}}/{{$.GW_MODEL}}/{{$file}} {{$.RESOURCES}}
        {{- end }}
        {{- end }}

        # Copy Static files
        {{- if and .STATIC_FILES (ne .STATIC_FILES "") }}
        {{- $static := splitList "," .STATIC_FILES }}
        {{- range $s := $static }}
        {{- $sf := trim $s }}
        {{- if $sf }}
        cp {{$.PWD}}/{{$sf}} {{$.RESOURCES}}
        {{- end }}
        {{- end }}
        {{- end }}
        echo "Creating FMU package..."
        # Create FMU
        (
          cd {{.RELEASE}} || exit 1
          zip -r ../../dist/{{.FMU_NAME}}.fmu .
        )

        echo "FMU created at {{.DIST}}/{{.FMU_NAME}}.fmu"