pax_global_header 0000666 0000000 0000000 00000000064 15165676005 0014525 g ustar 00root root 0000000 0000000 52 comment=c71a25e96364226ab702da1995b2a376f7ad3f00
zeroc-ice-3.8.1/ 0000775 0000000 0000000 00000000000 15165676005 0013416 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.clang-format 0000664 0000000 0000000 00000002720 15165676005 0015772 0 ustar 00root root 0000000 0000000 ---
# See https://clang.llvm.org/docs/ClangFormatStyleOptions.html
BasedOnStyle: LLVM
IndentWidth: 4
---
Language: Cpp
AccessModifierOffset: -4
AlignAfterOpenBracket: AlwaysBreak
AllowAllArgumentsOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowAllConstructorInitializersOnNextLine: false
AllowShortIfStatementsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: TopLevel
BinPackArguments: false
BinPackParameters: false
BreakBeforeBraces: Allman
ColumnLimit: 120
DerivePointerAlignment: false
FixNamespaceComments: false
IndentCaseLabels: true
IndentPPDirectives: AfterHash
KeepEmptyLinesAtTheStartOfBlocks: false
NamespaceIndentation: All
PackConstructorInitializers: CurrentLine
PointerAlignment: Left
SpaceAfterTemplateKeyword: false
TabWidth: 4
UseTab: Never
---
Language: ObjC
AccessModifierOffset: -4
AlignAfterOpenBracket: AlwaysBreak
AllowAllArgumentsOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowAllConstructorInitializersOnNextLine: false
AllowShortIfStatementsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: TopLevel
BinPackArguments: false
BinPackParameters: false
BreakBeforeBraces: Allman
ColumnLimit: 120
DerivePointerAlignment: false
FixNamespaceComments: false
IndentCaseLabels: true
IndentPPDirectives: AfterHash
KeepEmptyLinesAtTheStartOfBlocks: false
NamespaceIndentation: All
PackConstructorInitializers: CurrentLine
PointerAlignment: Left
SpaceAfterTemplateKeyword: false
TabWidth: 4
UseTab: Never
zeroc-ice-3.8.1/.clang-format-ignore 0000664 0000000 0000000 00000000622 15165676005 0017252 0 ustar 00root root 0000000 0000000 # C++ code generated from the Bison/Flex parsers
cpp/src/Slice/Grammar.h
cpp/src/Slice/Grammar.cpp
cpp/src/Slice/Scanner.cpp
cpp/src/IceGrid/Grammar.h
cpp/src/IceGrid/Grammar.cpp
cpp/src/IceGrid/Scanner.cpp
cpp/src/IceStorm/Grammar.h
cpp/src/IceStorm/Grammar.cpp
cpp/src/IceStorm/Scanner.cpp
# The property files generated from `makeprops.py`
cpp/src/Ice/PropertyNames.h
cpp/src/Ice/PropertyNames.cpp
zeroc-ice-3.8.1/.clang-tidy 0000664 0000000 0000000 00000001542 15165676005 0015454 0 ustar 00root root 0000000 0000000 Checks:
'-*,
clang-analyzer-*,
-clang-analyzer-optin.core.EnumCastOutOfRange,
cert-*,
modernize-*,
-modernize-avoid-c-arrays,
-modernize-use-trailing-return-type,
-modernize-macro-to-enum,
-modernize-use-designated-initializers,
-modernize-use-constraints,
-modernize-use-ranges,
-modernize-loop-convert,
-modernize-use-starts-ends-with,
performance-*,
-performance-avoid-endl,
-performance-enum-size,
-performance-inefficient-string-concatenation,
'
WarningsAsErrors: '*'
HeaderFilterRegex: '.*'
ExcludeHeaderFilterRegex: 'include/lmdb.h|include/python*/*|Grammar.h|dbus/*'
UseColor: true
FormatStyle: 'file'
CheckOptions:
modernize-use-nullptr.NullMacros: 'NULL'
# std::exception_ptr is a cheap to copy, pointer-like type; we pass it by value all the time.
performance-unnecessary-value-param.AllowedTypes: 'exception_ptr$;'
zeroc-ice-3.8.1/.devcontainer/ 0000775 0000000 0000000 00000000000 15165676005 0016155 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.devcontainer/Dockerfile 0000664 0000000 0000000 00000001762 15165676005 0020155 0 ustar 00root root 0000000 0000000 FROM mcr.microsoft.com/devcontainers/base:ubuntu-24.04
USER vscode
WORKDIR /home/vscode
RUN set -eux \
&& wget -q https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb \
&& sudo dpkg -i packages-microsoft-prod.deb \
&& rm packages-microsoft-prod.deb \
&& sudo apt update \
&& sudo apt-get install -y php-dev python3 python3-dev python3-passlib ruby-full gdb \
&& sudo apt-get install -y libbluetooth-dev libbz2-dev libdbus-1-dev libedit-dev libexpat1-dev liblmdb-dev libmcpp-dev libssl-dev libsystemd-dev \
&& sudo apt-get install -y openjdk-17-jdk \
&& sudo rm -rf /var/lib/apt/lists/* \
&& sudo apt-get clean
# Install .NET 8.0
RUN set -eux \
&& curl https://dot.net/v1/dotnet-install.sh -o dotnet-install.sh -L \
&& chmod +x dotnet-install.sh \
&& ./dotnet-install.sh -v latest -c 8.0
# Set environment variables
ENV DOTNET_ROOT=/home/vscode/.dotnet
ENV PATH=$DOTNET_ROOT:$PATH
ENV LANG=en_US.UTF-8
zeroc-ice-3.8.1/.devcontainer/debian12/ 0000775 0000000 0000000 00000000000 15165676005 0017542 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.devcontainer/debian12/Dockerfile 0000664 0000000 0000000 00000001010 15165676005 0021524 0 ustar 00root root 0000000 0000000 FROM mcr.microsoft.com/devcontainers/base:debian-12
USER vscode
WORKDIR /home/vscode
RUN sudo apt update \
&& sudo apt-get install -y \
php-dev python3 python3-dev python3-passlib ruby-full gdb \
libbluetooth-dev libbz2-dev libdbus-1-dev libedit-dev libexpat1-dev liblmdb-dev \
libmcpp-dev libssl-dev libsystemd-dev \
dh-exec dh-php dh-python locales-all php-all-dev python3-setuptools \
build-essential git devscripts curl \
&& sudo rm -rf /var/lib/apt/lists/* \
&& sudo apt-get clean
zeroc-ice-3.8.1/.devcontainer/debian12/devcontainer.json 0000664 0000000 0000000 00000001427 15165676005 0023122 0 ustar 00root root 0000000 0000000 {
// Use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
"build": {
"dockerfile": "Dockerfile"
},
"runArgs": [
// "--cpuset-cpus=0-1", // Limit CPU usage
// "--shm-size=4gb" // Limit memory usage
],
// Configure tool-specific properties
"customizations": {
"vscode": {
/* spell-checker:disable */
"extensions": [
"davidson.vscode-markdownlint",
"editorconfig.editorconfig",
"ms-azuretools.vscode-docker",
"streetsidesoftware.code-spell-checker",
"zerocinc.slice",
"ms-vscode.cpptools-extension-pack"
]
/* spell-checker:enable */
}
}
}
zeroc-ice-3.8.1/.devcontainer/devcontainer.json 0000664 0000000 0000000 00000001427 15165676005 0021535 0 ustar 00root root 0000000 0000000 {
// Use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
"build": {
"dockerfile": "Dockerfile"
},
"runArgs": [
// "--cpuset-cpus=0-1", // Limit CPU usage
// "--shm-size=4gb" // Limit memory usage
],
// Configure tool-specific properties
"customizations": {
"vscode": {
/* spell-checker:disable */
"extensions": [
"davidson.vscode-markdownlint",
"editorconfig.editorconfig",
"ms-azuretools.vscode-docker",
"streetsidesoftware.code-spell-checker",
"zerocinc.slice",
"ms-vscode.cpptools-extension-pack"
]
/* spell-checker:enable */
}
}
}
zeroc-ice-3.8.1/.devcontainer/rhel9/ 0000775 0000000 0000000 00000000000 15165676005 0017200 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.devcontainer/rhel9/Dockerfile 0000664 0000000 0000000 00000001465 15165676005 0021200 0 ustar 00root root 0000000 0000000 FROM registry.access.redhat.com/ubi9
RUN dnf install -y https://zeroc.com/download/ice/3.7/el9/ice-repo-3.7.el9.noarch.rpm && \
dnf clean all
# Install required build tools and dependencies
RUN dnf install -y \
sudo \
make \
curl-minimal \
git \
gcc-c++ \
glibc-devel \
libstdc++-devel \
redhat-rpm-config \
glibc-static \
libstdc++-static \
mcpp-devel \
bzip2-devel \
openssl-devel \
expat-devel \
libedit-devel \
lmdb-devel \
python3-devel \
&& dnf clean all
# Create a non-root user and set permissions
RUN useradd -ms /bin/bash vscode \
&& mkdir -p /home/vscode \
&& chown -R vscode:vscode /home/vscode \
&& echo "vscode ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers.d/vscode
USER vscode
WORKDIR /home/vscode
ENV LANG=en_US.UTF-8
zeroc-ice-3.8.1/.devcontainer/rhel9/devcontainer.json 0000664 0000000 0000000 00000001455 15165676005 0022561 0 ustar 00root root 0000000 0000000 {
// Use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
"name": "RHEL 9",
"build": {
"dockerfile": "Dockerfile"
},
"runArgs": [
// "--cpuset-cpus=0-1", // Limit CPU usage
// "--shm-size=4gb" // Limit memory usage
],
// Configure tool-specific properties
"customizations": {
"vscode": {
/* spell-checker:disable */
"extensions": [
"davidson.vscode-markdownlint",
"editorconfig.editorconfig",
"ms-azuretools.vscode-docker",
"streetsidesoftware.code-spell-checker",
"zerocinc.slice",
"ms-vscode.cpptools-extension-pack"
]
/* spell-checker:enable */
}
}
}
zeroc-ice-3.8.1/.editorconfig 0000664 0000000 0000000 00000000476 15165676005 0016102 0 ustar 00root root 0000000 0000000 # Remove the line below if you want to inherit .editorconfig settings from higher directories
root = true
# all files
[*]
#### Guidelines ####
guidelines = 120
#### Core EditorConfig Options ####
# New line preferences
insert_final_newline = true
# License header
file_header_template = Copyright (c) ZeroC, Inc.
zeroc-ice-3.8.1/.gitattributes 0000664 0000000 0000000 00000000143 15165676005 0016307 0 ustar 00root root 0000000 0000000 * text=auto
js/package.json text eol=lf
js/package-lock.json text eol=lf
gradlew.bat text eol=crlf
zeroc-ice-3.8.1/.github/ 0000775 0000000 0000000 00000000000 15165676005 0014756 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 15165676005 0017141 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/ISSUE_TEMPLATE/bug_report.yml 0000664 0000000 0000000 00000002217 15165676005 0022036 0 ustar 00root root 0000000 0000000 name: Bug report
description: Create a report to help us improve
labels: []
body:
- type: textarea
id: version
attributes:
label: Version
description: Please provide the following version information
placeholder: |
- Ice Version [e.g. 3.7.9]
- OS: [e.g. Linux, Windows, macOS]
- Distribution: [e.g. YUM, Apt, Homebrew]
validations:
required: true
- type: textarea
id: description
attributes:
label: Describe the bug
description: |
A clear and concise description of what the bug is.
placeholder: Description
validations:
required: true
- type: textarea
id: expected-behavior
attributes:
label: Expected behavior
description: |
A clear and concise description of what you expected to happen.
placeholder: Description
validations:
required: true
- type: textarea
id: additional-context
attributes:
label: Additional context
description: |
Add any other context or screenshots about the feature request here.
placeholder: Additional context
validations:
required: false
zeroc-ice-3.8.1/.github/actions/ 0000775 0000000 0000000 00000000000 15165676005 0016416 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/build-slice-compiler/ 0000775 0000000 0000000 00000000000 15165676005 0022422 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/build-slice-compiler/action.yml 0000664 0000000 0000000 00000002661 15165676005 0024427 0 ustar 00root root 0000000 0000000 name: "Build Slice Compiler"
description: "Builds a Slice compiler from C++ source for multiple platforms"
inputs:
compiler_name:
description: "Name of the compiler to build"
required: true
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
default: "false"
runs:
using: "composite"
steps:
- name: Build on Windows
if: runner.os == 'Windows'
run: |
nuget restore cpp/msbuild/ice.slnx
MSBuild /m cpp/msbuild/ice.slnx /p:Configuration=Release /p:Platform=x64 /t:${{ inputs.compiler_name }}
shell: cmd
- name: Build on Linux/macOS
if: runner.os != 'Windows'
run: |
make -C cpp OPTIMIZE=yes V=1 ${{ inputs.compiler_name }}
shell: bash
- name: Sign Compiler Artifact
if: runner.os == 'Windows' && inputs.authenticode_sign == 'true'
uses: azure/trusted-signing-action@v0
with:
azure-tenant-id: ${{ env.AZURE_TENANT_ID }}
azure-client-id: ${{ env.AZURE_CLIENT_ID }}
azure-client-secret: ${{ env.AZURE_CLIENT_SECRET }}
endpoint: https://eus.codesigning.azure.net/
trusted-signing-account-name: zeroc
certificate-profile-name: zeroc-ice
files: ${{ github.workspace }}\cpp\bin\x64\Release\${{ inputs.compiler_name }}.exe
file-digest: SHA256
timestamp-rfc3161: http://timestamp.acs.microsoft.com
timestamp-digest: SHA256
zeroc-ice-3.8.1/.github/actions/build/ 0000775 0000000 0000000 00000000000 15165676005 0017515 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/build/action.yml 0000664 0000000 0000000 00000003736 15165676005 0021526 0 ustar 00root root 0000000 0000000 name: Build Ice
description: Builds Ice for the current platform using Make (macOS/Linux) or MSBuild (Windows).
inputs:
working_directory:
description: "The working directory to run the build in"
default: "."
build_flags:
description: "Additional flags to pass to the build"
default: ""
msbuild_project:
description: "The project file to build"
default: "ice.proj"
msbuild_command:
description: "The msbuild command to use"
default: "msbuild /m"
build_cpp_and_python:
description: "Build C++ and Python"
default: "false"
build_android_controller:
description: "Build Android Controller"
default: "false"
runs:
using: "composite"
steps:
# macOS and Linux
- name: Build C++ and Python
run: |
make ${{ inputs.build_flags }} -C cpp srcs
make -C python
shell: bash
if: (runner.os == 'macOS' || runner.os == 'Linux') && inputs.build_cpp_and_python == 'true'
- name: Build
working-directory: ${{ inputs.working_directory }}
run: make ${{ inputs.build_flags }}
shell: bash
if: runner.os == 'macOS' || runner.os == 'Linux'
# Android
- name: Build Android
working-directory: ${{ inputs.working_directory }}
run: |
cd test/android/controller
./gradlew build checkstyle
./gradlew rewriteDryRun --no-parallel --no-configuration-cache
shell: bash
if: inputs.build_android_controller == 'true'
# Windows
- name: Build C++ and Python
run: |
msbuild /m ${{ inputs.build_flags }} /t:BuildDist cpp/msbuild/ice.proj
msbuild /m ${{ inputs.build_flags }} python/msbuild/ice.proj
shell: powershell
if: runner.os == 'Windows' && inputs.build_cpp_and_python == 'true'
- name: Build
working-directory: ${{ inputs.working_directory }}
run: ${{ inputs.msbuild_command }} ${{ inputs.build_flags }} ${{ inputs.msbuild_project }}
shell: powershell
if: runner.os == 'Windows'
zeroc-ice-3.8.1/.github/actions/dispatch-workflow/ 0000775 0000000 0000000 00000000000 15165676005 0022065 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/dispatch-workflow/action.yml 0000664 0000000 0000000 00000002131 15165676005 0024062 0 ustar 00root root 0000000 0000000 name: "Dispatch Workflow"
description: "Trigger a workflow_dispatch on a given ref with optional inputs"
inputs:
ref:
description: "Git ref to dispatch"
required: true
workflow:
description: "Workflow filename to dispatch"
required: true
token:
description: "GitHub token with workflow scope"
required: true
inputs:
description: "JSON object of inputs to pass to the workflow"
required: false
default: "{}"
runs:
using: "composite"
steps:
- name: Dispatch workflow
run: |
set -euo pipefail
echo "Dispatching ${WORKFLOW} on ref ${REF}"
# Build -f flags from JSON inputs
INPUT_ARGS=""
if [[ "${INPUTS}" != "{}" ]]; then
INPUT_ARGS=$(echo "${INPUTS}" | jq -r 'to_entries | .[] | "-f \(.key)=\(.value)"' | tr '\n' ' ')
fi
# shellcheck disable=SC2086
gh workflow run "${WORKFLOW}" --ref "${REF}" ${INPUT_ARGS}
env:
GH_TOKEN: ${{ inputs.token }}
REF: ${{ inputs.ref }}
WORKFLOW: ${{ inputs.workflow }}
INPUTS: ${{ inputs.inputs }}
shell: bash
zeroc-ice-3.8.1/.github/actions/documentation/ 0000775 0000000 0000000 00000000000 15165676005 0021267 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/documentation/action.yml 0000664 0000000 0000000 00000012200 15165676005 0023262 0 ustar 00root root 0000000 0000000 name: API Reference
description: Generate API reference documentation for Ice
inputs:
aws-access-key-id:
description: "AWS access key ID"
required: true
aws-secret-access-key:
description: "AWS secret access key"
required: true
aws-s3-code-bucket:
description: "AWS S3 bucket for storing the API reference"
required: true
github-token:
description: "GitHub token used by phive to access the GitHub API (to get the versions of the packages)"
required: true
runs:
using: "composite"
steps:
# Use --formula to silence homebrew warning when installing doxygen from a formula.
- name: Install doxygen and graphviz (a dependency of Doxygen for generating diagrams)
run: |
brew install graphviz || true
brew install doxygen --formula || true
shell: bash
- name: Install docfx for C# API reference
run: dotnet tool install -g docfx
shell: bash
- name: Generate Doxygen API reference for Slice
working-directory: ./doxygen
run: doxygen
shell: bash
- name: Generate Doxygen API reference for C++
working-directory: ./cpp/doxygen
run: doxygen
shell: bash
- name: Generate TypeDoc API reference for JavaScript
working-directory: ./js
run: make doc
shell: bash
- name: Generate docfx API reference for C#
working-directory: ./csharp/docfx
run: |
docfx metadata --property Configuration=Release
docfx build
shell: bash
- name: Generate Python API reference
working-directory: ./python/docs
run: |
pip install -r requirements.txt
make html
shell: bash
- name: Generate API reference for Swift
run: |
mkdir ./swift/docs
touch doc_output.log
swift package --allow-writing-to-directory ./swift/docs generate-documentation \
--enable-experimental-combined-documentation \
--fallback-display-name "Ice for Swift" \
--target Ice --target IceStorm --target Glacier2 --target IceGrid \
--output-path ./swift/docs --transform-for-static-hosting --hosting-base-path /ice/3.8/api/swift 2>&1 | tee -a doc_output.log
# Check if the documentation generation had any warnings
if grep -q "^warning:" doc_output.log; then
echo "Documentation generation had warnings"
exit 1
fi
shell: bash
- name: Generate API reference for Java
working-directory: ./java
run: |
make -C ../cpp slice2java
./gradlew :alljavadoc
shell: bash
- name: Generate API reference for Ruby
working-directory: ./ruby
run: |
gem install --user-install yard
export PATH="$(ruby -r rubygems -e 'puts Gem.user_dir')/bin:$PATH"
yard doc 'ruby/**/*.rb'
shell: bash
- name: Generate API reference for PHP
working-directory: ./php
env:
# We need to set the GITHUB_AUTH_TOKEN to allow phive use the GitHub API to get the versions
# of the packages. If we don't set this, phive will likely fail with a 403 error.
GITHUB_AUTH_TOKEN: "${{ inputs.github-token }}"
run: |
set -x
brew install phive
phive install phpDocumentor --trust-gpg-keys 6DA3ACC4991FFAE5 --temporary
./tools/phpDocumentor --config ./phpdoc.dist.xml
shell: bash
# This will perform a full sync of the documentation to S3 every time the workflow is run since
# the timestamps will always be different. Using --size-only is not sufficient since the
# documentation may be updated without changing the size of the files. S3 does not offer a hash based sync.
#
# Additionally, we do not cache the doxygen output since it does not remove files old files.
- name: Sync Documentation to S3
run: |
aws s3 sync ./doxygen/slice s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/slice --delete
aws s3 cp ./doxygen/slice.tag s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/slice.tag
aws s3 sync ./cpp/doxygen/cpp s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/cpp --delete
aws s3 cp ./cpp/doxygen/icecpp.tag s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/icecpp.tag
aws s3 sync ./csharp/docfx/_site s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/csharp --delete
aws s3 sync ./js/docs s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/javascript --delete
aws s3 sync ./python/docs/_build/html s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/python --delete
aws s3 sync ./swift/docs s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/swift --delete
aws s3 sync ./java/build/docs/javadoc s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/java --delete
aws s3 sync ./ruby/doc s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/ruby --delete
aws s3 sync ./php/doc/api s3://${AWS_S3_CODE_BUCKET}/ice/3.8/api/php --delete
env:
AWS_ACCESS_KEY_ID: ${{ inputs.aws-access-key-id }}
AWS_SECRET_ACCESS_KEY: ${{ inputs.aws-secret-access-key }}
AWS_S3_CODE_BUCKET: ${{ inputs.aws-s3-code-bucket }}
AWS_DEFAULT_REGION: us-east-1
shell: bash
if: github.ref == 'refs/heads/3.8' && github.event_name != 'pull_request' && github.repository == 'zeroc-ice/ice'
zeroc-ice-3.8.1/.github/actions/install-windows-debug-tools/ 0000775 0000000 0000000 00000000000 15165676005 0023776 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/install-windows-debug-tools/action.yml 0000664 0000000 0000000 00000002575 15165676005 0026007 0 ustar 00root root 0000000 0000000 name: Windows Debug Tools Installer
description: "Installs Debugging Tools for Windows using the Windows SDK installer."
runs:
using: "composite"
steps:
- name: Install Debugging Tools for Windows
shell: pwsh
run: |
$sdkPath = "${{ runner.temp }}\sdksetup.exe"
$logPath = "${{ runner.temp }}\sdk.log"
Write-Host "Downloading Windows SDK installer..."
Invoke-WebRequest -Uri "https://go.microsoft.com/fwlink/?linkid=2338977" -OutFile $sdkPath
Write-Host "Running Windows SDK installer (Debugging Tools only)..."
$args = '/quiet /norestart /features OptionId.WindowsDesktopDebuggers /log "{0}"' -f $logPath
$p = Start-Process -FilePath $sdkPath -ArgumentList $args -PassThru -Wait
if ($p.ExitCode -ne 0) {
Write-Error "Windows SDK installer failed with exit code $($p.ExitCode). See log at $logPath."
exit $p.ExitCode
}
- name: Add Debug Tools to PATH
shell: pwsh
run: |
$debugToolsPath = "C:\Program Files (x86)\Windows Kits\10\Debuggers\x64"
$srcsrvPath = "$debugToolsPath\srcsrv"
echo "$debugToolsPath" >> $env:GITHUB_PATH
echo "$srcsrvPath" >> $env:GITHUB_PATH
- name: Upload SDK install log
if: failure()
uses: actions/upload-artifact@v4
with:
name: sdk-install-log
path: ${{ runner.temp }}/sdk.log
zeroc-ice-3.8.1/.github/actions/macos-fqdn/ 0000775 0000000 0000000 00000000000 15165676005 0020446 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/macos-fqdn/action.yml 0000664 0000000 0000000 00000006134 15165676005 0022452 0 ustar 00root root 0000000 0000000 # The macOS FQDN can be misconfigured on GitHub-hosted runners,
# causing issues with some tests that expect a valid FQDN.
# See https://github.com/actions/runner-images/issues/12562
#
# Example from a runner that is good:
# > scutil --get ComputerName
# iad20-fj925-81b5ba22-7890-42f2-92e2-f0dbf5ebb8ed-1E029398D518
# > scutil --get LocalHostName
# iad20-fj925-81b5ba22-7890-42f2-92e2-f0dbf5ebb8ed-1E029398D518
# > scutil --get HostName
# iad20-fj925-81b5ba22-7890-42f2-92e2-f0dbf5ebb8ed-1E029398D518.local
name: macOS FQDN
description: Ensures the macOS runner has a valid Fully Qualified Domain Name (FQDN) by checking and fixing its hostname configuration.
runs:
using: "composite"
steps:
- name: Print host info
shell: bash
run: |
echo "ComputerName: $(scutil --get ComputerName)"
echo "LocalHostName: $(scutil --get LocalHostName)"
echo "HostName: $(scutil --get HostName)"
echo "FQDN: $(hostname -f)"
echo "Short hostname: $(hostname -s)"
echo "/etc/hosts:"
cat /etc/hosts
- name: Check and fix FQDN
shell: bash
run: |
RUNNER_FQDN=$(hostname -f)
# GitHub macOS runners will always have an entry for the hostname in /etc/hosts.
# For example: 192.168.64.24 iad20-fj917_6cae4d32-d0ce-456c-8173-514448759e72-FE7BB458E416.local iad20-fj917_6cae4d32-d0ce-456c-8173-514448759e72-FE7BB458E416
# This is the correct FQDN that matches the runner's IP address.
# Due to a bug/misconfiguration, the actual hostname of the runner is sometimes something else.
#
# If the runner FQDN is not in /etc/hosts, we find the correct entry in /etc/hosts and update the hostname.
if ! grep -qF "$RUNNER_FQDN" /etc/hosts; then
echo "Runner hostname $RUNNER_FQDN not found in /etc/hosts. Updating hostname to match /etc/hosts."
# Find the entry in /etc/hosts that corresponds to what the hostname should be.
# It's the one that ends in ".local" and is not "localhost" or "broadcasthost".
ENTRY=$(grep '\.local' /etc/hosts | grep -v 'localhost' | grep -v 'broadcasthost' | grep -v '^#' | head -1 || true)
if [ -n "$ENTRY" ]; then
HOSTNAME=$(echo "$ENTRY" | awk '{print $2}')
SHORT_HOSTNAME="${HOSTNAME%%.*}"
echo "Setting hostname from /etc/hosts: $ENTRY"
sudo scutil --set ComputerName "${SHORT_HOSTNAME}" # User-friendly name
sudo scutil --set LocalHostName "${SHORT_HOSTNAME}" # The Bonjour/mDNS name
sudo scutil --set HostName "${HOSTNAME}" # The system hostname
sudo dscacheutil -flushcache
else
echo "No suitable entry found in /etc/hosts."
fi
fi
- name: Print host info
shell: bash
run: |
echo "ComputerName: $(scutil --get ComputerName)"
echo "LocalHostName: $(scutil --get LocalHostName)"
echo "HostName: $(scutil --get HostName)"
echo "FQDN: $(hostname -f)"
echo "Short hostname: $(hostname -s)"
echo "/etc/hosts:"
cat /etc/hosts
zeroc-ice-3.8.1/.github/actions/setup-android/ 0000775 0000000 0000000 00000000000 15165676005 0021174 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-android/action.yml 0000664 0000000 0000000 00000002431 15165676005 0023174 0 ustar 00root root 0000000 0000000 name: Setup Android
description: Setup Android SDK and Emulator
runs:
using: "composite"
steps:
# See https://github.com/marketplace/actions/android-emulator-runner
- name: Enable KVM group perms
shell: bash
run: |
echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
sudo udevadm control --reload-rules
sudo udevadm trigger --name-match=kvm
- name: Android SDK and PATH
shell: bash
run: |
echo "$ANDROID_HOME/cmdline-tools/latest/bin" >> $GITHUB_PATH
echo "$ANDROID_HOME/emulator" >> $GITHUB_PATH
echo "$ANDROID_HOME/platform-tools" >> $GITHUB_PATH
# For some reason avdmanager is placing the avd into $HOME/.config/.android/avd instead of $HOME/.android/avd
echo "ANDROID_AVD_HOME=$HOME/.config/.android" >> $GITHUB_ENV
- name: Configure Android SDK
shell: bash
run: |
# platform-tools, build-tools, and platforms are pre-installed on GitHub runners
# We only need to install the system image for the emulator
if [ "$(uname -m)" = "aarch64" ]; then
ARCH="arm64-v8a"
else
ARCH="x86_64"
fi
sdkmanager "system-images;android-36;google_apis;$ARCH"
zeroc-ice-3.8.1/.github/actions/setup-cache/ 0000775 0000000 0000000 00000000000 15165676005 0020617 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-cache/action.yml 0000664 0000000 0000000 00000005635 15165676005 0022630 0 ustar 00root root 0000000 0000000 name: Setup Cache
description: Configures ccache for C++ compilation caching across platforms.
inputs:
prefix:
description: "Cache key prefix"
required: true
runs:
using: "composite"
steps:
#
# Cache
#
- name: Get Linux version
if: runner.os == 'Linux'
id: linux-version
run: echo "version=$(lsb_release -rs)" >> $GITHUB_OUTPUT
shell: bash
- name: Get macOS version
if: runner.os == 'macOS'
id: macos-version
run: echo "version=$(sw_vers -productVersion)" >> $GITHUB_OUTPUT
shell: bash
- name: Get Windows version
if: runner.os == 'Windows'
id: windows-version
run: |
echo "version=$((Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion').DisplayVersion)" >> $env:GITHUB_OUTPUT
shell: powershell
- name: Set OS version output
id: os-version
run: |
if [ "$RUNNER_OS" == "Linux" ]; then
echo "version=${{ steps.linux-version.outputs.version }}" >> $GITHUB_OUTPUT
elif [ "$RUNNER_OS" == "macOS" ]; then
echo "version=${{ steps.macos-version.outputs.version }}" >> $GITHUB_OUTPUT
elif [ "$RUNNER_OS" == "Windows" ]; then
echo "version=${{ steps.windows-version.outputs.version }}" >> $GITHUB_OUTPUT
fi
shell: bash
- name: Setup ccache
uses: hendrikmuhs/ccache-action@v1.2
with:
create-symlink: false
append-timestamp: false
key: ${{ inputs.prefix }}-${{ runner.os }}-${{ steps.os-version.outputs.version }}-${{ runner.arch }}-${{ github.sha }}
restore-keys: |
${{ inputs.prefix }}-${{ runner.os }}-${{ steps.os-version.outputs.version }}-${{ runner.arch }}
max-size: 1G
evict-old-files: job
variant: ${{ runner.os == 'Windows' && 'ccache' || 'ccache' }}
save: ${{ github.ref == 'refs/heads/main' && github.event_name == 'push' }}
- name: Configure ccache path
if: runner.os == 'macOS' || runner.os == 'Linux'
shell: bash
run: |
echo "/usr/lib/ccache" >> $GITHUB_PATH
echo "/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
echo "/opt/homebrew/opt/ccache/libexec" >> $GITHUB_PATH
# See https://github.com/ccache/ccache/wiki/MS-Visual-Studio
# The same instructions apply to sccache
- name: Setup ccache
if: runner.os == 'Windows'
shell: powershell
run: |
# Find ccache in path and copy it to cl.exe
$ccache = Get-Command ccache.exe -ErrorAction Stop
if ($ccache -eq $null) {
Write-Host "ccache not found in PATH"
exit 1
}
# Copy $ccache to C:\cl.exe
Copy-Item $ccache.Path C:\cl.exe
# Set required environment variables for ccache to work with MSVC
echo "USING_BUILD_CACHE=true" >> $env:GITHUB_ENV
echo "CLToolExe=C:\cl.exe" >> $env:GITHUB_ENV
echo "CLToolPath=C:\" >> $env:GITHUB_ENV
zeroc-ice-3.8.1/.github/actions/setup-cpp/ 0000775 0000000 0000000 00000000000 15165676005 0020336 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-cpp/action.yml 0000664 0000000 0000000 00000003505 15165676005 0022341 0 ustar 00root root 0000000 0000000 name: Setup C++
description: Installs C++ build dependencies and configures the build environment for the current platform.
inputs:
profile:
description: >
The dependency profile to install.
'full' installs all C++ dependencies (default).
'pip-bdist' installs only the minimal dependencies needed to build a pip wheel from sdist.
default: "full"
runs:
using: "composite"
steps:
- name: Install dependencies on macOS
if: runner.os == 'macOS' && inputs.profile == 'full'
shell: bash
run: brew install mcpp lmdb
- name: Install dependencies on Linux
if: runner.os == 'Linux' && inputs.profile == 'full'
shell: bash
run: |
sudo apt-get update && sudo apt-get install -y \
libbz2-dev libssl-dev libffi-dev \
libmcpp-dev libedit-dev liblmdb-dev libexpat1-dev libsystemd-dev \
libbluetooth-dev libdbus-1-dev \
gdb
- name: Install pip bdist dependencies on Linux
if: runner.os == 'Linux' && inputs.profile == 'pip-bdist'
shell: bash
run: |
sudo apt-get update && sudo apt-get install -y \
libbz2-dev libssl-dev
# This is needed for GDB to work on Linux runners
- name: Disable ptrace protection on Linux
if: runner.os == 'Linux' && inputs.profile == 'full'
shell: bash
run: echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
- name: Set macOS MAKEFLAGS
run: echo "MAKEFLAGS=-j$(sysctl -n hw.ncpu) V=1" >> $GITHUB_ENV
shell: bash
if: runner.os == 'macOS'
- name: Set Linux MAKEFLAGS
run: echo "MAKEFLAGS=-j$(nproc) V=1" >> $GITHUB_ENV
shell: bash
if: runner.os == 'Linux'
- name: Setup MSBuild
uses: microsoft/setup-msbuild@v2
with:
msbuild-architecture: x64
if: runner.os == 'Windows'
zeroc-ice-3.8.1/.github/actions/setup-dotnet/ 0000775 0000000 0000000 00000000000 15165676005 0021051 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-dotnet/action.yml 0000664 0000000 0000000 00000000715 15165676005 0023054 0 ustar 00root root 0000000 0000000 name: Setup .NET
description: Installs .NET SDK versions (8.0 by default, optionally 10.0).
inputs:
include_net10:
description: "Include .NET 10"
default: "false"
runs:
using: "composite"
steps:
- name: Setup .NET 8
uses: actions/setup-dotnet@v5
with:
dotnet-version: 8.0.x
- name: Setup .NET 10
if: inputs.include_net10 == 'true'
uses: actions/setup-dotnet@v5
with:
dotnet-version: 10.0.x
zeroc-ice-3.8.1/.github/actions/setup-java/ 0000775 0000000 0000000 00000000000 15165676005 0020475 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-java/action.yml 0000664 0000000 0000000 00000000410 15165676005 0022470 0 ustar 00root root 0000000 0000000 name: Setup Java
description: Installs Oracle Java 17 using the actions/setup-java action.
runs:
using: "composite"
steps:
- name: Setup Oracle Java 17
uses: actions/setup-java@v4
with:
distribution: "oracle"
java-version: "17"
zeroc-ice-3.8.1/.github/actions/setup-matlab/ 0000775 0000000 0000000 00000000000 15165676005 0021014 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-matlab/action.yml 0000664 0000000 0000000 00000004221 15165676005 0023013 0 ustar 00root root 0000000 0000000 name: Setup MATLAB
description: Setup MATLAB for use in GitHub Actions
runs:
using: "composite"
steps:
#
# MATLAB
#
- name: Setup MATLAB
id: setup-matlab
uses: matlab-actions/setup-matlab@v2
with:
release: "R2025b"
- name: Set MATLAB_HOME and MATLAB_VERSION
run: |
echo "MATLAB_VERSION=R2025b" >> $GITHUB_ENV
echo "MATLAB_HOME=${{ steps.setup-matlab.outputs.matlabroot }}" >> $GITHUB_ENV
shell: bash
if: runner.os == 'Linux'
- name: Set MATLAB_HOME and MATLAB_VERSION
run: |
echo "MATLAB_VERSION=R2025b" >> $env:GITHUB_ENV
echo "MATLAB_HOME=${{ steps.setup-matlab.outputs.matlabroot }}" >> $env:GITHUB_ENV
shell: powershell
if: runner.os == 'Windows'
# https://github.com/matlab-actions/run-command/issues/53
- name: Get run-matlab-command
run: |
wget -O /usr/local/bin/run-matlab-command https://ssd.mathworks.com/supportfiles/ci/run-matlab-command/v2/glnxa64/run-matlab-command
chmod +x /usr/local/bin/run-matlab-command
echo "MATLAB_COMMAND=/usr/local/bin/run-matlab-command" >> $GITHUB_ENV
shell: bash
if: runner.os == 'Linux'
- name: Setup MATLAB Build Environment
if: runner.os == 'Linux'
run: |
sudo apt-get update
sudo apt-get install -y g++-11
echo "CXX=g++-11" >> $GITHUB_ENV
echo "USE_MATLAB_SSL=yes" >> $GITHUB_ENV
# g++-11 headers only support _FORTIFY_SOURCE up to 2, but Ubuntu 24.04's dpkg-buildflags sets it to 3
echo "CXXFLAGS=-D_FORTIFY_SOURCE=2" >> $GITHUB_ENV
shell: bash
# Windows is currently not working. We get an error: "'matlab' executable not found on the system path"
# However, MATLAB is installed and the path is (seemingly) set correctly
- name: Get run-matlab-command
run: |
Invoke-WebRequest https://ssd.mathworks.com/supportfiles/ci/run-matlab-command/v2/win64/run-matlab-command.exe -OutFile C:\Windows\System32\run-matlab-command.exe
echo "MATLAB_COMMAND=C:\Windows\System32\run-matlab-command.exe" >> $env:GITHUB_ENV
shell: powershell
if: runner.os == 'Windows'
zeroc-ice-3.8.1/.github/actions/setup-node/ 0000775 0000000 0000000 00000000000 15165676005 0020501 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-node/action.yml 0000664 0000000 0000000 00000000304 15165676005 0022476 0 ustar 00root root 0000000 0000000 name: Setup Node
description: Installs Node.js 22 using the actions/setup-node action.
runs:
using: "composite"
steps:
- uses: actions/setup-node@v4
with:
node-version: "22"
zeroc-ice-3.8.1/.github/actions/setup-php/ 0000775 0000000 0000000 00000000000 15165676005 0020343 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-php/action.yml 0000664 0000000 0000000 00000000615 15165676005 0022345 0 ustar 00root root 0000000 0000000 name: "Setup PHP"
description: Installs PHP CLI and development packages for macOS and Linux.
runs:
using: "composite"
steps:
- name: Install PHP on macOS
run: brew install php
shell: bash
if: runner.os == 'macOS'
- name: Install PHP on Linux
run: sudo apt-get update && sudo apt-get install -y php-cli php-dev
shell: bash
if: runner.os == 'Linux'
zeroc-ice-3.8.1/.github/actions/setup-python/ 0000775 0000000 0000000 00000000000 15165676005 0021075 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-python/action.yml 0000664 0000000 0000000 00000001021 15165676005 0023067 0 ustar 00root root 0000000 0000000 name: Setup Python
description: Installs Python and configures the environment for the current platform.
inputs:
python-version:
description: "The version of Python to set up."
default: "3.14"
runs:
using: "composite"
steps:
- uses: actions/setup-python@v5
with:
python-version: ${{ inputs.python-version }}
- name: Configure Windows Python Environment
run: |
echo "PythonHome=$env:Python_ROOT_DIR" >> $env:GITHUB_ENV
shell: powershell
if: runner.os == 'Windows'
zeroc-ice-3.8.1/.github/actions/setup-ruby/ 0000775 0000000 0000000 00000000000 15165676005 0020535 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/setup-ruby/action.yml 0000664 0000000 0000000 00000000275 15165676005 0022541 0 ustar 00root root 0000000 0000000 name: Setup Ruby
description: Installs Ruby 3.4 using the ruby/setup-ruby action.
runs:
using: "composite"
steps:
- uses: ruby/setup-ruby@v1
with:
ruby-version: "3.4"
zeroc-ice-3.8.1/.github/actions/system-info/ 0000775 0000000 0000000 00000000000 15165676005 0020673 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/system-info/action.yml 0000664 0000000 0000000 00000000761 15165676005 0022677 0 ustar 00root root 0000000 0000000 name: Print System Info
description: Prints network information for the current runner OS (Linux, macOS, or Windows).
runs:
using: "composite"
steps:
- name: Linux Network Info
if: runner.os == 'Linux'
shell: bash
run: |
ip a
- name: macOS Network Info
if: runner.os == 'macOS'
shell: bash
run: |
ifconfig
- name: Windows Network Info
if: runner.os == 'Windows'
shell: powershell
run: |
ipconfig /all
zeroc-ice-3.8.1/.github/actions/test/ 0000775 0000000 0000000 00000000000 15165676005 0017375 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/actions/test/action.yml 0000664 0000000 0000000 00000002141 15165676005 0021373 0 ustar 00root root 0000000 0000000 name: Test Ice
description: Runs the Ice test suite using allTests.py with parallel workers and XML report generation.
inputs:
working_directory:
description: "The working directory to run the tests in"
flags:
description: "Flags to pass to the test"
default: ""
runs:
using: "composite"
steps:
- name: Test
working-directory: ${{ inputs.working_directory }}
run: python3 allTests.py --debug --all --keep-logs --continue --workers=4 --export-xml=test-report.xml ${{ inputs.flags }}
shell: bash
if: runner.os == 'macOS'
- name: Test
working-directory: ${{ inputs.working_directory }}
run: |
ulimit -c unlimited
python3 allTests.py --debug --all --keep-logs --continue --workers=4 --export-xml=test-report.xml ${{ inputs.flags }}
shell: bash
if: runner.os == 'Linux'
- name: Test
working-directory: ${{ inputs.working_directory }}
run: python allTests.py --debug --all --keep-logs --continue --workers=4 --export-xml=test-report.xml ${{ inputs.flags }}
shell: powershell
if: runner.os == 'Windows'
zeroc-ice-3.8.1/.github/assets/ 0000775 0000000 0000000 00000000000 15165676005 0016260 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/assets/ice-banner.svg 0000664 0000000 0000000 00000014337 15165676005 0021014 0 ustar 00root root 0000000 0000000
zeroc-ice-3.8.1/.github/workflows/ 0000775 0000000 0000000 00000000000 15165676005 0017013 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.github/workflows/README.md 0000664 0000000 0000000 00000003256 15165676005 0020300 0 ustar 00root root 0000000 0000000 # Release Workflows
The release workflows support building and publishing Ice packages for the `3.8` and `nightly` channels.
The `3.8` channel publishes packages to the stable release repositories, while the `nightly` channel publishes to the
unstable nightly repositories.
The nightly repositories are updated daily from the `zeroc-ice/ice` `main` branch. These releases are intended for
testing the latest development and must not be used in production.
To build a stable release for `3.8`, run the `build-release` workflow and pass `3.8` as the channel.
To build a dev release for `nightly`, run the `build-release` workflow and pass `nightly` as the channel.
The `build-nightly-release` workflow schedules a daily `build-release` run for the `nightly` channel.
## Implementation Notes
Each `build-xxx-package` workflow builds the corresponding `xxx` package, and each `publish-xxx-package` workflow
publishes it.
The `build-release` workflow orchestrates the build of all packages and triggers `publish-release` after all
`build-xxx-package` workflows have completed successfully.
The `publish-release` workflow orchestrates the publishing of all packages to their respective repositories by calling
the `publish-xxx-package` workflows. You can also run it manually by providing a `run_id` and `channel`; in this case,
it will publish the artifacts from the specified run to the specified channel.
The RPM and DEB packaging workflows use Docker images from `packaging/rpm/docker` and `packaging/deb/docker`.
The release pipeline is configured to use `ghcr.io`. These images can be built using the `build-container-images`
workflow, which builds and publishes them to `ghcr.io` for internal use.
zeroc-ice-3.8.1/.github/workflows/build-brew-packages.yml 0000664 0000000 0000000 00000004166 15165676005 0023355 0 ustar 00root root 0000000 0000000 name: "Build Brew Packages"
on:
workflow_call:
inputs:
ice_version:
required: true
type: string
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version number to use"
required: true
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading the IceGrid GUI dmg artifact"
required: true
permissions:
contents: write
jobs:
build-brew-packages:
runs-on: macos-26
# Stable brew release must be build manually.
if: ${{ inputs.quality == 'nightly' }}
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Download IceGrid GUI DMG
id: icegridgui
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
set -o pipefail
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name icegridgui-macos-app --dir staging
icegridgui_dmg_sha256=$(shasum -a 256 "staging/IceGridGUI-${{ inputs.ice_version }}.dmg" | cut -d ' ' -f 1)
if [[ -z "$icegridgui_dmg_sha256" ]]; then
echo "Failed to calculate SHA256 checksum for IceGrid GUI DMG"
exit 1
fi
echo "icegridgui_dmg_sha256=$icegridgui_dmg_sha256" >> $GITHUB_OUTPUT
- name: Update Nightly Tap
run: |
./packaging/brew/update-nightly-tap.sh "${{ inputs.channel }}" "${{ inputs.quality }}" "${{ inputs.ice_version }}" "${{ steps.icegridgui.outputs.icegridgui_dmg_sha256 }}"
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: homebrew-bottle
path: |
./*.tar.gz
./*.patch
zeroc-ice-3.8.1/.github/workflows/build-container-images.yml 0000664 0000000 0000000 00000014441 15165676005 0024064 0 ustar 00root root 0000000 0000000 name: "Build Docker CI Images"
on:
workflow_dispatch
jobs:
build-images:
name: "Build ${{ matrix.image }} (${{ matrix.platform }})"
runs-on: ${{ matrix.platform == 'arm64' && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
strategy:
matrix:
include:
- platform: amd64
image: rpm-repo-builder
dockerfile: packaging/rpm/docker/rpm-repo-builder/Dockerfile
- platform: arm64
image: rpm-repo-builder
dockerfile: packaging/rpm/docker/rpm-repo-builder/Dockerfile
- platform: amd64
image: ice-rpm-builder-el9
dockerfile: packaging/rpm/docker/el9/Dockerfile
- platform: arm64
image: ice-rpm-builder-el9
dockerfile: packaging/rpm/docker/el9/Dockerfile
- platform: amd64
image: ice-rpm-builder-el10
dockerfile: packaging/rpm/docker/el10/Dockerfile
- platform: arm64
image: ice-rpm-builder-el10
dockerfile: packaging/rpm/docker/el10/Dockerfile
- platform: amd64
image: ice-rpm-builder-amzn2023
dockerfile: packaging/rpm/docker/amzn2023/Dockerfile
- platform: arm64
image: ice-rpm-builder-amzn2023
dockerfile: packaging/rpm/docker/amzn2023/Dockerfile
- platform: amd64
image: deb-repo-builder
dockerfile: packaging/deb/docker/deb-repo-builder/Dockerfile
- platform: arm64
image: deb-repo-builder
dockerfile: packaging/deb/docker/deb-repo-builder/Dockerfile
- platform: amd64
image: ice-deb-builder-debian12
dockerfile: packaging/deb/docker/Dockerfile
base_image: debian:bookworm
- platform: arm64
image: ice-deb-builder-debian12
dockerfile: packaging/deb/docker/Dockerfile
base_image: debian:bookworm
- platform: amd64
image: ice-deb-builder-debian13
dockerfile: packaging/deb/docker/Dockerfile
base_image: debian:trixie
- platform: arm64
image: ice-deb-builder-debian13
dockerfile: packaging/deb/docker/Dockerfile
base_image: debian:trixie
- platform: amd64
image: ice-deb-builder-sid
dockerfile: packaging/deb/docker/Dockerfile
base_image: debian:sid
- platform: arm64
image: ice-deb-builder-sid
dockerfile: packaging/deb/docker/Dockerfile
base_image: debian:sid
- platform: amd64
image: ice-deb-builder-ubuntu24.04
dockerfile: packaging/deb/docker/Dockerfile
base_image: ubuntu:24.04
- platform: arm64
image: ice-deb-builder-ubuntu24.04
dockerfile: packaging/deb/docker/Dockerfile
base_image: ubuntu:24.04
env:
# On Red Hat-based images, we need to provide credentials to access the Red Hat repositories.
USE_RH_CREDENTIALS: ${{ startsWith(matrix.image, 'ice-rpm-builder-el') && 'true' || 'false' }}
# Disable attestations for compatibility with ghcr.io registry.
# See: https://github.com/orgs/community/discussions/45969
BUILDX_NO_DEFAULT_ATTESTATIONS: 1
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Load version info
run: |
source ice/config/version.env
echo "CHANNEL=$CHANNEL" >> $GITHUB_ENV
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: zeroc-ice
password: ${{ secrets.GITHUB_TOKEN }}
- name: Add RH credentials
if: env.USE_RH_CREDENTIALS == 'true'
run: |
umask 077
echo "RH_USERNAME=\"${{ secrets.RH_USERNAME }}\"" >> rh_credentials
echo "RH_PASSWORD=\"${{ secrets.RH_PASSWORD }}\"" >> rh_credentials
- name: Build and push image
run: |
args=(
--platform "linux/${{ matrix.platform }}"
# Use CHANNEL as the tag; keep arch as a suffix tag for manifest assembly.
--tag "ghcr.io/zeroc-ice/${{ matrix.image }}:${CHANNEL}-${{ matrix.platform }}"
--push
-f ${{ matrix.dockerfile }}
)
# Add BASE_IMAGE build arg if specified
if [[ -n "${{ matrix.base_image }}" ]]; then
args+=( --build-arg "BASE_IMAGE=${{ matrix.base_image }}" )
fi
# Add secret with Red Hat credentials if needed
if [[ "$USE_RH_CREDENTIALS" == "true" ]]; then
args+=( --secret id=rh_credentials,src=../rh_credentials )
fi
docker buildx build "${args[@]}" .
working-directory: ice
- name: Clean up RH credentials
if: always() && env.USE_RH_CREDENTIALS == 'true'
run: rm -f rh_credentials
create-manifests:
name: "Create and Push Multi-Arch Manifests"
runs-on: ubuntu-24.04
needs: build-images
strategy:
matrix:
image:
- deb-repo-builder
- ice-deb-builder-debian12
- ice-deb-builder-debian13
- ice-deb-builder-sid
- ice-deb-builder-ubuntu24.04
- ice-rpm-builder-amzn2023
- ice-rpm-builder-el10
- ice-rpm-builder-el9
- rpm-repo-builder
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: zeroc-ice
password: ${{ secrets.GITHUB_TOKEN }}
- name: Load version info
run: |
source ice/config/version.env
echo "CHANNEL=$CHANNEL" >> $GITHUB_ENV
- name: Create and push manifest
run: |
docker manifest create ghcr.io/zeroc-ice/${{ matrix.image }}:${CHANNEL} \
--amend ghcr.io/zeroc-ice/${{ matrix.image }}:${CHANNEL}-amd64 \
--amend ghcr.io/zeroc-ice/${{ matrix.image }}:${CHANNEL}-arm64
docker manifest push ghcr.io/zeroc-ice/${{ matrix.image }}:${CHANNEL}
zeroc-ice-3.8.1/.github/workflows/build-cpp-nuget-packages.yml 0000664 0000000 0000000 00000004131 15165676005 0024310 0 ustar 00root root 0000000 0000000 name: "Build C++ NuGet Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
run_id:
description: "The run ID to use for downloading artifacts"
required: true
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
run_id:
description: "The run ID to use for downloading artifacts"
required: true
jobs:
build-cpp-nuget-packages:
runs-on: windows-2022
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Download C++ Binaries
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-x64-Release-build --dir cpp
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-x64-Debug-build --dir cpp
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-Win32-Release-build --dir cpp
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-Win32-Debug-build --dir cpp
# Download Slice Tools (We only need the Release x64 build)
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-slice-tools `
--dir cpp/tools/ZeroC.Ice.Slice.Tools.Cpp/bin
- name: Ice Package Version
if: ${{ inputs.ice_version != '' }}
run: |
"IcePackageVersion=${{ inputs.ice_version }}" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
shell: pwsh
- name: Build C++ NuGet Packages
run: msbuild /m ice.proj /t:Pack /p:BuildAllConfigurations=yes
working-directory: cpp/msbuild
- name: Upload NuGet Packages
uses: actions/upload-artifact@v4
with:
name: windows-cpp-nuget-packages
path: |
cpp/msbuild/ZeroC.Ice.Cpp/*.nupkg
zeroc-ice-3.8.1/.github/workflows/build-cpp-swift-deps.yml 0000664 0000000 0000000 00000004025 15165676005 0023501 0 ustar 00root root 0000000 0000000 name: "Build C++ Dependencies for Swift"
on:
workflow_call:
inputs:
ice_version:
required: true
type: string
channel:
required: true
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version number to use"
required: true
channel:
description: "The channel to publish to (e.g., 3.8, nightly)"
required: true
permissions:
contents: write
jobs:
build-cpp-swift-deps:
runs-on: macos-26
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Set Version (For Nightly Builds)
run: |
echo "ICE_VERSION=${{inputs.ice_version}}" >> $GITHUB_ENV
if: ${{ inputs.ice_version != '' }}
- name: Set Version (For Release Builds)
run: |
source config/version.env
echo "ICE_VERSION=${VERSION}" >> $GITHUB_ENV
if: ${{ inputs.ice_version == '' }}
- name: Build XCFramework Packages
run: make OPTIMIZE=yes PLATFORMS="all" CONFIGS="static" srcs
working-directory: cpp
- name: Create XCFrameworks Zip archives
run: |
for dir in *.xcframework; do
framework_name=$(basename $dir)
framework_zip=${framework_name/.xcframework/-${ICE_VERSION}.xcframework.zip}
zip -r $framework_zip $dir
done
working-directory: cpp/lib/XCFrameworks
- name: Create slice2swift Artifact Bundle Zip archive
run: mv slice2swift.artifactbundle.zip slice2swift-${ICE_VERSION}.artifactbundle.zip
working-directory: cpp/bin
- name: Stage C++ Dependencies for Swift
run: |
mkdir -p staging
cp cpp/lib/XCFrameworks/*.zip staging/
cp cpp/bin/slice2swift-*.artifactbundle.zip staging/
- name: Upload C++ Dependencies for Swift
uses: actions/upload-artifact@v4
with:
name: cpp-swift-deps
path: staging/
zeroc-ice-3.8.1/.github/workflows/build-cpp-windows-binaries.yml 0000664 0000000 0000000 00000005431 15165676005 0024702 0 ustar 00root root 0000000 0000000 name: "Build C++ Windows Binaries"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
jobs:
build-cpp-windows-binaries:
runs-on: windows-2022
strategy:
matrix:
platform: [x64, Win32]
configuration: [Release, Debug]
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Build C++ Binaries
run: |
msbuild /m ice.proj /t:BuildDist /p:Configuration=${{ matrix.configuration }} /p:Platform=${{ matrix.platform }}
working-directory: cpp/msbuild
- name: Sign C++ Binaries with Trusted Signing
if: ${{ inputs.authenticode_sign }}
uses: azure/trusted-signing-action@v0
with:
azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
azure-client-secret: ${{ secrets.AZURE_CLIENT_SECRET }}
endpoint: https://eus.codesigning.azure.net/
trusted-signing-account-name: zeroc
certificate-profile-name: zeroc-ice
files-folder: ./cpp/bin/${{ matrix.platform }}/${{ matrix.configuration }}
files-folder-filter: exe,dll
file-digest: SHA256
timestamp-rfc3161: http://timestamp.acs.microsoft.com
timestamp-digest: SHA256
- name: Upload C++ Build
uses: actions/upload-artifact@v4
with:
name: windows-cpp-${{ matrix.platform }}-${{ matrix.configuration }}-build
path: |
cpp/bin/${{ matrix.platform }}/${{ matrix.configuration }}/
cpp/lib/${{ matrix.platform }}/${{ matrix.configuration }}/
cpp/include/generated/${{ matrix.platform }}/${{ matrix.configuration }}/
cpp/src/**/msbuild/**/${{ matrix.platform }}/${{ matrix.configuration }}/*.cpp
cpp/src/**/msbuild/**/${{ matrix.platform }}/${{ matrix.configuration }}/*.h
- name: Upload C++ Slice Tools
uses: actions/upload-artifact@v4
# We only need to upload the Slice Tools once (Release x64 build) which are included in the Nuget packages
if: ${{ matrix.configuration == 'Release' && matrix.platform == 'x64' }}
with:
name: windows-cpp-slice-tools
path: |
cpp/tools/ZeroC.Ice.Slice.Tools.Cpp/bin
zeroc-ice-3.8.1/.github/workflows/build-deb-ice-repo-packages.yml 0000664 0000000 0000000 00000004256 15165676005 0024651 0 ustar 00root root 0000000 0000000 name: "Build Ice Repo DEB Packages"
on:
workflow_dispatch:
inputs:
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: false
default: "nightly"
jobs:
build:
name: "Build Ice Repo DEB packages for ${{ matrix.distribution }}"
runs-on: ubuntu-24.04
strategy:
matrix:
distribution: [debian12, debian13, ubuntu24.04]
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Load version info
run: |
source ice/config/version.env
echo "CHANNEL=$CHANNEL" >> $GITHUB_ENV
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: zeroc-ice
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build DEB packages
run: |
docker run --rm \
-v "$GITHUB_WORKSPACE:/workspace" \
-e GPG_KEY="${{ secrets.ICE_3_8_CI_SIGNER_KEY }}" \
-e GPG_KEY_ID="${{ secrets.ICE_3_8_CI_SIGNER_KEY_ID }}" \
ghcr.io/zeroc-ice/ice-deb-builder-${{ matrix.distribution }}:${CHANNEL} \
/workspace/ice/packaging/deb/build-repo-package.sh \
--distribution "${{ matrix.distribution }}" \
--channel "${CHANNEL}" \
--quality "${{ inputs.quality }}"
- name: Sync DEB packages to S3
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}/${DISTRIBUTION}"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}/${DISTRIBUTION}"
fi
aws s3 cp build/*.deb "s3://zeroc-downloads/${UPLOAD_PATH}/"
env:
QUALITY: ${{ inputs.quality }}
DISTRIBUTION: ${{ matrix.distribution }}
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: deb-packages-${{ matrix.distribution }}
path: |
build/*.deb
zeroc-ice-3.8.1/.github/workflows/build-deb-packages.yml 0000664 0000000 0000000 00000005413 15165676005 0023144 0 ustar 00root root 0000000 0000000 name: "Build DEB Packages"
on:
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
deb_build_options:
description: "DEB_BUILD_OPTIONS for the build"
required: false
default: "nocheck parallel=4"
workflow_call:
inputs:
ice_version:
required: false
type: string
deb_build_options:
type: string
required: false
jobs:
build:
name: "Build for ${{ matrix.distribution }}-${{ matrix.arch }}"
runs-on: ${{ matrix.arch == 'arm64' && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
strategy:
matrix:
include:
- distribution: ubuntu24.04
arch: amd64
- distribution: ubuntu24.04
arch: arm64
- distribution: debian12
arch: amd64
deb_build_profiles: "nopython"
- distribution: debian12
arch: arm64
deb_build_profiles: "nopython"
- distribution: debian13
arch: amd64
- distribution: debian13
arch: arm64
- distribution: sid
arch: amd64
- distribution: sid
arch: arm64
env:
DEB_BUILD_OPTIONS: "nocheck parallel=4"
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Load version info
run: |
source ice/config/version.env
echo "CHANNEL=$CHANNEL" >> $GITHUB_ENV
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: zeroc-ice
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build DEB Packages
run: |
set -euo pipefail
# Enable ddeb generation
export DH_BUILD_DDEBS=1
docker run --rm \
-v "$GITHUB_WORKSPACE:/workspace" \
-e DEBEMAIL="ci@zeroc.com" \
-e DEBFULLNAME="CI" \
-e ICE_VERSION=${{ inputs.ice_version }} \
-e DH_BUILD_DDEBS="${DH_BUILD_DDEBS}" \
-e DEB_BUILD_OPTIONS="$DEB_BUILD_OPTIONS" \
-e DEB_BUILD_PROFILES="${{ matrix.deb_build_profiles }}" \
ghcr.io/zeroc-ice/ice-deb-builder-${{ matrix.distribution }}:${CHANNEL} \
/workspace/ice/packaging/deb/build-package.sh
shell: bash
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: deb-packages-${{ matrix.distribution }}-${{ matrix.arch }}
path: |
*.deb
*.ddeb
*.dsc
*.tar.xz
*.tar.gz
*.changes
*.buildinfo
zeroc-ice-3.8.1/.github/workflows/build-dotnet-packages.yml 0000664 0000000 0000000 00000012370 15165676005 0023707 0 ustar 00root root 0000000 0000000 name: "Build .NET Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
jobs:
build-slice-compilers:
strategy:
matrix:
include:
- os: macos-26
target: macos-arm64
artifact-path: cpp/bin/slice2cs
- os: windows-2022
target: windows-x64
artifact-path: cpp/bin/x64/Release/slice2cs.*
- os: ubuntu-24.04
target: linux-x64
artifact-path: cpp/bin/slice2cs
- os: ubuntu-24.04-arm
target: linux-arm64
artifact-path: cpp/bin/slice2cs
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Build Compiler
uses: ./.github/actions/build-slice-compiler
with:
compiler_name: slice2cs
authenticode_sign: ${{ inputs.authenticode_sign }}
env:
AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
- name: Upload Compiler Artifact
uses: actions/upload-artifact@v4
with:
name: slice2cs-${{ matrix.target }}
path: ${{ matrix.artifact-path }}
pack-dotnet:
runs-on: windows-2022
needs: build-slice-compilers
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup .NET
uses: ./.github/actions/setup-dotnet
- name: Download All slice2cs Artifacts
uses: actions/download-artifact@v4
with:
pattern: slice2cs-*
- name: Copy slice2cs binaries to staging path
run: |
@("macos-arm64", "linux-x64", "linux-arm64", "windows-x64") | ForEach-Object { New-Item -ItemType Directory -Path $env:GITHUB_WORKSPACE\tools -Name $_ }
Copy-Item "slice2cs-macos-arm64\slice2cs" -Destination "$env:GITHUB_WORKSPACE\tools\macos-arm64"
Copy-Item "slice2cs-linux-x64\slice2cs" -Destination "$env:GITHUB_WORKSPACE\tools\linux-x64"
Copy-Item "slice2cs-linux-arm64\slice2cs" -Destination "$env:GITHUB_WORKSPACE\tools\linux-arm64"
Copy-Item "slice2cs-windows-x64\slice2cs.exe" -Destination "$env:GITHUB_WORKSPACE\tools\windows-x64"
# Copy the compiler to the expected location to avoid rebuilding it when creating the NuGet packages
New-Item -ItemType Directory -Path "$env:GITHUB_WORKSPACE\cpp\bin\x64\Release"
Copy-Item "slice2cs-windows-x64\slice2cs.exe" -Destination "$env:GITHUB_WORKSPACE\cpp\bin\x64\Release"
# The .NET NuGet package includes bzip2 DLLs from the C++ Windows distribution for protocol compression
- name: Restore C++ dependencies
run: nuget restore cpp/msbuild/ice.slnx
- name: Ice Package Version
if: ${{ inputs.ice_version != '' }}
run: |
"IcePackageVersion=${{ inputs.ice_version }}" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
shell: pwsh
# Build .NET assemblies.
- name: Pack .NET Packages
run: |
dotnet msbuild csharp\msbuild\ice.proj /t:BuildDist /p:Configuration=Release
- name: Collect Files to Sign
if: ${{ inputs.authenticode_sign }}
run: |
Get-ChildItem -Path csharp\src -Directory | ForEach-Object {
$name = $_.Name
$csproj = "csharp\src\$name\$name.csproj"
$tfm = (Select-Xml -Path $csproj -XPath "//TargetFramework").Node.InnerText
"csharp\src\$name\bin\Release\$tfm\$name.dll"
} | Set-Content -Path ${{ github.workspace }}\catalog.txt -Encoding UTF8
- name: Sign .NET Assemblies with Trusted Signing
if: ${{ inputs.authenticode_sign }}
uses: azure/trusted-signing-action@v0
with:
azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
azure-client-secret: ${{ secrets.AZURE_CLIENT_SECRET }}
endpoint: https://eus.codesigning.azure.net/
trusted-signing-account-name: zeroc
certificate-profile-name: zeroc-ice
files-catalog: ${{ github.workspace }}\catalog.txt
file-digest: SHA256
timestamp-rfc3161: http://timestamp.acs.microsoft.com
timestamp-digest: SHA256
- name: Pack .NET Packages
run: dotnet msbuild csharp\msbuild\ice.proj /t:Pack /p:Configuration=Release
env:
SLICE2CS_STAGING_PATH: "${{ github.workspace }}\\tools"
- name: Upload NuGet Packages
uses: actions/upload-artifact@v4
with:
name: dotnet-nuget-packages
path: |
csharp/src/**/bin/Release/*.nupkg
csharp/src/**/bin/Release/*.snupkg
zeroc-ice-3.8.1/.github/workflows/build-gem-packages.yml 0000664 0000000 0000000 00000002014 15165676005 0023154 0 ustar 00root root 0000000 0000000 name: "Build GEM Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
jobs:
build-gem-packages:
runs-on: ubuntu-24.04
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Ruby
uses: ./.github/actions/setup-ruby
- name: Install Build Dependencies
run: gem install rake
- name: Update GEM Version
working-directory: ruby
run: sed -i "s/spec.version.*/spec.version = '${{ inputs.ice_version }}'/" ice.gemspec
if: ${{ inputs.ice_version != '' }}
- name: Build GEM Package
working-directory: ruby
run: rake
- name: Upload Gem Packages
uses: actions/upload-artifact@v4
with:
name: gem-packages
path: ruby/zeroc-ice-*.gem
zeroc-ice-3.8.1/.github/workflows/build-icegridgui-jar.yml 0000664 0000000 0000000 00000002422 15165676005 0023520 0 ustar 00root root 0000000 0000000 name: "Build IceGrid GUI JAR"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
jobs:
build-icegridgui-jar:
strategy:
matrix:
os: [windows-2022, macos-26]
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Build IceGrid GUI
if: runner.os == 'Windows'
run: |
nuget restore ..\cpp\msbuild\ice.slnx
MSBuild ..\cpp\msbuild\ice.slnx /t:"slice2java" /p:Configuration=Release /p:Platform=x64
./gradlew.bat dist -PcppPlatform=x64 -PcppConfiguration=Release
working-directory: java
- name: Build IceGrid GUI
if: runner.os == 'macOS'
run: |
make -C ../cpp slice2java
./gradlew dist
working-directory: java
- name: Upload IceGrid GUI JAR
uses: actions/upload-artifact@v4
with:
name: icegridgui-jar-${{ runner.os }}
path: |
java/lib/icegridgui.jar
zeroc-ice-3.8.1/.github/workflows/build-icegridgui-macos-app.yml 0000664 0000000 0000000 00000007333 15165676005 0024632 0 ustar 00root root 0000000 0000000 name: "Build IceGrid GUI macOS App"
on:
workflow_call:
inputs:
run_id:
description: "The run ID to use for downloading the IceGrid GUI JAR artifact"
required: true
type: string
dmg_version:
description: "The version number to use in the DMG filename (defaults to BASE_VERSION from version.env)"
required: false
type: string
workflow_dispatch:
inputs:
run_id:
description: "The run ID to use for downloading the IceGrid GUI JAR artifact"
required: true
dmg_version:
description: "The version number to use in the DMG filename (defaults to BASE_VERSION from version.env)"
required: false
jobs:
build-icegridgui-macos-app:
runs-on: macos-26
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Download IceGrid GUI JAR
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name icegridgui-jar-macOS --dir staging
- name: Build macOS App
run: ./packaging/macos/build-icegridgui-macos-app.sh staging/icegridgui.jar output
# Import the Apple "Developer ID Application" signing certificate into a temporary keychain
# on the runner. The certificate and private key are stored as a base64-encoded P12 file in
# the APPLE_CERTIFICATE_P12 repository secret (exported from Keychain Access with an empty
# password, then encoded with: base64 -i certificate.p12).
- name: Import signing certificate
env:
APPLE_CERTIFICATE_P12: ${{ secrets.APPLE_CERTIFICATE_P12 }}
run: |
KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
KEYCHAIN_PASSWORD=$(openssl rand -base64 32)
# Decode the certificate
echo "$APPLE_CERTIFICATE_P12" | base64 --decode > $RUNNER_TEMP/certificate.p12
# Create and configure a temporary keychain
security create-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
security set-keychain-settings -lut 21600 "$KEYCHAIN_PATH"
security unlock-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
# Import the certificate
security import $RUNNER_TEMP/certificate.p12 -P "" \
-A -t cert -f pkcs12 -k "$KEYCHAIN_PATH"
# Allow codesign to access the keychain without prompting
security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
# Add temporary keychain to the search list
security list-keychains -d user -s "$KEYCHAIN_PATH" $(security list-keychains -d user | tr -d '"')
- name: Sign macOS App
run: ./packaging/macos/sign-icegridgui-macos-app.sh "output/IceGrid GUI.app" --notarize
env:
APPLE_ID: ${{ secrets.APPLE_ID }}
APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
- name: Create DMG
run: |
dmg_args=("output/IceGrid GUI.app" output --sign --notarize)
if [ -n "${{ inputs.dmg_version }}" ]; then
dmg_args+=(--version "${{ inputs.dmg_version }}")
fi
./packaging/macos/create-icegridgui-dmg.sh "${dmg_args[@]}"
env:
APPLE_ID: ${{ secrets.APPLE_ID }}
APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
- name: Upload IceGrid GUI macOS App
uses: actions/upload-artifact@v4
with:
name: icegridgui-macos-app
path: |
output/IceGridGUI-*.dmg
zeroc-ice-3.8.1/.github/workflows/build-java-packages.yml 0000664 0000000 0000000 00000002116 15165676005 0023330 0 ustar 00root root 0000000 0000000 name: "Build Java Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
jobs:
build-java-packages:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Build slice2java
run: make -C cpp slice2java
- name: Update Ice Version
run: |
sed -i "s/^iceVersion = .*/iceVersion = ${{ inputs.ice_version }}/" gradle.properties
working-directory: java
if: ${{ inputs.ice_version != '' }}
- name: Build Ice for Java Packages
run: ./gradlew dist
working-directory: java
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: java-packages
path: |
java/lib/*.jar
java/lib/*.pom
zeroc-ice-3.8.1/.github/workflows/build-matlab-packages.yml 0000664 0000000 0000000 00000006273 15165676005 0023657 0 ustar 00root root 0000000 0000000 name: "Build MATLAB Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
jobs:
build-matlab-packages:
strategy:
matrix:
include:
- os: ubuntu-24.04
- os: windows-2022
runs-on: ${{ matrix.os }}
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup MATLAB
uses: ./.github/actions/setup-matlab
- name: Ice Package Version
if: ${{ inputs.ice_version != '' }}
run: |
"IceToolboxVersion=${{ inputs.ice_version }}" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
"ICE_TOOLBOX_VERSION=${{ inputs.ice_version }}" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
shell: pwsh
- name: Build Linux MATLAB ToolBox
run: |
make -C cpp slice2matlab Ice IceDiscovery IceLocatorDiscovery OPTIMIZE=yes
make -C matlab toolbox OPTIMIZE=yes
if: runner.os == 'Linux'
- name: Build Windows MATLAB ToolBox
run: MSBuild /p:Configuration=Release /p:Platform=x64 /t:BuildDist matlab\msbuild\ice.proj
if: runner.os == 'Windows'
- name: Collect Files To Sign
if: runner.os == 'Windows' && inputs.authenticode_sign
run: |
Resolve-Path -Path ".\matlab\lib\x64\Release\*.dll" -Relative | Set-Content -Path "${{ github.workspace }}\catalog.txt" -Encoding UTF8
Resolve-Path -Path ".\matlab\lib\x64\Release\*.mexw64" -Relative | Add-Content -Path "${{ github.workspace }}\catalog.txt" -Encoding UTF8
Add-Content -Path "${{ github.workspace }}\catalog.txt" -Value "cpp\bin\x64\Release\slice2matlab.exe"
- name: Sign C++ Binaries
uses: azure/trusted-signing-action@v0
if: runner.os == 'Windows' && inputs.authenticode_sign
with:
azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
azure-client-secret: ${{ secrets.AZURE_CLIENT_SECRET }}
endpoint: https://eus.codesigning.azure.net/
trusted-signing-account-name: zeroc
certificate-profile-name: zeroc-ice
files-catalog: ${{ github.workspace }}\catalog.txt
file-digest: SHA256
timestamp-rfc3161: http://timestamp.acs.microsoft.com
timestamp-digest: SHA256
- name: Package Windows MATLAB ToolBox
run: MSBuild /p:Configuration=Release /p:Platform=x64 /t:Package matlab\msbuild\ice.proj
if: runner.os == 'Windows'
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: matlab-packages-${{ matrix.os }}
path: matlab/toolbox/*.mltbx
zeroc-ice-3.8.1/.github/workflows/build-npm-packages.yml 0000664 0000000 0000000 00000010664 15165676005 0023210 0 ustar 00root root 0000000 0000000 name: "Build NPM Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
jobs:
build-slice-compilers:
strategy:
matrix:
include:
- os: macos-26
target: macos-arm64
artifact-path: cpp/bin/slice2js
- os: windows-2022
target: windows-x64
artifact-path: cpp/bin/x64/Release/slice2js.*
- os: ubuntu-24.04
target: linux-x64
artifact-path: cpp/bin/slice2js
- os: ubuntu-24.04-arm
target: linux-arm64
artifact-path: cpp/bin/slice2js
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Node
uses: ./.github/actions/setup-node
- name: Build Compiler
uses: ./.github/actions/build-slice-compiler
with:
compiler_name: slice2js
authenticode_sign: ${{ inputs.authenticode_sign }}
env:
AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
- name: Upload Compiler Artifact
uses: actions/upload-artifact@v4
with:
name: slice2js-${{ matrix.target }}
path: ${{ matrix.artifact-path }}
pack-npm:
runs-on: ubuntu-24.04
needs: build-slice-compilers
env:
SLICE2JS_STAGING_PATH: ${{ github.workspace }}/staging
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
path: ice
- name: Setup Node
uses: ./ice/.github/actions/setup-node
- name: Download All slice2js Compiler Artifacts
uses: actions/download-artifact@v4
with:
path: artifacts
pattern: slice2js-*
- name: Copy slice2js binaries to staging path
run: |
# Create the staging path.
mkdir -p "$SLICE2JS_STAGING_PATH/macos-arm64" \
"$SLICE2JS_STAGING_PATH/linux-x64" \
"$SLICE2JS_STAGING_PATH/linux-arm64" \
"$SLICE2JS_STAGING_PATH/windows-x64"
# Copy the slice2js binaries to the staging path.
cp -v artifacts/slice2js-macos-arm64/slice2js "$SLICE2JS_STAGING_PATH/macos-arm64/"
chmod +x $SLICE2JS_STAGING_PATH/macos-arm64/slice2js
cp -v artifacts/slice2js-linux-x64/slice2js "$SLICE2JS_STAGING_PATH/linux-x64/"
chmod +x $SLICE2JS_STAGING_PATH/linux-x64/slice2js
cp -v artifacts/slice2js-linux-arm64/slice2js "$SLICE2JS_STAGING_PATH/linux-arm64/"
chmod +x $SLICE2JS_STAGING_PATH/linux-arm64/slice2js
cp -v artifacts/slice2js-windows-x64/slice2js.exe "$SLICE2JS_STAGING_PATH/windows-x64/"
# Copy the slice2js binary to the cpp/bin directory to avoid rebuilding it.
mkdir -p ice/cpp/bin
cp -v artifacts/slice2js-linux-x64/slice2js $GITHUB_WORKSPACE/ice/cpp/bin/slice2js
chmod +x $GITHUB_WORKSPACE/ice/cpp/bin/slice2js
- name: Build JS
run: make srcs
working-directory: ice/js
- name: Update Version - @zeroc/ice
working-directory: ice/js/packages/ice
run: npm version ${{ inputs.ice_version }}
if: ${{ inputs.ice_version != '' }}
- name: Update Version - @zeroc/slice2js
working-directory: ice/js/packages/slice2js
run: npm version ${{ inputs.ice_version }}
if: ${{ inputs.ice_version != '' }}
- name: Pack npm - @zeroc/ice
run: npm pack
working-directory: ice/js/packages/ice
- name: Pack npm - @zeroc/slice2js
run: npm pack
working-directory: ice/js/packages/slice2js
- name: Upload NPM Packages
uses: actions/upload-artifact@v4
with:
name: js-npm-packages
path: |
ice/js/packages/ice/*.tgz
ice/js/packages/slice2js/*.tgz
zeroc-ice-3.8.1/.github/workflows/build-pip-packages.yml 0000664 0000000 0000000 00000005261 15165676005 0023203 0 ustar 00root root 0000000 0000000 name: "Build PIP Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
jobs:
build-sdist:
runs-on: ubuntu-24.04
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install Build Dependencies
run: |
python3 -m pip install --upgrade pip
python3 -m pip install build
python3 -m pip install toml
- name: Update PYPI Version
run: python3 packaging/pypi/update_version.py ${{ inputs.ice_version }} python/pyproject.toml
if: inputs.ice_version != ''
- name: Build Source Distribution
working-directory: python
run: python3 -m build --sdist
- name: Upload sdist
uses: actions/upload-artifact@v4
with:
name: pip-sdist
path: python/dist/zeroc_ice-*.tar.gz
build-bdist:
needs: build-sdist
strategy:
matrix:
include:
- os: macos-26
python-version: "3.12"
- os: macos-26
python-version: "3.13"
- os: macos-26
python-version: "3.14"
- os: windows-2022
python-version: "3.12"
- os: windows-2022
python-version: "3.13"
- os: windows-2022
python-version: "3.14"
runs-on: ${{ matrix.os }}
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
with:
profile: pip-bdist
- name: Setup Python
uses: ./.github/actions/setup-python
with:
python-version: ${{ matrix.python-version }}
- name: Download sdist
uses: actions/download-artifact@v4
with:
name: pip-sdist
path: sdist
- name: Build Wheel from sdist (Unix)
if: runner.os != 'Windows'
run: |
python -m pip install --upgrade pip
pip wheel sdist/*.tar.gz --no-deps -w dist/
- name: Build Wheel from sdist (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: |
python -m pip install --upgrade pip
pip wheel (Get-ChildItem sdist\*.tar.gz).FullName --no-deps -w dist/
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: pip-packages-${{ matrix.os }}-${{ matrix.python-version }}
path: dist/zeroc_ice-*.whl
zeroc-ice-3.8.1/.github/workflows/build-release.yml 0000664 0000000 0000000 00000024311 15165676005 0022254 0 ustar 00root root 0000000 0000000 name: Build Release
on:
workflow_call:
inputs:
build_number:
required: false
default: "1"
type: string
quality:
required: true
type: string
publish:
required: false
type: boolean
default: false
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries (always true for stable quality)"
required: false
type: boolean
default: false
workflow_dispatch:
inputs:
build_number:
description: "Build number for nightly releases"
required: false
default: "1"
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
publish:
description: "Whether to publish the packages"
required: false
default: false
type: boolean
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries (always true for stable quality)"
required: false
default: false
type: boolean
jobs:
configure:
runs-on: ubuntu-24.04
outputs:
semver_version: ${{ steps.configure.outputs.semver_version }}
deb_version: ${{ steps.configure.outputs.deb_version }}
gem_version: ${{ steps.configure.outputs.gem_version }}
maven_version: ${{ steps.configure.outputs.maven_version }}
pypi_version: ${{ steps.configure.outputs.pypi_version }}
rpm_version: ${{ steps.configure.outputs.rpm_version }}
matlab_version: ${{ steps.configure.outputs.matlab_version }}
channel: ${{ steps.configure.outputs.channel }}
authenticode_sign: ${{ steps.configure.outputs.authenticode_sign }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Configure build
id: configure
run: |
# Load version information
source ./config/version.env
# The channel for the branch from version.env
echo "channel=${CHANNEL}" >> $GITHUB_OUTPUT
# Authenticode sign is always true for stable quality, otherwise use the input value
if [[ "${{ inputs.quality }}" == "stable" ]] || [[ "${{ inputs.authenticode_sign }}" == "true" ]]; then
echo "authenticode_sign=true" >> $GITHUB_OUTPUT
else
echo "authenticode_sign=false" >> $GITHUB_OUTPUT
fi
if [[ "${{ inputs.quality }}" == "nightly" ]]; then
DATE=$(date +%Y%m%d)
BUILD=${{ inputs.build_number }}
# Set version variables for nightly packages according to platform conventions:
# e.g. 3.8.1-nightly.20250625.1
echo "semver_version=${NIGHTLY_BASE_VERSION}-nightly.${DATE}.${BUILD}" >> $GITHUB_OUTPUT
# e.g. 3.8.1~0.nightly20250625.1-1
echo "deb_version=${NIGHTLY_BASE_VERSION}~0.nightly${DATE}.${BUILD}-1" >> $GITHUB_OUTPUT
# e.g. 3.8.1.pre.20250625.1
echo "gem_version=${NIGHTLY_BASE_VERSION}.pre.${DATE}.${BUILD}" >> $GITHUB_OUTPUT
# e.g. 3.8.1-nightly-20250625.1-SNAPSHOT
echo "maven_version=${NIGHTLY_BASE_VERSION}-nightly-${DATE}.${BUILD}-SNAPSHOT" >> $GITHUB_OUTPUT
# e.g. 3.8.1.dev202506251
echo "pypi_version=${NIGHTLY_BASE_VERSION}.dev${DATE}${BUILD}" >> $GITHUB_OUTPUT
# e.g. 3.8.1~0.nightly20250625.1
echo "rpm_version=${NIGHTLY_BASE_VERSION}~0.nightly${DATE}.${BUILD}" >> $GITHUB_OUTPUT
# e.g. 3.8.1.202506251
echo "matlab_version=${NIGHTLY_BASE_VERSION}.${DATE}${BUILD}" >> $GITHUB_OUTPUT
else
# Define version variables as empty for stable channels to use the version from the repository
echo "semver_version=" >> $GITHUB_OUTPUT
echo "deb_version=" >> $GITHUB_OUTPUT
echo "gem_version=" >> $GITHUB_OUTPUT
echo "maven_version=" >> $GITHUB_OUTPUT
echo "pypi_version=" >> $GITHUB_OUTPUT
echo "rpm_version=" >> $GITHUB_OUTPUT
echo "matlab_version=" >> $GITHUB_OUTPUT
fi
build-brew-packages:
name: Build Brew Packages
uses: ./.github/workflows/build-brew-packages.yml
needs:
- configure
- build-icegridgui-macos-app
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
channel: ${{ needs.configure.outputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ github.run_id }}
secrets: inherit
build-deb-packages:
name: Build DEB Packages
uses: ./.github/workflows/build-deb-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.deb_version }}
secrets: inherit
build-dotnet-packages:
name: Build .NET Packages
uses: ./.github/workflows/build-dotnet-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
authenticode_sign: ${{ needs.configure.outputs.authenticode_sign == 'true' }}
secrets: inherit
build-gem-packages:
name: Build GEM Packages
uses: ./.github/workflows/build-gem-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.gem_version }}
build-matlab-packages:
name: Build MATLAB Packages
uses: ./.github/workflows/build-matlab-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.matlab_version }}
authenticode_sign: ${{ needs.configure.outputs.authenticode_sign == 'true' }}
secrets: inherit
build-java-packages:
name: Build Java Packages
uses: ./.github/workflows/build-java-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.maven_version }}
secrets: inherit
build-slice-tools-packages:
name: Build Slice Tools Packages
uses: ./.github/workflows/build-slice-tools-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.maven_version }}
authenticode_sign: ${{ needs.configure.outputs.authenticode_sign == 'true' }}
secrets: inherit
build-npm-packages:
name: Build NPM Packages
uses: ./.github/workflows/build-npm-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
authenticode_sign: ${{ needs.configure.outputs.authenticode_sign == 'true' }}
secrets: inherit
build-pip-packages:
name: Build PIP Packages
uses: ./.github/workflows/build-pip-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.pypi_version }}
secrets: inherit
build-rpm-packages:
name: Build RPM Packages
uses: ./.github/workflows/build-rpm-packages.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.rpm_version }}
secrets: inherit
build-cpp-windows-binaries:
name: Build C++ Windows Binaries
uses: ./.github/workflows/build-cpp-windows-binaries.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
authenticode_sign: ${{ needs.configure.outputs.authenticode_sign == 'true' }}
secrets: inherit
build-symbols-sources-store:
name: Build Symbols and Sources Store
uses: ./.github/workflows/build-symbols-sources-store.yml
needs:
- configure
- build-cpp-windows-binaries
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
channel: ${{ needs.configure.outputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ github.run_id }}
secrets: inherit
build-cpp-nuget-packages:
name: Build C++ NuGet Packages
uses: ./.github/workflows/build-cpp-nuget-packages.yml
needs:
- configure
- build-cpp-windows-binaries
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
run_id: ${{ github.run_id }}
secrets: inherit
build-icegridgui-jar:
name: Build IceGrid GUI JAR
uses: ./.github/workflows/build-icegridgui-jar.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
secrets: inherit
build-windows-installer:
name: Build Windows Installer
uses: ./.github/workflows/build-windows-installer.yml
needs:
- configure
- build-cpp-windows-binaries
- build-icegridgui-jar
with:
run_id: ${{ github.run_id }}
authenticode_sign: ${{ needs.configure.outputs.authenticode_sign == 'true' }}
secrets: inherit
build-icegridgui-macos-app:
name: Build IceGrid GUI macOS App
uses: ./.github/workflows/build-icegridgui-macos-app.yml
needs:
- configure
- build-icegridgui-jar
with:
run_id: ${{ github.run_id }}
dmg_version: ${{ needs.configure.outputs.semver_version }}
secrets: inherit
build-cpp-swift-deps:
name: Build macOS Packages
uses: ./.github/workflows/build-cpp-swift-deps.yml
needs: configure
with:
ice_version: ${{ needs.configure.outputs.semver_version }}
channel: ${{ needs.configure.outputs.channel }}
secrets: inherit
build-all:
name: Build All Packages
runs-on: ubuntu-24.04
needs:
- build-brew-packages
- build-deb-packages
- build-dotnet-packages
- build-gem-packages
- build-matlab-packages
- build-java-packages
- build-slice-tools-packages
- build-npm-packages
- build-pip-packages
- build-rpm-packages
- build-windows-installer
- build-icegridgui-macos-app
- build-cpp-swift-deps
- build-symbols-sources-store
- build-cpp-nuget-packages
steps:
- run: echo "All packages built successfully"
prune-nightly-artifacts:
name: Prune Nightly Artifacts
if: ${{ inputs.publish == true && inputs.quality == 'nightly' }}
needs:
- configure
- build-all
uses: ./.github/workflows/prune-nightly-artifacts.yml
with:
channel: ${{ needs.configure.outputs.channel }}
secrets: inherit
publish-release:
name: Publish Release
if: ${{ inputs.publish == true }}
needs:
- configure
- build-all
- prune-nightly-artifacts
uses: ./.github/workflows/publish-release.yml
with:
channel: ${{ needs.configure.outputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ github.run_id }}
secrets: inherit
zeroc-ice-3.8.1/.github/workflows/build-rpm-ice-repo-packages.yml 0000664 0000000 0000000 00000004311 15165676005 0024705 0 ustar 00root root 0000000 0000000 name: "Build Ice Repo RPM Packages"
on:
workflow_dispatch:
inputs:
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: false
default: "nightly"
jobs:
build:
name: "Build Ice Repo RPM packages for ${{ matrix.distribution }}"
runs-on: ubuntu-24.04
strategy:
matrix:
distribution: [el9, el10, amzn2023]
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Load version info
run: |
source ice/config/version.env
echo "CHANNEL=$CHANNEL" >> $GITHUB_ENV
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: zeroc-ice
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build RPM packages
run: |
docker run --rm \
-v "$GITHUB_WORKSPACE:/workspace" \
-e GPG_KEY="${{ secrets.ICE_3_8_CI_SIGNER_KEY }}" \
-e GPG_KEY_ID="${{ secrets.ICE_3_8_CI_SIGNER_KEY_ID }}" \
ghcr.io/zeroc-ice/ice-rpm-builder-${{ matrix.distribution }}:${CHANNEL} \
/workspace/ice/packaging/rpm/build-repo-package.sh \
--distribution "${{ matrix.distribution }}" \
--channel "${CHANNEL}" \
--quality "${{ inputs.quality }}"
- name: Sync RPM packages to S3
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}/${DISTRIBUTION}"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}/${DISTRIBUTION}"
fi
aws s3 cp build/RPMS/noarch/*.rpm "s3://zeroc-downloads/${UPLOAD_PATH}/"
env:
QUALITY: ${{ inputs.quality }}
DISTRIBUTION: ${{ matrix.distribution }}
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: rpm-packages-${{ matrix.distribution }}
path: |
build/RPMS/*
build/SRPMS/*
zeroc-ice-3.8.1/.github/workflows/build-rpm-packages.yml 0000664 0000000 0000000 00000003366 15165676005 0023215 0 ustar 00root root 0000000 0000000 name: "Build RPM Packages"
on:
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
workflow_call:
inputs:
ice_version:
required: false
type: string
jobs:
build:
name: "Build for ${{ matrix.distribution }}-${{ matrix.arch }}"
runs-on: ${{ matrix.arch == 'aarch64' && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
strategy:
matrix:
distribution: [el9, el10, amzn2023]
arch: [x86_64, aarch64]
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Load version info
run: |
source ice/config/version.env
echo "CHANNEL=$CHANNEL" >> $GITHUB_ENV
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: zeroc-ice
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build RPM packages
run: |
docker run --rm \
-v "$GITHUB_WORKSPACE:/workspace" \
-e ICE_VERSION="${{ inputs.ice_version }}" \
-e GIT_TAG="${{ github.ref_name }}" \
-e GPG_KEY="${{ secrets.ICE_3_8_CI_SIGNER_KEY }}" \
-e GPG_KEY_ID="${{ secrets.ICE_3_8_CI_SIGNER_KEY_ID }}" \
ghcr.io/zeroc-ice/ice-rpm-builder-${{ matrix.distribution }}:${CHANNEL} \
/workspace/ice/packaging/rpm/build-package.sh
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: rpm-packages-${{ matrix.distribution }}-${{ matrix.arch }}
path: |
build/RPMS/*
build/SRPMS/*
zeroc-ice-3.8.1/.github/workflows/build-slice-tools-packages.yml 0000664 0000000 0000000 00000010442 15165676005 0024645 0 ustar 00root root 0000000 0000000 name: "Build Slice Tools Packages"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version to build"
required: false
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
jobs:
build-slice-compilers:
strategy:
matrix:
include:
- os: macos-26
target: macos-arm64
artifact-path: cpp/bin/slice2java
- os: windows-2022
target: windows-x64
artifact-path: cpp/bin/x64/Release/slice2java.*
- os: ubuntu-24.04
target: linux-x64
artifact-path: cpp/bin/slice2java
- os: ubuntu-24.04-arm
target: linux-arm64
artifact-path: cpp/bin/slice2java
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Build Compiler
uses: ./.github/actions/build-slice-compiler
with:
compiler_name: slice2java
authenticode_sign: ${{ inputs.authenticode_sign }}
env:
AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
- name: Upload Compiler Artifact
uses: actions/upload-artifact@v4
with:
name: slice2java-${{ matrix.target }}
path: ${{ matrix.artifact-path }}
build-slice-tools-packages:
runs-on: ubuntu-24.04
needs: build-slice-compilers
env:
SLICE2JAVA_STAGING_PATH: ${{ github.workspace }}/ice/java/tools/slice-tools/src/main/resources/resources
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
path: ice
- name: Download All slice2java Artifacts
uses: actions/download-artifact@v4
with:
path: artifacts
pattern: slice2java-*
- name: Copy slice2java binaries to staging path
run: |
# Create the staging path.
mkdir -p "$SLICE2JAVA_STAGING_PATH/macos-arm64" \
"$SLICE2JAVA_STAGING_PATH/linux-x64" \
"$SLICE2JAVA_STAGING_PATH/linux-arm64" \
"$SLICE2JAVA_STAGING_PATH/windows-x64"
# Copy the slice2java binaries to the staging path.
cp -v artifacts/slice2java-macos-arm64/slice2java "$SLICE2JAVA_STAGING_PATH/macos-arm64/"
chmod +x $SLICE2JAVA_STAGING_PATH/macos-arm64/slice2java
cp -v artifacts/slice2java-linux-x64/slice2java "$SLICE2JAVA_STAGING_PATH/linux-x64/"
chmod +x $SLICE2JAVA_STAGING_PATH/linux-x64/slice2java
cp -v artifacts/slice2java-linux-arm64/slice2java "$SLICE2JAVA_STAGING_PATH/linux-arm64/"
chmod +x $SLICE2JAVA_STAGING_PATH/linux-arm64/slice2java
cp -v artifacts/slice2java-windows-x64/slice2java.exe "$SLICE2JAVA_STAGING_PATH/windows-x64/"
for component in DataStorm Glacier2 Ice IceBox IceGrid IceStorm; do
mkdir -p $SLICE2JAVA_STAGING_PATH/slice/$component
cp -v ice/slice/$component/*.ice $SLICE2JAVA_STAGING_PATH/slice/$component
done
- name: Update Ice Version
run: |
sed -i "s/^sliceToolsVersion = .*/sliceToolsVersion = ${{ inputs.ice_version }}/" tools/slice-tools/gradle.properties
working-directory: ice/java
if: ${{ inputs.ice_version != '' }}
- name: Build Slice Tools for Java Packages
run: |
../../gradlew publishAllPublicationsToSliceToolsRepository \
-PmavenRepository=file://${{ github.workspace }}/local-repo
working-directory: ice/java/tools/slice-tools
- name: Upload Artifacts
uses: actions/upload-artifact@v4
with:
name: slice-tools-packages
path: |
local-repo/**/*.jar
local-repo/**/*.pom
zeroc-ice-3.8.1/.github/workflows/build-symbols-sources-store.yml 0000664 0000000 0000000 00000006625 15165676005 0025147 0 ustar 00root root 0000000 0000000 name: "Build Symbols and Sources Store"
on:
workflow_call:
inputs:
ice_version:
required: false
type: string
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
description: "The run ID to use for downloading artifacts"
required: true
type: string
workflow_dispatch:
inputs:
ice_version:
description: "The Ice version (e.g., 3.9.0). Required for nightly builds, optional for stable."
required: false
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID of a successful build-cpp-windows-binaries workflow run"
required: true
jobs:
build-symbols-sources-store:
runs-on: windows-2022
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Set ICE_VERSION
shell: bash
run: |
if [[ "${{ inputs.quality }}" == "stable" ]]; then
source ./config/version.env
echo "ICE_VERSION=${BASE_VERSION}" >> $GITHUB_ENV
else
echo "ICE_VERSION=${{ inputs.ice_version }}" >> $GITHUB_ENV
fi
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install Windows Debug Tools
uses: ./.github/actions/install-windows-debug-tools
- name: Download C++ Windows Binaries
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-x64-Release-build --dir cpp
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-x64-Debug-build --dir cpp
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-Win32-Release-build --dir cpp
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-Win32-Debug-build --dir cpp
- name: Compute Source Base URL
id: source-url
run: |
if ("${{ inputs.quality }}" -eq "stable") {
$url = "https://symbols.zeroc.com/sources/ice/"
} else {
$url = "https://download.zeroc.com/ice/${{ inputs.quality }}/${{ inputs.channel }}/sources/"
}
echo "source_base_url=$url" >> $env:GITHUB_OUTPUT
shell: pwsh
- name: Index PDBs and Sources
run: |
python packaging/release/index-ice-pdb-sources.py `
--source-dir ${{ github.workspace }} `
--version $env:ICE_VERSION `
--source-base-url ${{ steps.source-url.outputs.source_base_url }} `
--output-dir ${{ github.workspace }}/symbols-sources
- name: Create Symbols Store
run: |
symstore add /3 /r /t "Ice for C++" `
/v "$env:ICE_VERSION" `
/s "${{ github.workspace }}/symbols-sources/symbols/$env:ICE_VERSION/" `
/f "${{ github.workspace }}/symbols-sources/pdbs/$env:ICE_VERSION/" `
/compress
- name: Upload Symbols and Sources
uses: actions/upload-artifact@v4
with:
name: windows-symbols-sources
path: ${{ github.workspace }}/symbols-sources/
zeroc-ice-3.8.1/.github/workflows/build-windows-installer.yml 0000664 0000000 0000000 00000006737 15165676005 0024335 0 ustar 00root root 0000000 0000000 name: "Build Windows Installer"
on:
workflow_call:
inputs:
run_id:
description: "The run ID to use for downloading artifacts"
required: true
type: string
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
workflow_dispatch:
inputs:
run_id:
description: "The run ID to use for downloading artifacts"
required: true
authenticode_sign:
description: "Whether to Authenticode sign Windows binaries"
required: false
type: boolean
default: false
jobs:
build-windows-installer:
runs-on: windows-2022
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Download Artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name windows-cpp-x64-Release-build --dir cpp
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --name icegridgui-jar-Windows --dir java/lib
- name: Download VC++ Redistributable
run: |
New-Item -ItemType Directory -Force -Path packaging\windows-installer\redist
Invoke-WebRequest -Uri "https://aka.ms/vs/17/release/vc_redist.x64.exe" -OutFile "packaging\windows-installer\redist\vc_redist.x64.exe"
shell: powershell
- name: Build MSI
run: dotnet build -c Release -p:Platform=x64
working-directory: packaging/windows-installer/msi
env:
StagingDir: "${{ github.workspace }}\\staging"
- name: Sign MSI with Trusted Signing
if: ${{ inputs.authenticode_sign }}
uses: azure/trusted-signing-action@v0
with:
azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
azure-client-secret: ${{ secrets.AZURE_CLIENT_SECRET }}
endpoint: https://eus.codesigning.azure.net/
trusted-signing-account-name: zeroc
certificate-profile-name: zeroc-ice
files-folder: ./packaging/windows-installer/msi/bin/x64/Release/
files-folder-filter: msi
file-digest: SHA256
timestamp-rfc3161: http://timestamp.acs.microsoft.com
timestamp-digest: SHA256
- name: Build Bundle
run: dotnet build -c Release -p:Platform=x64
working-directory: packaging/windows-installer/bundle
- name: Sign Bundle installer with Trusted Signing
if: ${{ inputs.authenticode_sign }}
uses: azure/trusted-signing-action@v0
with:
azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
azure-client-secret: ${{ secrets.AZURE_CLIENT_SECRET }}
endpoint: https://eus.codesigning.azure.net/
trusted-signing-account-name: zeroc
certificate-profile-name: zeroc-ice
files-folder: ./packaging/windows-installer/bundle/bin/x64/Release/
files-folder-filter: exe
file-digest: SHA256
timestamp-rfc3161: http://timestamp.acs.microsoft.com
timestamp-digest: SHA256
- name: Upload Installer
uses: actions/upload-artifact@v4
with:
name: windows-installer
path: |
packaging/windows-installer/bundle/bin/x64/Release/*.exe
zeroc-ice-3.8.1/.github/workflows/ci-linux.yml 0000664 0000000 0000000 00000007067 15165676005 0021300 0 ustar 00root root 0000000 0000000 name: CI Linux
on:
workflow_dispatch:
push:
branches: ["main"]
pull_request:
branches: ["main"]
concurrency:
group: ci-linux-${{ github.head_ref || github.run_id }}
cancel-in-progress: true
jobs:
build-and-test:
name: ${{ matrix.distribution }}-${{ matrix.arch }}
runs-on: ${{ (contains(matrix.arch, 'arm64') || contains(matrix.arch, 'aarch64')) && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
strategy:
fail-fast: false
matrix:
include:
# RPM-based distributions
- distribution: el9
arch: x86_64
image_type: rpm
python: python3.12
- distribution: el9
arch: aarch64
image_type: rpm
python: python3.12
- distribution: el10
arch: x86_64
image_type: rpm
- distribution: el10
arch: aarch64
image_type: rpm
- distribution: amzn2023
arch: x86_64
image_type: rpm
python: python3.12
- distribution: amzn2023
arch: aarch64
image_type: rpm
python: python3.12
# DEB-based distributions
- distribution: ubuntu24.04
arch: amd64
image_type: deb
- distribution: ubuntu24.04
arch: arm64
image_type: deb
- distribution: debian12
arch: amd64
image_type: deb
- distribution: debian12
arch: arm64
image_type: deb
- distribution: debian13
arch: amd64
image_type: deb
- distribution: debian13
arch: arm64
image_type: deb
- distribution: sid
arch: amd64
image_type: deb
- distribution: sid
arch: arm64
image_type: deb
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Load version info
run: |
source config/version.env
echo "CHANNEL=$CHANNEL" >> $GITHUB_ENV
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GHCR
uses: docker/login-action@v3
with:
registry: ghcr.io
username: zeroc-ice
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build and test C++
run: |
docker run --rm \
-v "$GITHUB_WORKSPACE:/ice" \
-w /ice/cpp \
ghcr.io/zeroc-ice/ice-${{ matrix.image_type }}-builder-${{ matrix.distribution }}:${CHANNEL} \
bash -c "
set -ex
make -j\$(nproc) srcs
make -j\$(nproc) tests
# The --rfilter option excludes tests matching the regex. These tests are excluded because
# they require dependencies or permissions not available in the Docker builder images:
# - IceUtil/priority, Ice/threadPoolPriority: require CAP_SYS_NICE for thread priorities
# - Glacier2/*: require the passlib Python module
# - IceSSL/configuration: requires the openssl CLI tool
${{ matrix.python || 'python3' }} allTests.py --workers=4 --debug --continue \
--rfilter='IceUtil/priority|Ice/threadPoolPriority|Glacier2/|IceSSL/configuration'
"
- name: Upload test logs
uses: actions/upload-artifact@v4
with:
name: test-logs-${{ matrix.distribution }}-${{ matrix.arch }}
path: cpp/**/*.log
if-no-files-found: ignore
if: always()
zeroc-ice-3.8.1/.github/workflows/ci.yml 0000664 0000000 0000000 00000033067 15165676005 0020142 0 ustar 00root root 0000000 0000000 name: CI
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
# See https://docs.github.com/en/actions/using-jobs/using-concurrency#example-using-a-fallback-value
concurrency:
group: ${{ github.head_ref || github.run_id }}
cancel-in-progress: true
env:
# Configure the various build systems to treat warnings as errors
WARNINGS_AS_ERRORS: yes
jobs:
ci:
name: ${{ matrix.config }} on ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
include:
# Release builds
- os: macos-26
config: "release"
# We want to test C++ and Swift only (in each direction)
cross_test_flags: "--all-cross --filter cpp --filter swift"
python_tests: true
- os: ubuntu-24.04
config: "release"
cross_test_flags: "--all-cross"
- os: ubuntu-24.04-arm
config: "release"
build_flags: "SKIP=csharp" # Skip C# on ARM as .NET compiler keeps crashing
test_flags: "--rfilter=csharp"
python_tests: true
- os: windows-2022
config: "release"
build_flags: "/p:Platform=x64"
test_flags: "--platform=x64"
python_tests: true
- os: windows-2022
config: "cpp-win32-release"
working_directory: "cpp"
build_flags: "/p:Platform=Win32"
msbuild_project: "msbuild/ice.proj"
test_flags: "--platform=Win32"
python_tests: true
- os: windows-2025
config: "release"
build_flags: "/p:Platform=x64"
test_flags: "--platform=x64"
python_tests: true
# Debug builds
- os: macos-26
config: "debug"
build_flags: "OPTIMIZE=no"
test_flags: "--swift-config=debug --csharp-config=Debug"
python_tests: true
enable_csharp_analysis: true
- os: ubuntu-24.04
config: "debug"
build_flags: "OPTIMIZE=no"
test_flags: "--csharp-config=Debug"
python_tests: true
enable_csharp_analysis: true
# TODO - figure out how to properly install debug Python
- os: windows-2022
config: "debug"
working_directory: "cpp"
build_flags: "/p:Platform=x64 /p:Configuration=Debug"
test_flags: "--platform=x64 --config=Debug"
msbuild_project: "msbuild/ice.proj"
python_tests: true
enable_csharp_analysis: true
# iOS
- os: macos-26
config: "ios"
build_flags: "OPTIMIZE=no PLATFORMS='macosx iphonesimulator' CONFIGS='static shared' LANGUAGES='cpp swift'"
test_flags: "--languages='cpp,swift' --config=debug --platform=iphonesimulator --controller-app"
build_cpp_and_python: true
# Static builds
- os: ubuntu-24.04
config: "static"
build_flags: "CONFIGS=static"
test_flags: "--config=static --filter=Ice/ --filter=IceDiscovery/"
working_directory: "cpp"
# MATLAB
- os: ubuntu-24.04
config: "matlab"
working_directory: "matlab"
build_cpp_and_python: true
- os: windows-2022
config: "matlab"
working_directory: "matlab"
build_flags: "/p:Platform=x64"
msbuild_project: "msbuild/ice.proj"
test_flags: "--platform=x64"
build_cpp_and_python: true
- os: ubuntu-24.04
config: "android"
working_directory: "java"
test_flags: "--android --controller-app"
build_cpp_and_python: true
build_android_controller: true
# .NET 10.0
- os: ubuntu-24.04
config: ".NET10"
working_directory: "csharp"
net_target_framework: "net10.0"
test_flags: "--target-framework=net10.0"
build_cpp_and_python: true
- os: windows-2025
config: ".NET10"
working_directory: "csharp"
msbuild_command: "dotnet msbuild"
build_flags: "/p:Platform=x64"
msbuild_project: "msbuild/ice.proj"
net_target_framework: "net10.0"
test_flags: "--target-framework=net10.0"
build_cpp_and_python: true
- os: macos-26
config: ".NET10"
working_directory: "csharp"
net_target_framework: "net10.0"
test_flags: "--target-framework=net10.0"
build_cpp_and_python: true
# Python 3.12 testing
- os: windows-2025
config: "Python312"
working_directory: "python"
build_flags: "/p:Platform=x64"
msbuild_project: "msbuild/ice.proj"
build_cpp_and_python: true
python_version: "3.12"
python_tests: true
- os: macos-26
config: "Python312"
working_directory: "python"
build_cpp_and_python: true
python_version: "3.12"
python_tests: true
- os: ubuntu-24.04
config: "Python312"
working_directory: "python"
build_cpp_and_python: true
python_version: "3.12"
python_tests: true
# Python 3.13 testing
- os: windows-2025
config: "Python313"
working_directory: "python"
build_flags: "/p:Platform=x64"
msbuild_project: "msbuild/ice.proj"
build_cpp_and_python: true
python_version: "3.13"
python_tests: true
- os: macos-26
config: "Python313"
working_directory: "python"
build_cpp_and_python: true
python_version: "3.13"
python_tests: true
- os: ubuntu-24.04
config: "Python313"
working_directory: "python"
build_cpp_and_python: true
python_version: "3.13"
python_tests: true
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Print System Info
uses: ./.github/actions/system-info
- name: macOS FQDN Fix
uses: ./.github/actions/macos-fqdn
if: runner.os == 'macOS'
- name: Disk space before setup
run: df -h
shell: bash
# Free up disk space to avoid running out of space when starting the Android emulator for tests
- name: Free up disk space
if: matrix.config == 'android'
run: |
sudo rm -rf /usr/local/go* /opt/hostedtoolcache/go
sudo rm -rf /usr/local/.ghcup
sudo rm -rf /usr/share/dotnet
df -h
shell: bash
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup PHP
uses: ./.github/actions/setup-php
- name: Setup Python
uses: ./.github/actions/setup-python
with:
python-version: ${{ matrix.python_version || '3.14' }}
- name: Setup .NET
if: matrix.config != 'android'
uses: ./.github/actions/setup-dotnet
with:
include_net10: ${{ matrix.net_target_framework == 'net10.0' }}
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Setup Node
uses: ./.github/actions/setup-node
- name: Setup Ruby
if: runner.os != 'Windows'
uses: ./.github/actions/setup-ruby
- name: Setup MATLAB
if: matrix.config == 'matlab'
uses: ./.github/actions/setup-matlab
- name: Setup Android
if: matrix.config == 'android'
uses: ./.github/actions/setup-android
- name: Install Windows Debug Tools
if: runner.os == 'Windows'
uses: ./.github/actions/install-windows-debug-tools
- name: Install ice-builder-xcode
run: |
#TODO: We should consider removing the dependency on ice-builder-xcode
brew install zeroc-ice/tap/ice-builder-xcode
shell: bash
if: (runner.os == 'macOS') && (matrix.config == 'ios')
- name: Setup Cache
uses: ./.github/actions/setup-cache
with:
prefix: ci-${{ matrix.config }}
- name: Disk space after setup
run: df -h
shell: bash
# See https://learn.microsoft.com/en-us/windows/win32/wer/collecting-user-mode-dumps
- name: Enable Windows crash dumps
run: |
reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps" /v DumpType /t REG_DWORD /d 2 /f
reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps" /v DumpFolder /t REG_EXPAND_SZ /d ${{ github.workspace }}\LocalDumps /f
reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Windows Error Reporting" /v DontShowUI /t REG_DWORD /d 1 /f
shell: powershell
if: runner.os == 'Windows'
- name: Enable C# Analysis
if: matrix.enable_csharp_analysis == true
run: |
echo "EnableAnalysis=true" >> $env:GITHUB_ENV
shell: pwsh
- name: .NET Target Framework
if: matrix.net_target_framework == 'net10.0'
run: |
echo "AppTargetFramework=net10.0" >> $env:GITHUB_ENV
shell: pwsh
- name: Build ${{ matrix.config }} on ${{ matrix.os }}
uses: ./.github/actions/build
timeout-minutes: 90
with:
working_directory: ${{ matrix.working_directory || '.' }}
build_cpp_and_python: ${{ matrix.build_cpp_and_python || false }}
build_android_controller: ${{ matrix.build_android_controller || false }}
build_flags: ${{ matrix.build_flags || '' }}
msbuild_command: ${{ matrix.msbuild_command || 'msbuild /m' }}
msbuild_project: ${{ matrix.msbuild_project || 'ice.proj' }}
- name: Install testing dependencies from pip
run: python3 -m pip install passlib cryptography numpy
shell: bash
- name: Test ${{ matrix.config }} on ${{ matrix.os }}
uses: ./.github/actions/test
timeout-minutes: 45
with:
working_directory: ${{ matrix.working_directory || '.' }}
flags: ${{ matrix.test_flags }}
- name: Cross Test ${{ matrix.config }} on ${{ matrix.os }}
uses: ./.github/actions/test
timeout-minutes: 30
with:
working_directory: ${{ matrix.working_directory || '.' }}
flags: ${{ matrix.cross_test_flags }}
if: matrix.cross_test_flags != ''
- name: Remove Python tests generated code
run: |
# Remove generated files from previous runs before to test with loadSlice
# to ensure we use the dynamically generated code.
find python/test -name generated -exec rm -rfv {} +
shell: bash
if: matrix.python_tests == true
- name: Python Test with loadSlice ${{ matrix.config }} on ${{ matrix.os }}
uses: ./.github/actions/test
timeout-minutes: 45
with:
working_directory: ${{ matrix.working_directory || '.' }}
flags: "${{ matrix.test_flags }} --load-slice --language=python"
if: matrix.python_tests == true
- name: Generate API Reference
uses: ./.github/actions/documentation
with:
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
aws-s3-code-bucket: ${{ secrets.AWS_S3_CODE_BUCKET }}
github-token: ${{ secrets.GITHUB_TOKEN }}
if: matrix.config == 'release' && runner.os == 'macOS'
- name: Upload test logs
uses: actions/upload-artifact@v4
with:
name: test-logs-${{ matrix.config }}-${{ matrix.os }}
path: ${{ '.' }}/**/*.log
if-no-files-found: ignore
if: always()
- name: Process Linux crash dumps
if: runner.os == 'Linux' && always()
run: |
python3 scripts/process_linux_crash_dumps.py \
--workspace $GITHUB_WORKSPACE \
--reports LinuxDumpReports
shell: bash
- name: Upload Linux crash dump reports
uses: actions/upload-artifact@v4
with:
name: crash-dumps-${{ matrix.config }}-${{ matrix.os }}
path: ${{ github.workspace }}/LinuxDumpReports/*
if-no-files-found: ignore
if: runner.os == 'Linux' && always()
- name: Upload macOS crash diagnostics
uses: actions/upload-artifact@v4
with:
name: crash-diagnostics-${{ matrix.config }}-${{ matrix.os }}
path: ~/Library/Logs/DiagnosticReports/*.ips
if-no-files-found: ignore
if: runner.os == 'macOS' && always()
- name: Process Windows crash dumps
if: runner.os == 'Windows' && always()
shell: pwsh
run: |
$dumpDir = Join-Path $env:GITHUB_WORKSPACE 'LocalDumps'
$reportsDir = Join-Path $env:GITHUB_WORKSPACE 'LocalDumpReports'
python scripts\process_windows_crash_dumps.py `
--dumps $dumpDir `
--workspace $env:GITHUB_WORKSPACE `
--reports $reportsDir `
--cdb "C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\cdb.exe"
- name: Upload Windows crash dump reports
uses: actions/upload-artifact@v4
with:
name: crash-dumps-${{ matrix.config }}-${{ matrix.os }}
path: ${{ github.workspace }}/LocalDumpReports/*
if-no-files-found: ignore
if: runner.os == 'Windows' && always()
zeroc-ice-3.8.1/.github/workflows/compat-nightly.yml 0000664 0000000 0000000 00000015607 15165676005 0022506 0 ustar 00root root 0000000 0000000 name: Binary Compatibility
on:
workflow_dispatch:
# Builds tests from a stable tag and distribution libraries from the branch HEAD, then swaps the HEAD libraries into
# the stable test tree and runs the tests. If the tests pass, the HEAD libraries are binary-compatible with that stable
# release.
#
# Each stable branch (3.7, 3.8) maintains its own copy of this workflow with branch-specific configuration below.
# Branch-specific configuration:
env:
STABLE_TAG: "v3.8.0"
jobs:
compat:
name: compat on ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [macos-26, ubuntu-24.04, ubuntu-24.04-arm, windows-2025]
steps:
- name: Checkout HEAD
uses: actions/checkout@v4
with:
path: head
- name: Checkout stable (${{ env.STABLE_TAG }})
uses: actions/checkout@v4
with:
ref: ${{ env.STABLE_TAG }}
path: stable
- name: macOS FQDN Fix
uses: ./head/.github/actions/macos-fqdn
if: runner.os == 'macOS'
- name: Setup C++
uses: ./head/.github/actions/setup-cpp
- name: Setup .NET
uses: ./head/.github/actions/setup-dotnet
if: matrix.os == 'ubuntu-24.04'
- name: Setup Java
uses: ./head/.github/actions/setup-java
if: matrix.os == 'ubuntu-24.04'
- name: Setup Python
uses: ./head/.github/actions/setup-python
# Build HEAD distribution libraries only.
- name: Build HEAD C++ dist (Unix)
if: runner.os != 'Windows'
run: make -C head/cpp srcs
shell: bash
timeout-minutes: 60
- name: Build HEAD C++ dist (Windows)
if: runner.os == 'Windows'
run: msbuild /m /t:BuildDist head\cpp\msbuild\ice.proj /p:Platform=x64 /p:Configuration=Release
shell: powershell
timeout-minutes: 60
- name: Build HEAD C# and Java dist
if: matrix.os == 'ubuntu-24.04'
run: |
make -C head/csharp srcs
make -C head/java srcs
shell: bash
timeout-minutes: 30
# Build stable completely (distribution + tests).
- name: Build stable C++ (Unix)
if: runner.os != 'Windows'
run: make -C stable/cpp
shell: bash
timeout-minutes: 90
- name: Build stable C++ (Windows)
if: runner.os == 'Windows'
run: msbuild /m stable\cpp\msbuild\ice.proj /p:Platform=x64 /p:Configuration=Release
shell: powershell
timeout-minutes: 90
- name: Build stable C# and Java
if: matrix.os == 'ubuntu-24.04'
run: |
make -C stable/csharp
make -C stable/java
shell: bash
timeout-minutes: 60
# Swap HEAD libraries into the stable tree, replacing the stable distribution libraries while keeping the stable
# test binaries. This is the core of the binary compatibility test.
- name: Swap HEAD C++ libraries (Unix)
if: runner.os != 'Windows'
run: |
echo "=== HEAD C++ libraries ==="
ls -la head/cpp/lib/
echo ""
echo "=== Stable C++ libraries BEFORE swap ==="
ls -la stable/cpp/lib/
echo ""
cp -afv head/cpp/lib/. stable/cpp/lib/
echo ""
echo "=== Stable C++ libraries AFTER swap ==="
ls -la stable/cpp/lib/
shell: bash
- name: Swap HEAD C++ libraries (Windows)
if: runner.os == 'Windows'
run: |
Write-Host "=== HEAD C++ DLLs ==="
Get-ChildItem head\cpp\bin\x64\Release\*.dll | Format-Table Name, Length, LastWriteTime
Write-Host ""
Write-Host "=== Stable C++ DLLs BEFORE swap ==="
Get-ChildItem stable\cpp\bin\x64\Release\*.dll | Format-Table Name, Length, LastWriteTime
Write-Host ""
Copy-Item head\cpp\bin\x64\Release\*.dll stable\cpp\bin\x64\Release\ -Force -Verbose
Write-Host ""
Write-Host "=== Stable C++ DLLs AFTER swap ==="
Get-ChildItem stable\cpp\bin\x64\Release\*.dll | Format-Table Name, Length, LastWriteTime
shell: powershell
- name: Swap HEAD C# libraries
if: matrix.os == 'ubuntu-24.04'
run: |
for dll in Ice Glacier2 IceBox IceDiscovery IceGrid IceLocatorDiscovery IceStorm; do
echo "=== Swapping ${dll}.dll ==="
echo "Source: head/csharp/src/${dll}/bin/Release/net8.0/${dll}.dll"
ls -la "head/csharp/src/${dll}/bin/Release/net8.0/${dll}.dll" 2>&1 || echo " WARNING: source not found!"
echo "Targets in stable tree:"
find stable/csharp/test -name "${dll}.dll" -exec ls -la {} \;
find stable/csharp/test -name "${dll}.dll" -exec cp -v "head/csharp/src/${dll}/bin/Release/net8.0/${dll}.dll" {} \;
echo ""
done
shell: bash
- name: Swap HEAD Java libraries
if: matrix.os == 'ubuntu-24.04'
run: |
STABLE_VER=$(grep '^iceVersion' stable/java/gradle.properties | cut -d= -f2 | tr -d ' ')
HEAD_VER=$(grep '^iceVersion' head/java/gradle.properties | cut -d= -f2 | tr -d ' ')
echo "Stable version: ${STABLE_VER}"
echo "HEAD version: ${HEAD_VER}"
echo ""
echo "=== HEAD Java JARs ==="
ls -la head/java/lib/*-${HEAD_VER}.jar
echo ""
echo "=== Stable Java JARs BEFORE swap ==="
ls -la stable/java/lib/
echo ""
for jar in head/java/lib/*-${HEAD_VER}.jar; do
name=$(basename "$jar" | sed "s/${HEAD_VER}/${STABLE_VER}/")
echo "Copying: $jar -> stable/java/lib/${name}"
cp -v "$jar" "stable/java/lib/${name}"
done
echo ""
echo "=== Stable Java JARs AFTER swap ==="
ls -la stable/java/lib/
shell: bash
- name: Install testing dependencies
run: python3 -m pip install passlib cryptography numpy
shell: bash
# Run the stable test suite against the HEAD libraries.
# Exclude IceSSL/configuration because the 3.8.0 test connects to the decommissioned Glacier2 demo proxy on
# zeroc.com (removed from HEAD by #5047).
# Exclude Slice/macros because it compares compile-time and runtime Ice versions (Util.intVersion()), which
# won't match when built and run with different patch versions.
- name: Run compatibility tests
uses: ./head/.github/actions/test
timeout-minutes: 45
with:
working_directory: stable
flags: >-
--rfilter="IceSSL/configuration|Slice/macros"
${{ matrix.os == 'ubuntu-24.04' && '--languages=cpp,csharp,java' || '--languages=cpp' }}
- name: Upload test results
uses: actions/upload-artifact@v4
with:
name: compat-test-results-${{ matrix.os }}
path: |
stable/cpp/test-report.xml
stable/**/*.log
if-no-files-found: ignore
if: always()
zeroc-ice-3.8.1/.github/workflows/coverage.yml 0000664 0000000 0000000 00000014401 15165676005 0021331 0 ustar 00root root 0000000 0000000 name: Coverage
on:
workflow_dispatch:
schedule:
- cron: "0 0 * * 0" # Run every Sunday at midnight
jobs:
generate-cpp-coverage-report:
runs-on: macos-26
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install testing dependencies from pip
run: python3 -m pip install passlib cryptography numpy
shell: bash
- name: Generate C++ Coverage
working-directory: ./cpp
run: ../scripts/generate-cpp-code-coverage.sh
- name: Generate C++ Coverage Reports
working-directory: ./cpp
run: |
for binary in bin/*; do
# Skip non-executable files in the bin directory (e.g., .zip files, etc.)
[[ ! -f "$binary" || ! -x "$binary" ]] && continue
../scripts/generate-cpp-code-coverage.sh "$binary"
done
for library in lib/*; do
if [[ $library =~ lib/lib[a-zA-Z0-9]+\.dylib ]]; then
../scripts/generate-cpp-code-coverage.sh "$library"
fi
done
# This will perform a full sync of the documentation to S3 every time the workflow is run since
# the timestamps will always be different. Using --size-only is not sufficient since the
# documentation may be updated without changing the size of the files. S3 does not offer a hash based sync.
- name: Sync Coverage Report to S3
working-directory: ./cpp/coverage/html
run: |
for coverage_dir in *; do
if [[ -d $coverage_dir ]]; then
aws s3 sync $coverage_dir s3://${AWS_S3_CODE_BUCKET}/ice/3.8/coverage/cpp/$(basename $coverage_dir) --delete
fi
done
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
AWS_S3_CODE_BUCKET: ${{ secrets.AWS_S3_CODE_BUCKET }}
AWS_DEFAULT_REGION: us-east-1
if: github.ref == 'refs/heads/3.8' && github.repository == 'zeroc-ice/ice'
generate-csharp-coverage-report:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup .NET
uses: ./.github/actions/setup-dotnet
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install testing dependencies from pip
run: python3 -m pip install passlib cryptography numpy
shell: bash
- name: Build
run: |
make -C cpp srcs
make -C csharp
- name: Generate C# Coverage
working-directory: ./csharp
run: |
dotnet tool install dotnet-coverage --global
dotnet-coverage collect --server-mode --background --session-id dotnet-coverage --output coverage.cobertura.xml --output-format cobertura --settings msbuild/coverage.runsettings
python3 allTests.py --all --workers=4 --debug --coverage-session dotnet-coverage
dotnet-coverage shutdown dotnet-coverage
- name: Generate Coverage Reports
uses: danielpalme/ReportGenerator-GitHub-Action@5.3.8
with:
reports: csharp/coverage.cobertura.xml
targetdir: coveragereport
reporttypes: Html;Badges
license: ${{ secrets.REPORT_GENERATOR_LICENSE }}
- name: Sync Coverage Report to S3
working-directory: ./coveragereport
run: aws s3 sync . s3://${AWS_S3_CODE_BUCKET}/ice/3.8/coverage/csharp --delete
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
AWS_S3_CODE_BUCKET: ${{ secrets.AWS_S3_CODE_BUCKET }}
AWS_DEFAULT_REGION: us-east-1
if: github.ref == 'refs/heads/3.8' && github.repository == 'zeroc-ice/ice'
generate-java-coverage-report:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install testing dependencies from pip
run: python3 -m pip install passlib cryptography numpy
shell: bash
- name: Generate Java Coverage
working-directory: ./java
run: |
../scripts/generate-java-code-coverage.sh
- name: Sync Coverage Report to S3
working-directory: ./java/coverage
run: aws s3 sync . s3://${AWS_S3_CODE_BUCKET}/ice/3.8/coverage/java --delete
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
AWS_S3_CODE_BUCKET: ${{ secrets.AWS_S3_CODE_BUCKET }}
AWS_DEFAULT_REGION: us-east-1
if: github.ref == 'refs/heads/3.8' && github.repository == 'zeroc-ice/ice'
generate-js-coverage-report:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Node.js
uses: ./.github/actions/setup-node
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install testing dependencies from pip
run: python3 -m pip install passlib cryptography numpy
shell: bash
- name: Build C++ and JavaScript
run: |
make -C cpp
make -C js
- name: Generate JavaScript Coverage
working-directory: ./js
run: |
../scripts/generate-js-code-coverage.sh
- name: Sync Coverage Report to S3
working-directory: ./js/coverage-report
run: aws s3 sync . s3://${AWS_S3_CODE_BUCKET}/ice/3.8/coverage/javascript --delete
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
AWS_S3_CODE_BUCKET: ${{ secrets.AWS_S3_CODE_BUCKET }}
AWS_DEFAULT_REGION: us-east-1
if: github.ref == 'refs/heads/3.8' && github.repository == 'zeroc-ice/ice'
zeroc-ice-3.8.1/.github/workflows/cpp.yml 0000664 0000000 0000000 00000006121 15165676005 0020320 0 ustar 00root root 0000000 0000000 name: C++
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
clang-format:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Install Clang Format
run: |
# This LLVM script will add the relevant LLVM PPA: https://apt.llvm.org/
wget https://apt.llvm.org/llvm.sh -O /tmp/llvm.sh
chmod +x /tmp/llvm.sh
sudo /tmp/llvm.sh 19
sudo apt-get install -y clang-format-19
rm /tmp/llvm.sh
clang-format-19 --version
if: runner.os == 'Linux'
- name: Run Clang Format
run: |
find . -name "*.h" -o -name "*.c" -o -name "*.cpp" -o -name "*.mm" | xargs clang-format-19 --style=file --fallback-style=none -i
find cpp -name "*.m" | xargs clang-format-19 --style=file --fallback-style=none -i
if [ -n "$(git status --porcelain)" ]; then
echo "clang-format found issues, please run it locally and commit the changes."
git diff
exit 1
else
echo "clang-format passed successfully."
fi
clang-tidy:
runs-on: ubuntu-24.04
steps:
- name: Checkout Ice
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Cache
uses: ./.github/actions/setup-cache
with:
prefix: clang-tidy
- name: Install clang-tidy
run: |
# This LLVM script will add the relevant LLVM PPA: https://apt.llvm.org/
wget https://apt.llvm.org/llvm.sh -O /tmp/llvm.sh
chmod +x /tmp/llvm.sh
sudo /tmp/llvm.sh 19
sudo apt-get install -y clang-tidy-19
rm /tmp/llvm.sh
clang-tidy-19 --version
- name: Install bear
run: |
sudo apt-get update
sudo apt-get install -y bear
bear --version
- name: Build Ice
timeout-minutes: 90
working-directory: cpp
run: bear -- make
- name: Build IcePy
timeout-minutes: 10
working-directory: python
run: bear -- make
- name: Select files to check
uses: tj-actions/glob@v22
id: glob
with:
files: |
**/*.cpp
excluded-files: |
**/generated/*.cpp
working-directory: cpp
- name: Run Clang Tidy
working-directory: cpp
run: |
echo "Running clang-tidy on ${{ steps.glob.outputs.paths }}"
run-clang-tidy-19 -j$(nproc) -quiet ${{ steps.glob.outputs.paths }}
- name: Select files to check for IcePy
uses: tj-actions/glob@v22
id: globpy
with:
files: |
**/*.cpp
working-directory: python
- name: Run Clang Tidy on IcePy
working-directory: python
run: |
echo "Running clang-tidy on ${{ steps.globpy.outputs.paths }}"
run-clang-tidy-19 -j$(nproc) -quiet ${{ steps.globpy.outputs.paths }}
zeroc-ice-3.8.1/.github/workflows/dispatch-compat-nightly.yml 0000664 0000000 0000000 00000001254 15165676005 0024274 0 ustar 00root root 0000000 0000000 name: Dispatch Binary Compatibility Nightly
on:
# Central scheduler (runs from the default branch)
schedule:
# Run 3.8 binary compat test at 5:00 AM UTC (after nightly release at 3:00 AM)
- cron: "0 5 * * *"
jobs:
dispatch-compat-nightly:
if: github.repository == 'zeroc-ice/ice'
runs-on: ubuntu-24.04
steps:
- name: Check out repository
uses: actions/checkout@v4
- name: Dispatch binary compat test for 3.8 (5:00 UTC)
if: github.event.schedule == '0 5 * * *'
uses: ./.github/actions/dispatch-workflow
with:
ref: 3.8
workflow: compat-nightly.yml
token: ${{ secrets.GITHUB_TOKEN }}
zeroc-ice-3.8.1/.github/workflows/dispatch-container-image-builds.yml 0000664 0000000 0000000 00000002640 15165676005 0025657 0 ustar 00root root 0000000 0000000 name: Dispatch Container Image Builds
on:
# Central scheduler (runs from the default branch)
schedule:
# Run main container image builds on Saturday at 6:00 AM UTC
- cron: "0 6 * * 6"
# Run 3.8 container image builds on Saturday at 7:00 AM UTC
- cron: "0 7 * * 6"
# Run 3.7 container image builds on Saturday at 8:00 AM UTC
- cron: "0 8 * * 6"
jobs:
dispatch-container-image-builds:
if: github.repository == 'zeroc-ice/ice'
runs-on: ubuntu-24.04
steps:
- name: Check out repository
uses: actions/checkout@v4
- name: Dispatch container image builds for main (6:00 UTC)
if: github.event.schedule == '0 6 * * 6'
uses: ./.github/actions/dispatch-workflow
with:
ref: main
workflow: build-container-images.yml
token: ${{ secrets.GITHUB_TOKEN }}
- name: Dispatch container image builds for 3.8 (7:00 UTC)
if: github.event.schedule == '0 7 * * 6'
uses: ./.github/actions/dispatch-workflow
with:
ref: 3.8
workflow: build-container-images.yml
token: ${{ secrets.GITHUB_TOKEN }}
- name: Dispatch container image builds for 3.7 (8:00 UTC)
if: github.event.schedule == '0 8 * * 6'
uses: ./.github/actions/dispatch-workflow
with:
ref: 3.7
workflow: build-container-images.yml
token: ${{ secrets.GITHUB_TOKEN }}
zeroc-ice-3.8.1/.github/workflows/dispatch-nightly-release.yml 0000664 0000000 0000000 00000002677 15165676005 0024443 0 ustar 00root root 0000000 0000000 name: Dispatch Nightly Release
on:
# Central scheduler (runs from the default branch)
schedule:
# Run main nightly at 2:00 AM UTC
- cron: "0 2 * * *"
# Run 3.8 nightly at 3:00 AM UTC
- cron: "0 3 * * *"
# Run 3.7 nightly at 4:00 AM UTC
- cron: "0 4 * * *"
jobs:
dispatch-nightly-release:
if: github.repository == 'zeroc-ice/ice'
runs-on: ubuntu-24.04
steps:
- name: Check out repository
uses: actions/checkout@v4
- name: Dispatch nightly build for main (2:00 UTC)
if: github.event.schedule == '0 2 * * *'
uses: ./.github/actions/dispatch-workflow
with:
ref: main
workflow: build-release.yml
token: ${{ secrets.GITHUB_TOKEN }}
inputs: '{"quality": "nightly", "publish": true}'
- name: Dispatch nightly build for 3.8 (3:00 UTC)
if: github.event.schedule == '0 3 * * *'
uses: ./.github/actions/dispatch-workflow
with:
ref: 3.8
workflow: build-release.yml
token: ${{ secrets.GITHUB_TOKEN }}
inputs: '{"quality": "nightly", "publish": true}'
- name: Dispatch nightly build for 3.7 (4:00 UTC)
if: github.event.schedule == '0 4 * * *'
uses: ./.github/actions/dispatch-workflow
with:
ref: 3.7
workflow: build-release.yml
token: ${{ secrets.GITHUB_TOKEN }}
inputs: '{"quality": "nightly", "publish": true}'
zeroc-ice-3.8.1/.github/workflows/dotnet.yml 0000664 0000000 0000000 00000000745 15165676005 0021041 0 ustar 00root root 0000000 0000000 name: .NET
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
dotnet-format:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup .NET
uses: ./.github/actions/setup-dotnet
- name: Run dotnet format
run: |
dotnet format --verify-no-changes csharp/msbuild/ice.slnx
zeroc-ice-3.8.1/.github/workflows/ice2slice.yml 0000664 0000000 0000000 00000002327 15165676005 0021404 0 ustar 00root root 0000000 0000000 name: Run ice2slice
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
ice2slice:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Build ice2slice
working-directory: ./cpp
run: make V=1 ice2slice
- name: Test ice2slice
working-directory: ./slice
run: |
# Run ice2slice on all .ice files in the slice directory
for dir in */; do ../cpp/bin/ice2slice -I. "$dir"/*.ice --output-dir $dir; done
# We don't generate anything for EndpointTypes.ice since it contains only constants.
touch Ice/EndpointTypes.slice
while IFS= read -r file; do
# Derive the matching *.slice filename
base="${file%.ice}"
slice_file="${base}.slice"
# Check if the *.slice file exists
if [ ! -f "$slice_file" ]; then
echo "Error: No matching .slice file for $file"
exit 1
fi
done < <(find . -type f -name "*.ice")
zeroc-ice-3.8.1/.github/workflows/java.yml 0000664 0000000 0000000 00000002022 15165676005 0020453 0 ustar 00root root 0000000 0000000 name: Java
on:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
checkstyle:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Build slice2java
run: make -C cpp slice2java
- name: Run checkstyle formatter
working-directory: java
run: ./gradlew check
rewrite:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Java
uses: ./.github/actions/setup-java
- name: Build slice2java
run: make -C cpp slice2java
- name: Run rewrite linter
working-directory: java
run: ./gradlew rewriteDryRun --no-parallel --no-configuration-cache
zeroc-ice-3.8.1/.github/workflows/javascript.yml 0000664 0000000 0000000 00000001522 15165676005 0021704 0 ustar 00root root 0000000 0000000 name: JavaScript
on:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
prettier:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Set up Node.js
uses: actions/setup-node@v4
with:
node-version: "latest"
- name: Run JavaScript prettier
run: npx prettier --check .
working-directory: js
eslint:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Set up Node.js
uses: actions/setup-node@v4
with:
node-version: "latest"
- name: Run JavaScript eslint
run: |
npm install
npx eslint
working-directory: js
zeroc-ice-3.8.1/.github/workflows/links.yml 0000664 0000000 0000000 00000001224 15165676005 0020655 0 ustar 00root root 0000000 0000000 name: Check Links
on:
workflow_dispatch:
push:
branches: ["main"]
paths:
- "**.md"
- "**.html"
- ".github/workflows/links.yml"
pull_request:
branches: ["main"]
paths:
- "**.md"
- "**.html"
- ".github/workflows/links.yml"
jobs:
check-links:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Check links
uses: lycheeverse/lychee-action@v2
with:
args: >-
--config .lychee.toml
--verbose
--no-progress
'**/*.md'
'**/*.html'
fail: true
zeroc-ice-3.8.1/.github/workflows/matlab.yml 0000664 0000000 0000000 00000001771 15165676005 0021004 0 ustar 00root root 0000000 0000000 name: Matlab
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
matlab-analyzer:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup MATLAB
uses: ./.github/actions/setup-matlab
- name: Build MATLAB on Ubuntu
uses: ./.github/actions/build
timeout-minutes: 90
with:
working_directory: "matlab"
build_cpp_and_python: true
- name: MATLAB Analyzer
run: |
$MATLAB_COMMAND code_analyzer
working-directory: ./matlab/config
shell: bash
- name: Upload Analyzer Report
uses: actions/upload-artifact@v4
with:
name: matlab-analyzer-report
path: ./matlab/config/result.json
if-no-files-found: ignore
if: always()
zeroc-ice-3.8.1/.github/workflows/prune-nightly-artifacts.yml 0000664 0000000 0000000 00000001373 15165676005 0024325 0 ustar 00root root 0000000 0000000 name: Prune Nightly Artifacts
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
jobs:
prune-nightly-artifacts:
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Prune nightly artifacts
env:
CHANNEL: ${{ inputs.channel }}
DRY_RUN: '0'
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
run: |
./packaging/release/prune-nightly-artifacts.sh
zeroc-ice-3.8.1/.github/workflows/publish-brew-packages.yml 0000664 0000000 0000000 00000004517 15165676005 0023724 0 ustar 00root root 0000000 0000000 name: "Publish Brew Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish-brew-packages:
name: "Publish Brew Packages"
runs-on: macos-26
# Stable Brew releases must be published manually.
if: ${{ inputs.quality == 'nightly' }}
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Download Homebrew Bottle XCFramework artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "homebrew-bottle" --dir staging
- name: Publish Homebrew Bottle Packages
run: |
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}"
aws s3 sync staging/homebrew-bottle/ "s3://${S3_DOWNLOADS_BUCKET}/${UPLOAD_PATH}/" --exclude "*" --include "*.tar.gz"
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
S3_DOWNLOADS_BUCKET: ${{ vars.S3_DOWNLOADS_BUCKET }}
- name: Clone Repository
run: |
git clone "https://x-access-token:${{ secrets.ICE_NIGHTLY_PUBLISH_TOKEN }}@github.com/zeroc-ice/homebrew-nightly.git" -b main
- name: Publish Homebrew Patch
run: |
# Configure git for pushing the patch
git config user.name "ZeroC"
git config user.email "git@zeroc.com"
# Apply and commit the patch created during the brew package build
git am "${GITHUB_WORKSPACE}/staging/homebrew-bottle/"ice@${{ inputs.channel }}-*.patch
# Push the updated formula
git push origin main || { echo "Push failed"; exit 1; }
working-directory: homebrew-nightly
zeroc-ice-3.8.1/.github/workflows/publish-cpp-swift-deps.yml 0000664 0000000 0000000 00000003054 15165676005 0024051 0 ustar 00root root 0000000 0000000 name: "Publish C++ Dependencies for Swift"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish-cpp-swift-deps:
name: "Publish C++ Dependencies for Swift"
runs-on: "ubuntu-24.04"
steps:
- name: Download C++ Dependencies for Swift
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo zeroc-ice/ice --pattern "cpp-swift-deps" --dir staging
- name: Publish C++ Dependencies for Swift
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}"
fi
aws s3 sync staging/cpp-swift-deps/ "s3://zeroc-downloads/${UPLOAD_PATH}/" --exclude "*" --include "*.zip"
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
zeroc-ice-3.8.1/.github/workflows/publish-deb-packages.yml 0000664 0000000 0000000 00000006023 15165676005 0023511 0 ustar 00root root 0000000 0000000 name: "Publish DEB Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
build:
name: "Publish DEB Packages for ${{ matrix.distribution }}"
runs-on: ubuntu-24.04
strategy:
matrix:
include:
- distribution: debian12
- distribution: debian13
- distribution: ubuntu24.04
env:
DISTRIBUTION: ${{ matrix.distribution }}
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Download DEB artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo zeroc-ice/ice --pattern "deb-packages-${DISTRIBUTION}-*" --dir staging
- name: Create DEB repository
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}/${DISTRIBUTION}"
REPO_PATH="ice/${CHANNEL}"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}/${DISTRIBUTION}"
REPO_PATH="ice/${QUALITY}/${CHANNEL}"
fi
echo "Syncing current repository from S3..."
mkdir -p "${UPLOAD_PATH}"
aws s3 sync "s3://zeroc-downloads/${UPLOAD_PATH}" "${UPLOAD_PATH}"
echo "Creating/updating repository with new DEB packages..."
docker run --rm \
-v "$GITHUB_WORKSPACE:/workspace" \
-e GPG_KEY="${GPG_KEY}" \
-e GPG_KEY_ID="${GPG_KEY_ID}" \
ghcr.io/zeroc-ice/deb-repo-builder:${CHANNEL} \
/workspace/ice/packaging/deb/create-deb-repo.sh \
--staging /workspace/staging/ \
--repository "/workspace/${REPO_PATH}" \
--distribution "${DISTRIBUTION}" \
--channel "${CHANNEL}" \
--quality "${QUALITY}"
echo "Uploading updated repository to S3..."
# We add the repo package to --exclude to avoid deleting it, this package is built by
# the build-deb-ice-repo-packages workflow
aws s3 sync \
"${UPLOAD_PATH}" \
"s3://zeroc-downloads/${UPLOAD_PATH}" \
--delete \
--exclude "ice-repo-*.deb"
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
GPG_KEY: ${{ secrets.ICE_3_8_CI_SIGNER_KEY }}
GPG_KEY_ID: ${{ secrets.ICE_3_8_CI_SIGNER_KEY_ID }}
zeroc-ice-3.8.1/.github/workflows/publish-gem-packages.yml 0000664 0000000 0000000 00000005000 15165676005 0023521 0 ustar 00root root 0000000 0000000 name: "Publish GEM Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish:
name: "Publish GEM Packages"
runs-on: ubuntu-24.04
permissions:
id-token: write
contents: read
steps:
- name: Download GEM artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "gem-packages" --dir staging
- name: Publish Nightly GEM Packages
if: ${{ inputs.quality == 'nightly' }}
run: |
for gem in staging/gem-packages/zeroc-ice-*.gem; do
echo "Uploading $(basename "$gem")..."
curl -u "nightly:${NEXUS_NIGHTLY_PASSWORD}" \
--upload-file "$gem" \
--output /dev/null \
--silent \
--retry 3 \
--fail \
--show-error \
"https://download.zeroc.com/nexus/repository/rubygems-${CHANNEL}-${QUALITY}/gems/$(basename "$gem")" \
|| { echo "Gem upload failed for $gem"; exit 1; }
done
env:
NEXUS_NIGHTLY_PASSWORD: ${{ secrets.NEXUS_NIGHTLY_PASSWORD }}
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
- name: Publish Release GEM Packages
if: ${{ inputs.quality == 'stable' }}
run: |
# Get OIDC token from GitHub Actions
OIDC_TOKEN=$(curl -sS -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
"$ACTIONS_ID_TOKEN_REQUEST_URL&audience=rubygems.org" | jq -r '.value')
# Exchange OIDC token for RubyGems API key
GEM_API_KEY=$(curl -sS -X POST "https://rubygems.org/api/v1/oidc/trusted_publisher/exchange_token" \
-H "Content-Type: application/json" \
-d "{\"jwt\": \"$OIDC_TOKEN\"}" | jq -r '.rubygems_api_key')
# Push the gem
GEM_HOST_API_KEY="$GEM_API_KEY" gem push staging/gem-packages/zeroc-ice-*.gem
zeroc-ice-3.8.1/.github/workflows/publish-icegridgui-macos-app.yml 0000664 0000000 0000000 00000003142 15165676005 0025173 0 ustar 00root root 0000000 0000000 name: "Publish IceGridGUI macOS App"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish-icegridgui-macos-app:
name: "Publish IceGridGUI macOS App"
runs-on: "ubuntu-24.04"
steps:
- name: Download IceGridGUI macOS App artifact
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "icegridgui-macos-app" --dir staging
- name: Publish IceGridGUI macOS App
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}"
fi
aws s3 cp staging/icegridgui-macos-app/*.dmg "s3://${S3_DOWNLOADS_BUCKET}/${UPLOAD_PATH}/"
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
S3_DOWNLOADS_BUCKET: ${{ vars.S3_DOWNLOADS_BUCKET }}
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
zeroc-ice-3.8.1/.github/workflows/publish-java-packages.yml 0000664 0000000 0000000 00000004214 15165676005 0023700 0 ustar 00root root 0000000 0000000 name: "Publish Java Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.8, 3.7)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish:
name: "Publish Java Packages"
runs-on: ubuntu-24.04
env:
STAGING_DIR: ${{ github.workspace }}/staging
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Download Java artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "java-packages" --dir "${STAGING_DIR}"
- name: Publish Java Packages
run: packaging/maven/publish-java-release.sh
if: ${{ inputs.quality == 'nightly' }}
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
MAVEN_USERNAME: "nightly"
MAVEN_PASSWORD: ${{ secrets.NEXUS_NIGHTLY_PASSWORD }}
GPG_KEY: ${{ secrets.ICE_CI_SIGNER_KEY }}
GPG_KEY_ID: ${{ secrets.ICE_CI_SIGNER_KEY_ID }}
- name: Publish Java Packages
run: packaging/maven/publish-java-release.sh
if: ${{ inputs.quality == 'stable' }}
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
MAVEN_USERNAME: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
MAVEN_PASSWORD: ${{ secrets.MAVEN_CENTRAL_API_KEY }}
MAVEN_CENTRAL_BEARER_AUTH_TOKEN: ${{ secrets.MAVEN_CENTRAL_BEARER_AUTH_TOKEN }}
GPG_KEY: ${{ secrets.ICE_CI_SIGNER_KEY }}
GPG_KEY_ID: ${{ secrets.ICE_CI_SIGNER_KEY_ID }}
- name: Clean Credentials
if: always()
run: rm -f ~/.m2/settings.xml
zeroc-ice-3.8.1/.github/workflows/publish-matlab-packages.yml 0000664 0000000 0000000 00000004000 15165676005 0024210 0 ustar 00root root 0000000 0000000 name: "Publish MATLAB Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish-matlab-packages:
name: "Publish MATLAB Packages"
runs-on: "ubuntu-24.04"
steps:
- name: Download MATLAB artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo zeroc-ice/ice --pattern "matlab-packages-*" --dir staging
- name: Publish MATLAB Packages
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}"
aws s3 cp staging/matlab-packages-windows-*/ice-*-win.mltbx "s3://zeroc-downloads/${UPLOAD_PATH}/"
aws s3 cp staging/matlab-packages-ubuntu-*/ice-*-linux.mltbx "s3://zeroc-downloads/${UPLOAD_PATH}/"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}"
# Rename the Toolbox files to ice-nightly-R2025b-.mltbx if it's the nightly channel
aws s3 cp staging/matlab-packages-windows-*/ice-*-R2025b-win.mltbx "s3://zeroc-downloads/${UPLOAD_PATH}/ice-${QUALITY}-R2025b-win.mltbx"
aws s3 cp staging/matlab-packages-ubuntu-*/ice-*-R2025b-linux.mltbx "s3://zeroc-downloads/${UPLOAD_PATH}/ice-${QUALITY}-R2025b-linux.mltbx"
fi
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
zeroc-ice-3.8.1/.github/workflows/publish-npm-packages.yml 0000664 0000000 0000000 00000004465 15165676005 0023561 0 ustar 00root root 0000000 0000000 name: "Publish NPM Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish:
name: "Publish NPM Packages"
runs-on: ubuntu-24.04
permissions:
id-token: write
contents: read
steps:
- name: Download NPM artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "js-npm-packages" --dir staging
- name: Publish Nightly NPM Packages
if: ${{ inputs.quality != 'stable' }}
run: |
REPOSITORY_PREFIX="//download.zeroc.com/nexus/repository/npm-${CHANNEL}-${QUALITY}/"
# Reference the env var in .npmrc using \$ so NPM reads it at publish time
echo "${REPOSITORY_PREFIX}:_auth=\${NEXUS_NIGHTLY_NPM_AUTH_TOKEN}" > ~/.npmrc
echo "always-auth=true" >> ~/.npmrc
mapfile -t packages < <(find staging -type f -name "*.tgz")
for pkg in "${packages[@]}"; do
echo "Publishing package: $pkg"
npm publish "$pkg" --registry "https:${REPOSITORY_PREFIX}"
done
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
NEXUS_NIGHTLY_NPM_AUTH_TOKEN: ${{ secrets.NEXUS_NIGHTLY_NPM_AUTH_TOKEN }}
- uses: actions/setup-node@v4
if: ${{ inputs.quality == 'stable' }}
with:
node-version: '22'
registry-url: 'https://registry.npmjs.org'
- name: Publish Release NPM Packages
if: ${{ inputs.quality == 'stable' }}
run: |
mapfile -t packages < <(find staging -type f -name "*.tgz")
for pkg in "${packages[@]}"; do
echo "Publishing package: $pkg"
npm publish "$pkg" --provenance
done
zeroc-ice-3.8.1/.github/workflows/publish-nuget-packages.yml 0000664 0000000 0000000 00000004162 15165676005 0024103 0 ustar 00root root 0000000 0000000 name: "Publish NuGet Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish:
name: "Publish NuGet Packages"
runs-on: ubuntu-24.04
steps:
- name: Download NuGet artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "*-nuget-packages" --dir staging
- name: Publish NuGet Packages
run: |
case "$QUALITY" in
"stable")
SOURCE_URL="https://api.nuget.org/v3/index.json"
NUGET_API_KEY="${RELEASE_NUGET_API_KEY}"
;;
*)
SOURCE_URL="https://download.zeroc.com/nexus/repository/nuget-${CHANNEL}-${QUALITY}/"
NUGET_API_KEY="${NEXUS_NIGHTLY_NUGET_API_KEY}"
;;
esac
# Collect all packages. The symbol package ".snupkg" files are published automatically with the main package
# no need to push them separately.
mapfile -t packages < <(find staging -type f -name "*.nupkg")
# Push each package to the appropriate NuGet repository
for package in "${packages[@]}"; do
echo "Publishing package: $package"
dotnet nuget push "$package" --source "$SOURCE_URL" --api-key "$NUGET_API_KEY"
done
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
NEXUS_NIGHTLY_NUGET_API_KEY: ${{ secrets.NEXUS_NIGHTLY_NUGET_API_KEY }}
RELEASE_NUGET_API_KEY: ${{ secrets.RELEASE_NUGET_API_KEY }}
zeroc-ice-3.8.1/.github/workflows/publish-pip-packages.yml 0000664 0000000 0000000 00000004316 15165676005 0023552 0 ustar 00root root 0000000 0000000 name: "Publish PIP Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish:
name: "Publish Python PIP Packages"
runs-on: ubuntu-24.04
steps:
- name: Download PIP artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "pip-sdist" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "pip-packages-*" --dir staging
- name: Publish PIP Package
run: |
case "$QUALITY" in
"stable")
REPOSITORY_URL="https://upload.pypi.org/legacy/"
export TWINE_USERNAME="__token__"
export TWINE_PASSWORD="${RELEASE_PYPI_AUTH_TOKEN}"
;;
*)
REPOSITORY_URL="https://download.zeroc.com/nexus/repository/pypi-${CHANNEL}-${QUALITY}/"
export TWINE_USERNAME="nightly"
export TWINE_PASSWORD="${NEXUS_NIGHTLY_PASSWORD}"
;;
esac
mkdir -p dist
# Collect all matching package files into dist/
find staging -name 'zeroc_ice-*' -type f -exec cp -vf {} dist/ \;
# Upload using Twine in a fresh venv
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip twine
twine upload --verbose --repository-url "${REPOSITORY_URL}" dist/*
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
NEXUS_NIGHTLY_PASSWORD: ${{ secrets.NEXUS_NIGHTLY_PASSWORD }}
RELEASE_PYPI_AUTH_TOKEN: ${{ secrets.RELEASE_PYPI_AUTH_TOKEN }}
zeroc-ice-3.8.1/.github/workflows/publish-release.yml 0000664 0000000 0000000 00000013265 15165676005 0022631 0 ustar 00root root 0000000 0000000 name: "Publish Ice Release"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The GitHub run ID to use for artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish-brew-packages:
uses: ./.github/workflows/publish-brew-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-deb-packages:
uses: ./.github/workflows/publish-deb-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-gem-packages:
uses: ./.github/workflows/publish-gem-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-matlab-packages:
uses: ./.github/workflows/publish-matlab-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-java-packages:
uses: ./.github/workflows/publish-java-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-slice-tools-packages:
uses: ./.github/workflows/publish-slice-tools-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-windows-installer:
uses: ./.github/workflows/publish-windows-installer.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-icegridgui-macos-app:
uses: ./.github/workflows/publish-icegridgui-macos-app.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-npm-packages:
uses: ./.github/workflows/publish-npm-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-nuget-packages:
uses: ./.github/workflows/publish-nuget-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-pip-packages:
uses: ./.github/workflows/publish-pip-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-rpm-packages:
uses: ./.github/workflows/publish-rpm-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-swift-packages:
uses: ./.github/workflows/publish-swift-packages.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-cpp-swift-deps:
uses: ./.github/workflows/publish-cpp-swift-deps.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
publish-symbols-sources:
uses: ./.github/workflows/publish-symbols-sources.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
# Gate job that waits for all publish jobs to complete.
# Other jobs can depend on this instead of listing all publish jobs individually.
publish-all:
runs-on: ubuntu-24.04
needs:
- publish-brew-packages
- publish-deb-packages
- publish-gem-packages
- publish-matlab-packages
- publish-java-packages
- publish-slice-tools-packages
- publish-windows-installer
- publish-icegridgui-macos-app
- publish-npm-packages
- publish-nuget-packages
- publish-pip-packages
- publish-rpm-packages
- publish-swift-packages
- publish-cpp-swift-deps
- publish-symbols-sources
steps:
- run: echo "All publish jobs completed successfully"
invalidate-cloudfront-cache:
runs-on: ubuntu-24.04
needs: publish-all
steps:
- name: Invalidate CloudFront Cache
run: |
if [ "${{ inputs.quality }}" = "stable" ]; then
INVALIDATION_PATH="/ice/${{ inputs.channel }}/*"
else
INVALIDATION_PATH="/ice/${{ inputs.quality }}/${{ inputs.channel }}/*"
fi
aws cloudfront create-invalidation \
--distribution-id ${{ vars.CLOUDFRONT_DISTRIBUTION_ID }} \
--paths "${INVALIDATION_PATH}"
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
upload-release-assets:
# For stable channels if running on a tag, we upload the release assets to the tag.
if: ${{ inputs.quality == 'stable' && startsWith(github.ref, 'refs/tags/') }}
needs: publish-all
uses: ./.github/workflows/upload-release-assets.yml
with:
channel: ${{ inputs.channel }}
quality: ${{ inputs.quality }}
run_id: ${{ inputs.run_id }}
secrets: inherit
zeroc-ice-3.8.1/.github/workflows/publish-rpm-packages.yml 0000664 0000000 0000000 00000007407 15165676005 0023564 0 ustar 00root root 0000000 0000000 name: "Publish RPM Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
build:
name: "Publish RPM Packages for ${{ matrix.distribution }}"
runs-on: 'ubuntu-24.04'
strategy:
matrix:
include:
- distribution: el9
- distribution: el10
- distribution: amzn2023
env:
DISTRIBUTION: ${{ matrix.distribution }}
CHANNEL: ${{ inputs.channel }}
MCPP_VERSION: v2.7.2.20
steps:
- name: Check out repository
uses: actions/checkout@v4
with:
path: ice
- name: Download RPM artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
# Download RPM artifacts from the specified run.
echo "Downloading Ice RPMs from current run..."
gh run download "$RUN_ID" \
--repo zeroc-ice/ice \
--pattern "rpm-packages-${DISTRIBUTION}-*" \
--dir staging
# If building for RHEL 9 or 10, also download MCPP RPMs.
if [[ "$DISTRIBUTION" == "el9" || "$DISTRIBUTION" == "el10" ]]; then
echo "Also downloading MCPP RPMs for $DISTRIBUTION..."
# MCPP packages
MCPP_PACKAGES="rpm-packages-3.8-${DISTRIBUTION}-*"
gh release download "$MCPP_VERSION" \
--repo zeroc-ice/mcpp \
--pattern "$MCPP_PACKAGES" \
--dir staging/mcpp
# gh doesn't automatically extract release downloads
pushd staging/mcpp > /dev/null
for zip in ${MCPP_PACKAGES}.zip; do unzip -q "$zip"; done
popd > /dev/null
fi
- name: Create RPM repository
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}/${DISTRIBUTION}"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}/${DISTRIBUTION}"
fi
echo "Syncing current repository from S3..."
mkdir -p "${DISTRIBUTION}"
aws s3 sync "s3://zeroc-downloads/${UPLOAD_PATH}" "${DISTRIBUTION}"
echo "Creating/updating repository with new RPMs..."
docker_args=(
--rm
-v "$GITHUB_WORKSPACE:/workspace"
-e GPG_KEY="${GPG_KEY}"
-e GPG_KEY_ID="${GPG_KEY_ID}"
ghcr.io/zeroc-ice/rpm-repo-builder:${CHANNEL}
)
docker run "${docker_args[@]}" /workspace/ice/packaging/rpm/create-rpm-repo.sh \
--staging /workspace/staging/ \
--repository "/workspace/${DISTRIBUTION}"
echo "Uploading updated repository to S3..."
# We add the repo package to --exclude to avoid deleting it, this package is built by
# the build-rpm-ice-repo-packages workflow
aws s3 sync \
"${DISTRIBUTION}" \
"s3://zeroc-downloads/${UPLOAD_PATH}" \
--delete \
--exclude "ice-repo-*.noarch.rpm"
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
GPG_KEY: ${{ secrets.ICE_3_8_CI_SIGNER_KEY }}
GPG_KEY_ID: ${{ secrets.ICE_3_8_CI_SIGNER_KEY_ID }}
zeroc-ice-3.8.1/.github/workflows/publish-slice-tools-packages.yml 0000664 0000000 0000000 00000004003 15165676005 0025210 0 ustar 00root root 0000000 0000000 name: "Publish Slice Tools Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish:
name: "Publish Slice Tools Packages"
runs-on: ubuntu-24.04
env:
STAGING_DIR: ${{ github.workspace }}/staging
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Download Slice Tools artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "slice-tools-packages" --dir "${STAGING_DIR}"
- name: Publish Slice Tools Packages
run: packaging/maven/publish-slice-tools-release.sh
if: ${{ inputs.quality == 'nightly' }}
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
MAVEN_USERNAME: "nightly"
MAVEN_PASSWORD: ${{ secrets.NEXUS_NIGHTLY_PASSWORD }}
GPG_KEY: ${{ secrets.ICE_CI_SIGNER_KEY }}
GPG_KEY_ID: ${{ secrets.ICE_CI_SIGNER_KEY_ID }}
- name: Publish Slice Tools Packages
run: packaging/maven/publish-slice-tools-release.sh
if: ${{ inputs.quality == 'stable' }}
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
GRADLE_PUBLISH_KEY: ${{ secrets.GRADLE_PUBLISH_KEY }}
GRADLE_PUBLISH_SECRET: ${{ secrets.GRADLE_PUBLISH_SECRET }}
- name: Clean Credentials
if: always()
run: rm -f ~/.m2/settings.xml
zeroc-ice-3.8.1/.github/workflows/publish-swift-packages.yml 0000664 0000000 0000000 00000002751 15165676005 0024117 0 ustar 00root root 0000000 0000000 name: "Publish Swift Packages"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish-swift-packages:
name: "Publish Swift Packages"
runs-on: macos-26
# Stable Swift releases must be published manually.
if: ${{ inputs.quality == 'nightly' }}
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Download C++ Dependencies for Swift
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo zeroc-ice/ice --pattern "cpp-swift-deps" --dir staging
- name: Create ice-swift repository
run: ./update-ice-swift-nightly.sh
working-directory: packaging/swift
env:
ICE_NIGHTLY_PUBLISH_TOKEN: ${{ secrets.ICE_NIGHTLY_PUBLISH_TOKEN }}
STAGING_DIR: ${{ github.workspace }}/staging/cpp-swift-deps
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
zeroc-ice-3.8.1/.github/workflows/publish-symbols-sources.yml 0000664 0000000 0000000 00000010433 15165676005 0024354 0 ustar 00root root 0000000 0000000 name: "Publish Symbols and Sources"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
# Non-stable releases (nightly, RC) - simple sync to quality-specific paths
publish-symbols-sources-nightly:
name: "Publish Symbols and Sources (Non-Stable)"
if: ${{ inputs.quality != 'stable' }}
runs-on: ubuntu-24.04
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
steps:
- name: Download Symbols and Sources artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh run download "${{ inputs.run_id }}" --repo zeroc-ice/ice --pattern "windows-symbols-sources" --dir staging
- name: Publish Symbols and Sources
run: |
# Non-stable only, so path is always ice/${QUALITY}/${CHANNEL}
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}"
# Upload sources to S3 (version is already in the directory structure)
aws s3 sync "staging/windows-symbols-sources/sources/" "s3://zeroc-downloads/${UPLOAD_PATH}/sources/"
# Upload symbol store to S3
aws s3 sync "staging/windows-symbols-sources/symbols/" "s3://zeroc-downloads/${UPLOAD_PATH}/symbols/"
env:
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
# Stable releases - incremental update to shared symbol store with proper 000admin handling
# Downloads existing 000admin, uses symstore add to create proper transaction, uploads result
publish-symbols-sources-stable:
name: "Publish Symbols and Sources (Stable)"
if: ${{ inputs.quality == 'stable' }}
runs-on: windows-2022
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
S3_BUCKET: ${{ vars.S3_SYMBOLS_BUCKET }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Install Windows Debug Tools
uses: ./.github/actions/install-windows-debug-tools
- name: Download Symbols and Sources artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh run download "${{ inputs.run_id }}" --repo zeroc-ice/ice --pattern "windows-symbols-sources" --dir staging
- name: Read version from config
id: version
run: |
source ./config/version.env
echo "ice_version=${BASE_VERSION}" >> $GITHUB_OUTPUT
shell: bash
- name: Download existing 000admin from S3
run: |
New-Item -ItemType Directory -Force -Path symbol-store
# Download existing 000admin from stable symbol store
aws s3 sync "s3://${{ env.S3_BUCKET }}/symstore/000admin/" "symbol-store/000admin/"
if (-not (Test-Path "symbol-store/000admin/history.txt")) {
Write-Error "No existing 000admin found in stable symbol store - this should not happen"
exit 1
}
Write-Host "Downloaded existing 000admin"
shell: pwsh
- name: Add symbols to store using symstore
run: |
# Add all PDBs in a single transaction
# symstore /r recursively finds all PDBs under the staging directory
symstore add /3 /compress /r `
/t "Ice" `
/v "${{ steps.version.outputs.ice_version }}" `
/s ${{ github.workspace }}/symbol-store `
/f "${{ github.workspace }}/staging"
shell: pwsh
- name: Publish Symbols and Sources to S3
run: |
# Upload sources to S3
aws s3 sync "staging/windows-symbols-sources/sources/" "s3://${{ env.S3_BUCKET }}/sources/ice/"
# Sync the entire symbol store including 000admin
aws s3 sync "symbol-store/" "s3://${{ env.S3_BUCKET }}/symstore/"
shell: pwsh
zeroc-ice-3.8.1/.github/workflows/publish-windows-installer.yml 0000664 0000000 0000000 00000006256 15165676005 0024700 0 ustar 00root root 0000000 0000000 name: "Publish Windows Installer"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The run ID to use for downloading artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
publish-windows-installer:
name: "Publish Windows Installer"
runs-on: "ubuntu-24.04"
steps:
- name: Download installer artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "windows-installer" --dir staging
- name: Publish Installer Packages
run: |
if [ "${QUALITY}" = "stable" ]; then
UPLOAD_PATH="ice/${CHANNEL}"
aws s3 cp staging/windows-installer/*.exe "s3://${S3_DOWNLOADS_BUCKET}/${UPLOAD_PATH}/"
else
UPLOAD_PATH="ice/${QUALITY}/${CHANNEL}"
# Rename the installer for non-stable releases to include the quality in the filename
aws s3 cp staging/windows-installer/*.exe "s3://${S3_DOWNLOADS_BUCKET}/${UPLOAD_PATH}/Ice-Services-${QUALITY}.exe"
fi
env:
AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
S3_DOWNLOADS_BUCKET: ${{ vars.S3_DOWNLOADS_BUCKET }}
CHANNEL: ${{ inputs.channel }}
QUALITY: ${{ inputs.quality }}
publish-winget:
name: "Publish to WinGet"
if: ${{ inputs.quality == 'stable' }}
continue-on-error: true
needs: publish-windows-installer
runs-on: windows-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Load version
run: |
source ./config/version.env
echo "BASE_VERSION=${BASE_VERSION}" >> $GITHUB_ENV
shell: bash
- name: Download installer artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh run download "${{ inputs.run_id }}" --repo ${{ github.repository }} --pattern "windows-installer" --dir staging
- name: Submit to WinGet
env:
CHANNEL: ${{ inputs.channel }}
WINGET_PAT: ${{ secrets.WINGET_GITHUB_PAT }}
run: |
$exeFile = Get-ChildItem staging/windows-installer/*.exe | Select-Object -First 1
$downloadUrl = "https://download.zeroc.com/ice/${env:CHANNEL}/$($exeFile.Name)"
Write-Host "Download URL: $downloadUrl"
Write-Host "Version: $env:BASE_VERSION"
Invoke-WebRequest https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
.\wingetcreate.exe update ZeroC.IceServices `
--urls $downloadUrl `
--version $env:BASE_VERSION `
--submit `
--token $env:WINGET_PAT
shell: pwsh
zeroc-ice-3.8.1/.github/workflows/python.yml 0000664 0000000 0000000 00000002341 15165676005 0021057 0 ustar 00root root 0000000 0000000 name: Python
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
ruff:
name: Ruff
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install Ruff
run: pip install ruff
- name: Ruff check
run: ruff check . --ignore E402
- name: Ruff format
run: ruff format . --check --diff
pyright:
name: Pyright
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install the latest version of uv
uses: astral-sh/setup-uv@v7
- name: Install Python dependencies
working-directory: python
run: uv sync --group dev
- name: Build Ice for Python
run: |
make -C cpp srcs
make -C python
- name: Pyright check
working-directory: python
run: |
uv run pyright .
zeroc-ice-3.8.1/.github/workflows/swift.yml 0000664 0000000 0000000 00000001572 15165676005 0020677 0 ustar 00root root 0000000 0000000 name: Swift
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
swift-format:
name: Swift format and lint
runs-on: ubuntu-24.04
container:
image: swift
volumes:
- ${{ github.workspace }}:${{ github.workspace }}
steps:
- name: Checkout repository
uses: actions/checkout@v4
# https://github.com/actions/runner/issues/2033
- name: Set safe directory
run: |
git config --global --add safe.directory /__w/ice/ice
- name: swift-format Format
run: |
swift format . --recursive --in-place --configuration .swift-format.json
git diff --exit-code
- name: swift-format Lint
run: swift format lint . --recursive --strict --configuration .swift-format.json
zeroc-ice-3.8.1/.github/workflows/test-pip-package.yml 0000664 0000000 0000000 00000006071 15165676005 0022700 0 ustar 00root root 0000000 0000000 name: "Test PIP Package"
on:
workflow_dispatch:
push:
branches: ["main"]
paths:
- "python/**"
- "slice/**"
- ".github/actions/setup-cpp/**"
- ".github/actions/setup-python/**"
pull_request:
branches: ["main"]
paths:
- "python/**"
- "slice/**"
- ".github/actions/setup-cpp/**"
- ".github/actions/setup-python/**"
jobs:
build-sdist:
runs-on: ubuntu-24.04
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Install Build Dependencies
run: |
python -m pip install --upgrade pip
python -m pip install build
- name: Build Source Distribution
working-directory: python
run: python -m build --sdist
- name: Upload sdist
uses: actions/upload-artifact@v4
with:
name: sdist
path: python/dist/zeroc_ice-*.tar.gz
test-pip-package:
needs: build-sdist
strategy:
fail-fast: false
matrix:
os: [ubuntu-24.04, macos-26, windows-2022]
runs-on: ${{ matrix.os }}
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Setup C++
uses: ./.github/actions/setup-cpp
with:
profile: pip-bdist
- name: Setup Python
uses: ./.github/actions/setup-python
- name: Download sdist
uses: actions/download-artifact@v4
with:
name: sdist
path: sdist
- name: Build Wheel from sdist (Unix)
if: runner.os != 'Windows'
run: |
python -m pip install --upgrade pip
pip wheel sdist/*.tar.gz --no-deps -w dist/
- name: Build Wheel from sdist (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: |
python -m pip install --upgrade pip
pip wheel (Get-ChildItem sdist\*.tar.gz).FullName --no-deps -w dist/
- name: Create Test Virtual Environment
run: python -m venv test-venv
- name: Install Package (Unix)
if: runner.os != 'Windows'
run: |
source test-venv/bin/activate
pip install dist/*.whl
pip install cryptography
- name: Install Package (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: |
test-venv\Scripts\Activate.ps1
pip install (Get-ChildItem dist\*.whl).FullName
pip install cryptography
- name: Run Tests (Unix)
if: runner.os != 'Windows'
working-directory: python
run: |
source ../test-venv/bin/activate
python allTests.py --load-slice --pip-package --rfilter="Glacier2|IceGrid|IceBox|IceMX"
- name: Run Tests (Windows)
if: runner.os == 'Windows'
working-directory: python
shell: pwsh
run: |
..\test-venv\Scripts\Activate.ps1
python allTests.py --load-slice --pip-package --rfilter="Glacier2|IceGrid|IceBox|IceMX"
zeroc-ice-3.8.1/.github/workflows/upload-release-assets.yml 0000664 0000000 0000000 00000007700 15165676005 0023744 0 ustar 00root root 0000000 0000000 name: "Upload Release Assets"
on:
workflow_dispatch:
inputs:
channel:
description: "The release channel (e.g., 3.9, 3.8)"
required: true
quality:
description: "Release quality (e.g., stable, nightly, RC)"
required: true
default: "nightly"
run_id:
description: "The GitHub run ID to use for artifacts"
required: true
workflow_call:
inputs:
channel:
required: true
type: string
quality:
required: true
type: string
run_id:
required: true
type: string
jobs:
upload-release-assets:
# For stable channels if running on a tag, we upload the release assets to the tag.
if: ${{ inputs.quality == 'stable' && startsWith(github.ref, 'refs/tags/') }}
runs-on: ubuntu-24.04
steps:
- name: Ensure tag matches channel
run: |
case "${GITHUB_REF}" in
refs/tags/v${{ inputs.channel }}*)
echo "Tag matches channel"
;;
*)
echo "⌠Tag '${GITHUB_REF}' does not match channel '${{ inputs.channel }}'"
exit 1
;;
esac
- name: Checkout repository
uses: actions/checkout@v4
- name: Download artifacts
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RUN_ID: ${{ inputs.run_id }}
run: |
set -euo pipefail
mkdir -p staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "deb-packages-*" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "dotnet-nuget-packages" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "gem-packages" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "cpp-swift-deps" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "matlab-packages-*" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "windows-installer" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "java-packages" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "slice-tools-packages" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "js-npm-packages" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "pip-sdist" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "pip-packages-*" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "rpm-packages-*" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "icegridgui-jar-Windows" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "icegridgui-jar-macOS" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "icegridgui-macos-app" --dir staging
gh run download "$RUN_ID" --repo ${{ github.repository }} --pattern "windows-symbols-sources" --dir staging
- name: Prepare Release Assets
run: ./packaging/release/prepare-release-assets.sh
env:
STAGING_DIR: ${{ github.workspace }}/staging
- name: Upload Release Assets
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
set -euo pipefail
TAG="${GITHUB_REF#refs/tags/}"
TITLE="Ice ${TAG}"
# Check if the release already exists
if ! gh release view "$TAG" &>/dev/null; then
echo "Creating draft release for $TAG..."
gh release create "$TAG" --title "$TITLE" --notes "" --draft
fi
# Upload artifacts to the release
echo "Uploading artifacts to release $TAG..."
gh release upload "$TAG" release/* --clobber
zeroc-ice-3.8.1/.github/workflows/whitespace.yml 0000664 0000000 0000000 00000001004 15165676005 0021665 0 ustar 00root root 0000000 0000000 name: Whitespace
on:
workflow_dispatch:
push:
branches: ["3.8"]
pull_request:
# The branches below must be a subset of the branches above
branches: ["3.8"]
jobs:
whitespace-validation:
name: Validate trailing whitespace and consecutive empty lines
runs-on: ubuntu-24.04
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Run whitespace validation
uses: zeroc-ice/github-actions/@main
with:
whitespace_patterns: "'*'"
zeroc-ice-3.8.1/.gitignore 0000664 0000000 0000000 00000003731 15165676005 0015412 0 ustar 00root root 0000000 0000000 # Ignore objects and archives.
*.aps
*.[oa]
*.obj
*.dll
*.ilk
*.so
*.so.*
*.sl
*.dylib
*.pyc
*.class
*.exe
*.mdb
*.pdb
*.tds
*.bak
*.ncb
# .sdf is the Visual Studio 2010 equivalent to .ncb
*.sdf
# .VC.db is is the new IntelliSense database, it replaces the old .sdf
*.VC.db
# Visual Studio Hosting process configuration files
*.vshost.exe.*
*.opt
*.user
*.res
*.exp
.gdb_history
.DS_Store
*#
.#*
*~
*.lib
*.idb
*.suo
*.xap
core.*
tmp_*.xml
obj
*.RES
ClientBin
vcproj
.metadata
# VIM swap file
*.swp
.keychain
# Eclipse
.externalToolBuilders
# macOS Keychain
*.keychain
.fl????????
passwords
# Makefile Build System
build
!.github/actions/build
!.github/workflows/build*
generated
.depend
# MSBuild Build System
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
!.github/workflows/release
!packaging/release
# Visual Studio
*.opendb
# Visual Studio 2015 cache/options directory
.vs/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
# SliceCompile dependency files
SliceCompile.d
xcuserdata
xcshareddata
/sdk
# SliceCompile build log
SliceCompile.command.*.log
# Nuget packages
**/msbuild/packages/*
*.nupkg
**/netstandard2.0/netstandard2.0/*
**/netstandard2.0/netcoreapp3.*/*
AppPackages
BundleArtifacts
csharp/AppX
*.deps.json
*.runtimeconfig.dev.json
*.runtimeconfig.json
cpp/AppX
cpp/test/Slice/errorDetection/tmp
# iOS builds
**/objs-*/
**/build-*/
.classpath
.project
.settings
*.dep
# Android Tets
**/android/**/raw/*.p12
# Log files generated by the test suite.
*.log
# Top level log dir where we store simulator logs
/logs
# Clang's compilation database file
compile_commands.json
# Python Formatter cache
.ruff_cache
# Python venv
.venv
# SPM build artifacts
.build
.swiftpm
# LLVM Code Coverage maps
*.profraw
*.profdata
packaging/msi/staging
*.binlog
*.tar.gz
.kotlin
zeroc-ice-3.8.1/.lychee.toml 0000664 0000000 0000000 00000002311 15165676005 0015637 0 ustar 00root root 0000000 0000000 # Lychee link checker configuration
# https://lychee.cli.rs/
# Maximum number of concurrent requests
max_concurrency = 32
# Minimum interval between requests to the same host
host_request_interval = "50ms"
# Timeout for each request in seconds
timeout = 30
# Number of retries for failed requests
max_retries = 3
# User agent string
user_agent = "Mozilla/5.0 (compatible; lychee/0.15; +https://github.com/lycheeverse/lychee)"
# Exclude patterns
exclude = [
# Localhost and local files
"^file://",
"^https?://localhost",
"^https?://127\\.0\\.0\\.1",
# Example domains
"^https?://example\\.com",
# Mail links
"^mailto:",
# GitHub edit/blame links (may require auth)
"github\\.com/.*/edit/",
"github\\.com/.*/blame/",
# Gitter (no longer used)
"^https?://gitter\\.im",
# npm returns 403 to bots
"^https?://www\\.npmjs\\.com",
# Symbol server
"^https?://symbols\\.zeroc\\.com",
]
# Exclude paths from being checked
exclude_path = [
"cpp/doxygen",
"doxygen",
"js/packages/test/Common/controller.html",
]
# Accept these status codes as valid
accept = [200, 204, 206, 301, 308]
# Include fragments (anchors) in checks
include_fragments = true
zeroc-ice-3.8.1/.mailmap 0000664 0000000 0000000 00000000134 15165676005 0015035 0 ustar 00root root 0000000 0000000
Benoit Foucher bentoi
zeroc-ice-3.8.1/.markdownlint.json 0000664 0000000 0000000 00000000126 15165676005 0017077 0 ustar 00root root 0000000 0000000 {
"no-duplicate-heading": {
"siblings_only": true
},
"line-length": false
}
zeroc-ice-3.8.1/.spi.yml 0000664 0000000 0000000 00000000302 15165676005 0015005 0 ustar 00root root 0000000 0000000 # See https://swiftpackageindex.com/swiftpackageindex/spimanifest/1.11.0/documentation/spimanifest
version: 1
builder:
configs:
- documentation_targets: [Ice, Glacier2, IceGrid, IceStorm]
zeroc-ice-3.8.1/.swift-format.json 0000664 0000000 0000000 00000005043 15165676005 0017013 0 ustar 00root root 0000000 0000000 {
"fileScopedDeclarationPrivacy": {
"accessLevel": "private"
},
"indentation": {
"spaces": 4
},
"indentConditionalCompilationBlocks": true,
"indentSwitchCaseLabels": false,
"lineBreakAroundMultilineExpressionChainComponents": false,
"lineBreakBeforeControlFlowKeywords": false,
"lineBreakBeforeEachArgument": false,
"lineBreakBeforeEachGenericRequirement": false,
"lineLength": 120,
"maximumBlankLines": 1,
"multiElementCollectionTrailingCommas": true,
"noAssignmentInExpressions": {
"allowedFunctions": [
"XCTAssertNoThrow"
]
},
"prioritizeKeepingFunctionOutputTogether": false,
"respectsExistingLineBreaks": true,
"rules": {
"AllPublicDeclarationsHaveDocumentation": false,
"AlwaysUseLiteralForEmptyCollectionInit": false,
"AlwaysUseLowerCamelCase": false,
"AmbiguousTrailingClosureOverload": true,
"BeginDocumentationCommentWithOneLineSummary": false,
"DoNotUseSemicolons": true,
"DontRepeatTypeInStaticProperties": true,
"FileScopedDeclarationPrivacy": true,
"FullyIndirectEnum": true,
"GroupNumericLiterals": true,
"IdentifiersMustBeASCII": true,
"NeverForceUnwrap": false,
"NeverUseForceTry": false,
"NeverUseImplicitlyUnwrappedOptionals": false,
"NoAccessLevelOnExtensionDeclaration": true,
"NoAssignmentInExpressions": true,
"NoBlockComments": true,
"NoCasesWithOnlyFallthrough": true,
"NoEmptyTrailingClosureParentheses": true,
"NoLabelsInCasePatterns": true,
"NoLeadingUnderscores": false,
"NoParensAroundConditions": true,
"NoPlaygroundLiterals": true,
"NoVoidReturnOnFunctionSignature": true,
"OmitExplicitReturns": false,
"OneCasePerLine": true,
"OneVariableDeclarationPerLine": true,
"OnlyOneTrailingClosureArgument": true,
"OrderedImports": true,
"ReplaceForEachWithForLoop": true,
"ReturnVoidInsteadOfEmptyTuple": true,
"TypeNamesShouldBeCapitalized": true,
"UseEarlyExits": false,
"UseLetInEveryBoundCaseVariable": true,
"UseShorthandTypeNames": true,
"UseSingleLinePropertyGetter": true,
"UseSynthesizedInitializer": true,
"UseTripleSlashForDocumentationComments": true,
"UseWhereClausesInForLoops": false,
"ValidateDocumentationComments": false
},
"spacesAroundRangeFormationOperators": false,
"tabWidth": 8,
"version": 1
}
zeroc-ice-3.8.1/.vscode/ 0000775 0000000 0000000 00000000000 15165676005 0014757 5 ustar 00root root 0000000 0000000 zeroc-ice-3.8.1/.vscode/cspell.json 0000664 0000000 0000000 00000002064 15165676005 0017136 0 ustar 00root root 0000000 0000000 {
"version": "0.2",
"language": "en",
"words": [
"apos",
"autoreleasepool",
"Blobject",
"Browsable",
"cacerts",
"datagram",
"datagrams",
"decoratee",
"demangled",
"demangles",
"docfx",
"DTLS",
"finalizer",
"finalizers",
"icegrid",
"icegridadmin",
"icegridnode",
"icestorm",
"istr",
"jgoodies",
"LMDB",
"nohup",
"nullopt",
"oneway",
"ostr",
"PKCS",
"Postamble",
"reloadable",
"RFCOMM",
"slnx",
"soversion",
"Stringifier",
"Syscall",
"Truststore",
"twoway",
"unmarshal",
"unmarshaling",
"unmarshals",
"unregisters",
"upcall",
"upcalls",
"zeroc"
],
"flagWords": [
"wether"
],
"dictionaries": [
"csharp",
"softwareTerms",
"en_US"
],
"enableFiletypes": [
"ice"
]
}
zeroc-ice-3.8.1/.vscode/extensions.json 0000664 0000000 0000000 00000000133 15165676005 0020046 0 ustar 00root root 0000000 0000000 {
"recommendations": [
"ZeroCInc.slice",
"charliermarsh.ruff",
]
}
zeroc-ice-3.8.1/.vscode/launch.json 0000664 0000000 0000000 00000001273 15165676005 0017127 0 ustar 00root root 0000000 0000000 {
"configurations": [
{
"type": "swift",
"request": "launch",
"args": [],
"cwd": "${workspaceFolder:ice}",
"name": "Debug slice2swift",
"target": "slice2swift",
"configuration": "debug",
"preLaunchTask": "swift: Build Debug slice2swift"
},
{
"type": "swift",
"request": "launch",
"args": [],
"cwd": "${workspaceFolder:ice}",
"name": "Release slice2swift",
"target": "slice2swift",
"configuration": "release",
"preLaunchTask": "swift: Build Release slice2swift"
}
]
}
zeroc-ice-3.8.1/.vscode/settings.json 0000664 0000000 0000000 00000000572 15165676005 0017516 0 ustar 00root root 0000000 0000000 {
"C_Cpp.autoAddFileAssociations": false,
"files.associations": {
"Make.*": "makefile"
},
"C_Cpp.default.cppStandard": "c++20",
"[java]": {
"editor.formatOnSave": false
},
"[swift]": {
"editor.formatOnSave": false
},
"[xml]": {
"editor.formatOnSave": false
},
"markdown.extension.toc.levels": "1..4"
}
zeroc-ice-3.8.1/BLUETOOTH.md 0000664 0000000 0000000 00000006275 15165676005 0015317 0 ustar 00root root 0000000 0000000 # Bluetooth Testing Guide
This document describes how to run the Ice test suite over Bluetooth connections between different language mappings.
## Prerequisites
- C++ and Java source builds, refer to the [cpp/BUILDING.md] and [java/BUILDING.md] for details
- An Android device with Bluetooth capability
- The [Android test controller] application installed and running on the device
- Bluetooth adapters on both client and server machines
- Paired Bluetooth devices (the Android device and the machine running the C++ tests)
## Run C++ Client Against Android Server Over Bluetooth
First, start the Android test controller application on your device.
From the `java` directory, start the Python controller to manage the Android server:
```bash
python ../scripts/Controller.py --host-bt="A4:FF:9F:A6:48:C1" --host=192.168.1.51 --id=server --android
```
Where:
- `--host-bt` is the Bluetooth address of the Android device running the server
- `--host` is the IP address of the Android device running the server
- `--id=server` identifies this controller as managing servers
- `--android` indicates this is controlling an Android device
Then from the `cpp` directory, start the C++ test suite to run against the Android servers:
```bash
python ./allTests.py --server=server --protocol=bt --cross=java
```
Where:
- `--server=server` indicates to use the remote server controller
- `--protocol=bt` specifies to use Bluetooth transport, use `--protocol=bts` to test Bluetooth over SSL
- `--cross=java` indicates cross-language testing with Java servers
## Run Android Client Against C++ Server Over Bluetooth
First, start the Android test controller application on your device.
From the `cpp` directory, start the Python controller to manage the C++ server:
```bash
python ../scripts/Controller.py --host-bt="00:15:83:ED:D7:29" --host=192.168.1.48 --id=server
```
Where:
- `--host-bt` is the Bluetooth address of the machine running the C++ server
- `--host` is the IP address of the machine running the C++ server
- `--id=server` identifies this controller as managing servers
Then from the `java` directory, start the Java/Android test suite to run against the C++ servers:
```bash
python ./allTests.py --server=server --protocol=bt --cross=cpp --android
```
Where:
- `--server=server` indicates to use the remote server controller
- `--protocol=bt` specifies to use Bluetooth transport, use `--protocol=bts` to test Bluetooth over SSL
- `--cross=cpp` indicates cross-language testing with C++ servers
- `--android` runs the Android client tests
## Finding Bluetooth Addresses
On Linux, you can find the Bluetooth address of your machine using:
```bash
hciconfig
```
On Android, go to Settings → About phone → Status (or Settings → System → About phone) to find the Bluetooth address.
## Troubleshooting
- Ensure Bluetooth is enabled on all devices
- Verify devices are paired before running tests
- Check that the Android test controller application is running and visible
- Ensure IP addresses and Bluetooth addresses are correct
- Use `--debug` flag for verbose output to diagnose connection issues
[Android test controller]: java/test//android/controller/
[cpp/BUILDING.md]: cpp/BUILDING.md
[java/BUILDING.md]: java/BUILDING.md
zeroc-ice-3.8.1/CHANGELOG-3.8.md 0000664 0000000 0000000 00000213531 15165676005 0015542 0 ustar 00root root 0000000 0000000 # Ice 3.8 Changelog
The entries below contain brief descriptions of the changes in each release, in no particular order. Some of the
entries reflect significant new additions, while others represent minor corrections. Although this list is not a
comprehensive report of every change we made in a release, it does provide details on the changes we feel Ice users
might need to be aware of.
- [Changes in Ice 3.8.1](#changes-in-ice-381)
- [General Changes](#general-changes)
- [IceSSL Changes](#icessl-changes)
- [C++ Changes](#c-changes)
- [JavaScript Changes](#javascript-changes)
- [Python Changes](#python-changes)
- [Swift Changes](#swift-changes)
- [Ice Service Changes](#ice-service-changes)
- [Glacier2](#glacier2)
- [IceDiscovery](#icediscovery)
- [Packaging Changes](#packaging-changes)
- [Changes in Ice 3.8.0](#changes-in-ice-380)
- [General Changes](#general-changes-1)
- [Packaging Changes](#packaging-changes-1)
- [Slice Language Changes](#slice-language-changes)
- [IceSSL Changes](#icessl-changes-1)
- [Integration with Platform SSL Engines](#integration-with-platform-ssl-engines)
- [Removed Support for OpenSSL on Windows](#removed-support-for-openssl-on-windows)
- [Removed IceSSL APIs](#removed-icessl-apis)
- [Updated IceSSL Properties](#updated-icessl-properties)
- [Removed IceSSL Properties](#removed-icessl-properties)
- [C++ Changes](#c-changes-1)
- [C# Changes](#c-changes-2)
- [Java Changes](#java-changes)
- [JavaScript Changes](#javascript-changes-1)
- [MATLAB Changes](#matlab-changes)
- [Objective-C Changes](#objective-c-changes)
- [PHP Changes](#php-changes)
- [Python Changes](#python-changes-1)
- [Ruby Changes](#ruby-changes)
- [Swift Changes](#swift-changes-1)
- [Ice Service Changes](#ice-service-changes-1)
- [DataStorm](#datastorm)
- [Glacier2](#glacier2-1)
- [IceBox](#icebox)
- [IceGrid](#icegrid)
- [IcePatch2](#icepatch2)
- [IceStorm](#icestorm)
## Changes in Ice 3.8.1
These are the changes since the Ice 3.8.0 release.
### General Changes
- Updated MCPP to [2.7.2.20](https://github.com/zeroc-ice/mcpp/releases/tag/v2.7.2.20), which fixes a heap-based
buffer overflow (CVE-2019-14274) and a segfault caused by macro parameter corruption. This update applies to the
EL9, EL10, and Windows builds; other platforms use MCPP packages provided by the system.
- The IceBox client library is now available in Swift, MATLAB, and JavaScript, matching the functionality already
available in C++, C#, Java, and Python. (https://github.com/zeroc-ice/ice/pull/5030)
### IceSSL Changes
- Fixed the TrustManager in C# and Java to properly handle the rare situation where Ice's RFC 2253 parser cannot parse a
certificate's subject DN string produced by the platform's SSL stack. Previously, a parse failure could bypass
`IceSSL.TrustOnly` reject rules. (https://github.com/zeroc-ice/ice/pull/5117)
- Fixed a dangling pointer in Schannel hostname verification where a temporary string was destroyed before
`CertVerifyCertificateChainPolicy` read from it, potentially causing incorrect hostname validation or crashes on
Windows. (https://github.com/zeroc-ice/ice/pull/5100)
- Fixed misleading OpenSSL handshake error messages caused by stale errors in the OpenSSL error queue.
(https://github.com/zeroc-ice/ice/pull/5106)
- SSL passwords are now cleared from memory after engine initialization instead of persisting for the engine's entire
lifetime. (https://github.com/zeroc-ice/ice/pull/5108)
- Fixed the Java SSL engine creating a new default `SSLParameters` object instead of preserving the existing engine
parameters when enabling `IceSSL.CheckCertName` hostname verification. (https://github.com/zeroc-ice/ice/pull/5116)
### C++ Changes
- Fixed build failures with Clang in C++23 and C++26 modes. (https://github.com/zeroc-ice/ice/pull/4811)
- Improved `OutputStream::writeConverted` performance by simplifying the size encoding logic, eliminating unnecessary
memory operations when marshaling strings. This applies to applications that use a narrow string converter (non-UTF-8
encoding). (https://github.com/zeroc-ice/ice/pull/5039)
- Fixed `iceserviceinstall` to correctly accept IceGrid and Glacier2 property prefixes. (https://github.com/zeroc-ice/ice/pull/4810)
- Fixed the default value for `IceSSL.RevocationCheckCacheOnly` from 0 to 1, so that certificate revocation checks use
only the local cache by default. (https://github.com/zeroc-ice/ice/issues/2133)
- Fixed a data race in the IceBT DBus message handler. (https://github.com/zeroc-ice/ice/issues/5073)
- Fixed duplicate error handling in the IceBT stream socket read path. (https://github.com/zeroc-ice/ice/issues/5074)
- Added Slice dependency tracking to the CMake `slice2cpp_generate` function, so changes to included `.ice` files
automatically trigger recompilation. (https://github.com/zeroc-ice/ice/pull/5065)
- Fixed `icegriddb` and `icestormdb` import failures caused by using `vector::reserve` instead of `vector::resize`,
and a crash when passing an empty `--mapsize` argument. (https://github.com/zeroc-ice/ice/pull/5137)
### JavaScript Changes
- Created new `@zeroc/slice2js` npm package, which includes the `slice2js` compiler and an unplugin plugin compatible
with modern JavaScript build tools (Vite, Rollup, Webpack, esbuild). (https://github.com/zeroc-ice/ice/pull/5031)
- Added module aggregation support to `slice2js`. The compiler now automatically aggregates nested submodules from
direct and transitive includes, making module imports more natural in JavaScript and TypeScript projects.
(https://github.com/zeroc-ice/ice/pull/5020)
- Fixed inactivity timeout not being correctly converted from seconds to milliseconds, which could cause incorrect
connection timeout behavior. (https://github.com/zeroc-ice/ice/issues/4956)
- Fixed missing `onerror` handler on WebSocket connections, which could cause unhandled errors during connection
establishment. (https://github.com/zeroc-ice/ice/issues/4968)
- Fixed `slice2js` generating invalid JavaScript identifiers from Slice files or modules with hyphenated names.
(https://github.com/zeroc-ice/ice/pull/5029)
- Fixed `slice2js` generating malformed import statements when including Slice files from built-in Ice services such
as Glacier2, IceGrid, or IceStorm. (https://github.com/zeroc-ice/ice/issues/4913)
- Added address information to socket exceptions for better error diagnostics. (https://github.com/zeroc-ice/ice/pull/4997)
- Improved string encoding and decoding performance by using the `TextEncoder` and `TextDecoder` APIs.
(https://github.com/zeroc-ice/ice/issues/5008, https://github.com/zeroc-ice/ice/pull/5069)
- Fixed WebSocket URL construction to properly bracket IPv6 addresses and use port 443 as the default for `wss`
connections. (https://github.com/zeroc-ice/ice/issues/5083, https://github.com/zeroc-ice/ice/issues/5084)
- Fixed encoding version validation incorrectly checking the protocol version field instead of the encoding version
field in message headers. (https://github.com/zeroc-ice/ice/issues/5078)
- Fixed `getPropertyAsList` returning an incorrect default value and `Properties.parse` crashing on empty content.
(https://github.com/zeroc-ice/ice/issues/5079, https://github.com/zeroc-ice/ice/issues/5082)
- Fixed exception chaining to use `{ cause: ex }` consistently across the runtime.
(https://github.com/zeroc-ice/ice/issues/5085)
### Python Changes
- Improved generated doc-comments in the Python Slice compiler (`slice2py`) and `IcePy` extension, including
source-ordered member output, doc-comments for constants, and more complete and consistent documentation.
([#4817](https://github.com/zeroc-ice/ice/pull/4817),
[#4834](https://github.com/zeroc-ice/ice/pull/4834),
[#4835](https://github.com/zeroc-ice/ice/pull/4835),
[#4862](https://github.com/zeroc-ice/ice/pull/4862),
[#4883](https://github.com/zeroc-ice/ice/pull/4883))
- Fixed `python-config` usage in the build system to use `--includes` instead of `--cflags`, avoiding invalid
C-specific flags during C++ compilation. (https://github.com/zeroc-ice/ice/pull/4866)
### Swift Changes
- The `CompileSlice` SwiftPM plugin now auto-detects the Ice slice directory, eliminating the need for manual
configuration when including Ice Slice definitions. (https://github.com/zeroc-ice/ice/pull/4999)
- SwiftPM now uses a prebuilt `slice2swift` artifact bundle, reducing build times and removing the MCPP dependency from
the Ice for Swift SPM package. (https://github.com/zeroc-ice/ice/pull/5007)
- Fixed a rare crash in `ICELocalObject` dealloc caused by recursive deallocation via ARC weak reference reads.
(https://github.com/zeroc-ice/ice/issues/4143)
### Ice Service Changes
#### Glacier2
- Fixed `FilterManager` adapter ID filter being polluted with category filter entries when both
`Glacier2.Filter.Category.Accept` and `Glacier2.Filter.AdapterId.Accept` were configured.
(https://github.com/zeroc-ice/ice/pull/5152)
- Fixed `MatchesString::match` in the proxy address verifier ignoring the `pos` parameter, which could cause incorrect
proxy filtering behavior with address filters containing numeric ranges.
(https://github.com/zeroc-ice/ice/pull/5154)
#### IceDiscovery
- Fixed the C++ IceDiscovery implementation silently keeping a stale adapter proxy when an adapter ID is re-registered,
for example after a server crash or a network failure during shutdown. (https://github.com/zeroc-ice/ice/pull/5170)
### Packaging Changes
- The Windows installer is now distributed as a Burn bundle (.exe) that automatically installs the Visual C++
Redistributable as a prerequisite.
- Ice is now available as a WinGet package.
- Added IceBT library to RPM distributions. (https://github.com/zeroc-ice/ice/issues/4749)
- Added symbols server support for Windows releases.
- NuGet packages now use service-specific icons. (https://github.com/zeroc-ice/ice/pull/5053)
## Changes in Ice 3.8.0
These are the changes since the [Ice 3.7.10] release.
### General Changes
- Replaced ACM and connection timeouts by idle, inactivity, connect, and close timeouts.
- Idle timeout\
Once a connection is established, this connection is considered healthy as long as it does not wait for more than idle
timeout to read a byte. If a connection waits for more than idle timeout to read a byte, it is considered idle and
aborted by the idle check mechanism.
Idle is never a good state. To prevent connections from becoming idle, Ice ensures there is regular write activity on
established connections: if there is no write on a connection for idle timeout / 2, Ice sends a heartbeat on this
connection. A heartbeat is a one-way, unacknowledged, ValidateConnection message. The default idle timeout is
60 seconds. You can change this value with the configuration property `Ice.Connection.Client.IdleTimeout` (for client
connections) or `Ice.Connection.Server.IdleTimeout` (for server connections). The unit for this timeout is seconds.
You can also override this value for a specific object adapter with the configuration property
`AdapterName.Connection.IdleTimeout`. We recommend keeping things simple: use the same value (typically the default)
for all your Ice applications. In particular, the idle timeout is not negotiated during connection establishment and
an idle timeout mismatch may result in untimely connection aborts.
- **Interop with Ice 3.7 and earlier releases**\
If your Ice 3.8 application connects to an older Ice server or accepts a connection from an older Ice client, you
need to change the configuration of your older Ice application to send regular heartbeats. Otherwise, your Ice 3.8
application can consider the connection idle (after idle timeout) and abort this connection. With Ice 3.7 and Ice
3.6, you can set the property `Ice.ACM.Heartbeat` to 3, and make sure the `Ice.ACM.Timeout` property matches your
idle timeout (the default for the ACM timeout is 60 seconds, just like the default idle timeout). If you are unable
to change the configuration of your older Ice application, you can switch off the idle check on the Ice 3.8 side
by setting `Ice.Connection.Client.EnableIdleCheck` or `Ice.Connection.Server.EnableIdleCheck` to 0. You can also
switch off the idle check for just a specific object adapter by setting `AdapterName.Connection.EnableIdleCheck`
to 0.
- **Interop with IceRPC**\
[IceRPC] uses the same idle timeout and idle check mechanism for connections that use the `ice` protocol.
- Inactivity timeout\
A connection is considered inactive when there is no application-level activity on this connection:
there is no outstanding invocation (we're not waiting for a response for a request we've sent), there is no
outstanding dispatch, and no request or response is being sent or received. Sending or receiving a heartbeat (see
above) does not count as application-level activity. When a connection remains inactive for more than the inactivity
timeout, this connection is closed gracefully. Inactive is a good state: the connection is healthy but unused, so we
shut it down to reclaim resources. The default inactivity timeout is 300 seconds. You can change this default by
setting `Ice.Connection.Client.InactivityTimeout` (for client connections) or
`Ice.Connection.Server.InactivityTimeout` (for server connections). The unit for this timeout is seconds. You
can also override this value for a specific object adapter with the configuration property
`AdapterName.Connection.InactivityTimeout`. You can also disable the inactivity timeout/check on a connection
programmatically by calling `disableInactivityCheck` on the connection. This disables the inactivity check only on
your end of the connection.\
Make sure your inactivity timeout is greater than your idle timeout, as the implementation of the inactivity
timeout relies on a smaller idle timeout value. If you disable your idle timeout by setting it to 0 or very large
value (not something we recommend), you will effectively disable your inactivity timeout as well.
- Connect timeout\
A connection establishment fails if it takes more than connect timeout to complete. The default connect timeout is 10
seconds. You can change this value by setting `Ice.Connection.Client.ConnectTimeout` (for client connections) or
`Ice.Connection.Server.ConnectTimeout` (for server connections). The unit for this timeout is seconds. You can also
override this value for a specific object adapter with the configuration property
`AdapterName.Connection.ConnectTimeout`.
- Close timeout\
A graceful connection closure transitions to connection abort if it takes more than close timeout to complete. The
default close timeout is 10 seconds. You can change this value by setting `Ice.Connection.Client.CloseTimeout` (for
client connections) or `Ice.Connection.Server.CloseTimeout` (for server connections). The unit for this timeout is
seconds, as usual. You can also override this value for a specific object adapter with the configuration
property `AdapterName.Connection.CloseTimeout`.
- Removed all properties and APIs related to the old endpoint/connection timeouts: `Ice.Default.Timeout`,
`Ice.Override.Timeout`, `Ice.Override.ConnectTimeout`, `Ice.Override.CloseTimeout`, `ice_timeout`, etc.
The default timeout assigned to new `tcp`, `ssl`, `ws`, `wss`, etc. endpoints is now always 60,000 ms. This timeout
has no effect on Ice 3.8 applications but it can have an effect on older Ice applications that receive proxies with
such endpoints.
- Removed the `setHeartbeatCallback` operation on `Connection`.
- Add new properties for flow control.
- Max dispatches\
The maximum number of concurrent dispatches for each connection is now 100. You can change this value by setting
`Ice.Connection.Client.MaxDispatches` (for client connections) or `Ice.Connection.Server.MaxDispatches` (for server
connections). You can also override this value for a specific object adapter with the configuration
property `AdapterName.Connection.MaxDispatches`.
When the limit is reached, Ice stops reading from the connection, which applies back pressure on the peer.
Ice for JavaScript doesn't implement max dispatches because the WebSocket APIs doesn't provide a mechanism to stop
reading and apply back pressure.
- Max connections\
The property _adapter_.MaxConnections limits the number of incoming connections accepted by an object adapter. The
default is 0, which means no limit.
- Simplify proxy creation.
You can now create a typed proxy directly from a communicator and a string in all languages. For example:
```cpp
// C++
GreeterPrx greeter{communicator, "greeter:tcp -h localhost -p 4061"};
```
```csharp
// C#
var greeter = GreeterPrxHelper.createProxy(communicator, "greeter:tcp -h localhost -p 4061");
```
```java
// Java
var greeter = GreeterPrx.createProxy(communicator, "greeter:tcp -h localhost -p 4061");
```
```js
// JavaScript
const greeter = new GreeterPrx(communicator, "greeter:tcp -h localhost -p 4061");
```
```matlab
% MATLAB
greeter = GreeterPrx(communicator, 'greeter:tcp -h localhost -p 4061');
```
```php
// PHP
$greeter = GreeterPrxHelper::createProxy($communicator, 'greeter:tcp -h localhost -p 4061');
```
```python
# Python
greeter = GreeterPrx(communicator, "greeter:tcp -h localhost -p 4061")
```
```ruby
# Ruby
greeter = GreeterPrx.new(communicator, "greeter:tcp -h localhost -p 4061")
```
```swift
// Swift
let greeter = try makeProxy(
communicator: communicator,
proxyString: "greeter:tcp -h localhost -p 4061",
type: GreeterPrx.self)
```
```ts
// TypeScript
const greeter = new GreeterPrx(communicator, "greeter:tcp -h localhost -p 4061");
```
The existing `stringToProxy` operation on `Communicator` remains available. However, the new syntax is now the
preferred way to create a proxy from a string.
- Reduced the number of `initialize` functions that create a `Communicator`. You can now pass either an
`InitializationData` to `initialize`, or a command-line argument vector. If you were using another overload, you
should update your code to construct an `InitializationData`.
- Add new dispatcher API in C++, C#, Java, JavaScript, and Swift.
- Replaced dispatch interceptors by middleware. See the new forwarder and middleware demos.
- Changed the name of the Ice 3.7 dispatcher API: it's now called executor.
- Add new property `Ice.Warn.Executor`: when 1 (the default), the communicator logs a warning when a custom executor
throws an exception.
- Add `setDefaultObjectAdapter` operation on Communicator to simplify the creation of bidir connections. See the updated
Ice/bidir demo.
- Rework the published endpoints of object adapters
- The published endpoints of an object adapter are the endpoint(s) included in the proxies returned by the `add` and
`createProxy` operations on an object adapter. For indirect object adapters, the published endpoints are the
endpoints registered with the Ice Locator (typically the IceGrid registry).
- Improved the algorithm for computing the default published endpoints.
- Add new _adapter_.PublishedHost property, used to compute the default published endpoints.
- Removed the `refreshPublishedEndpoints` operation on `ObjectAdapter`.
- Removed the `secure` proxy option, the `PreferSecure` proxy property, and all associated properties
(`Ice.Default.PreferSecure`, `Ice.Override.Secure`) and proxy methods (`ice_secure`, `ice_preferSecure`, etc.).
`secure` and `PreferSecure` were about handling proxies with both tcp and ssl endpoints (or ws and wss endpoints).
You should not create such "client-decides-on-security" proxies, and Ice no longer provides special support for these
proxies. If you still use such proxies (even though you shouldn't), the communicator no longer prefers secure or
non-secure endpoints when establishing a connection for such a proxy: all endpoints are treated the same.
- The default value for `Ice.ClassGraphDepthMax` is now `10`. In Ice 3.7, the default was `0`, which meant the class
graph depth was unlimited.
- Refactored the unmarshaling of Slice-defined classes and exceptions.
When Ice unmarshals a Slice-defined class or exception, it first needs to locate and create an instance of the mapped
C++/C#/Java (...) class, using the default parameter-less constructor of the mapped class. The new abstraction for
this process is the Slice loader. Its API varies slightly from language to language, for example:
```cpp
// C++
class SliceLoader
{
public:
[[nodiscard]] virtual ValuePtr newClassInstance(std::string_view typeId) const;
[[nodiscard]] virtual std::exception_ptr newExceptionInstance(std::string_view typeId) const;
};
```
```java
// Java
@FunctionalInterface
public interface SliceLoader {
java.lang.Object newInstance(String typeId);
}
```
```typescript
// TypeScript
interface SliceLoader {
newInstance(typeId: string): Ice.Value | Ice.UserException | null;
}
```
```matlab
% MATLAB
classdef (Abstract) SliceLoader < handle
methods(Abstract)
r = newInstance(obj, typeId)
end
end
```
You can implement `SliceLoader` and install your own custom Slice loader on a communicator by setting the
`sliceLoader` field in `InitializationData`. This custom Slice loader is always in addition to an internal Slice
loader that Ice uses when you don't set a custom Slice loader or when your Slice loader returns null. This new
`InitializationData` field replaces the `ValueFactory` and `ValueFactoryManager` provided in previous Ice releases.
In most languages, generated classes for Slice classes and exceptions register themselves at startup with a default
Slice loader implemented by Ice, and you don't need to do anything to help Ice locate these generated classes.
However, in Java and MATLAB, there is no such registration at startup, and you need to help Ice locate these generated
classes when:
- you remap either the class name or an enclosing module using the `java:identifier`, `java:package`, or
`matlab:identifier` metadata; or
- you assign a compact ID to your class
You help Ice locate these classes by installing a Slice loader in `InitializationData`, just like when you provide a
custom Slice loader. Ice for Java and Ice for MATLAB provide implementations of `SliceLoader` for this purpose. For
example, you can use the `ClassSliceLoader` implementation to create a Slice loader for one or more generated classes
(typically classes with remapped names or compact IDs).
In Java, MATLAB and Swift, the communicator caches "not found" Slice loader resolutions. This cache can be configured
using `Ice.SliceLoader.NotFoundCacheSize` and `Ice.Warn.SliceLoader`.
Limitations:
- in Python and Ruby, a custom Slice loader can only create class instances. The creation of custom user exceptions is
currently ignored.
- there is no custom Slice loader in PHP.
- The local exceptions that can be marshaled now have a common base class (`DispatchException`), and are no longer
limited to 6 exceptions. The reply status of a dispatch exception can have any value between 2 and 255. A dispatch
exception with reply status >= 5 is marshaled as its reply status (one byte) followed by its message (a Slice-encoded
string).
```mermaid
classDiagram
class ReplyStatus {
<>
Ok = 0
UserException
ObjectNotExist
FacetNotExist
OperationNotExist
...
}
LocalException <|-- DispatchException
LocalException: +string message
DispatchException : +ReplyStatus replyStatus
DispatchException <|-- RequestFailedException
class RequestFailedException{
+Identity id
+string facet
+string operation
}
RequestFailedException <|-- ObjectNotExistException
ObjectNotExistException : replyStatus = ObjectNotExist
RequestFailedException <|-- FacetNotExistException
FacetNotExistException : replyStatus = FacetNotExist
RequestFailedException <|-- OperationNotExistException
OperationNotExistException : replyStatus = OperationNotExist
DispatchException <|-- UnknownException
UnknownException : replyStatus = UnknownException
UnknownException <|-- UnknownLocalException
UnknownLocalException : replyStatus = UnknownLocalException
UnknownException <|-- UnknownUserException
UnknownUserException : replyStatus = UnknownUserException
```
- Consolidate and refactor the exceptions derived from LocalException.
| Local exception in Ice 3.7 | Replacement | Notes |
| ----------------------------------- | ---------------------------------------------------------------------------------------- | -------- |
| BadMagicException | ProtocolException (base) | |
| CFNetworkException | SocketException (base) | |
| CloneNotImplementedException | std::logic_error | C++ only |
| CompressionException | ProtocolException (base) | |
| ConnectionManuallyClosedException | ConnectionAbortedException, ConnectionClosedException | |
| ConnectionNotValidatedException | ProtocolException (base) | |
| EncapsulationException | MarshalException (base) | |
| EndpointParseException | ParseException | |
| EndpointSelectionTypeParseException | ParseException | |
| IllegalIdentityException | ArgumentException (C#), std::invalid_argument (C++), IllegalArgumentException (Java) | |
| IllegalMessageSizeException | MarshalException | |
| IllegalServantException | ArgumentNullException (C#), std::invalid_argument (C++), IllegalArgumentException (Java) | |
| IdentityParseException | ParseException | |
| MemoryLimitException | MarshalException (base) | |
| NoValueFactoryException | MarshalException (base) | |
| ProxyParseException | ParseException | |
| ProxyUnmarshalException | MarshalException (base) | |
| StringConversionException | MarshalException (base) | |
| UnexpectedObjectException | MarshalException (base) | |
| UnknownMessageException | ProtocolException (base) | |
| UnknownReplyStatusException | None: all values are now valid | |
| UnmarshalOutOfBoundsException | MarshalException (base) | |
| UnsupportedEncodingException | MarshalException | |
| UnsupportedProtocolException | MarshalException, FeatureNotSupportedException | |
| VersionMismatchException | InitializationException | |
| VersionParseException | ParseException | |
base = was existing base class
New local exceptions:\
ConnectionAbortedException, ConnectionClosedException, ParseException
- The plug-ins provided by Ice now have fixed names: IceIAP, IceBT, IceUDP, IceWS, IceDiscovery, IceLocatorDiscovery.
This fixed name is the only name you can use when loading/configuring such a plug-in with the Ice.Plugin.name
property.
- Added a new always-enabled logger middleware in all languages with dispatch support. This middleware logs dispatches
using the configured logger based on the value of `Ice.Trace.Dispatch` and `Ice.Warn.Dispatch`.
- Removed support for setting per-language plug-in entry points. In Ice 3.7 and earlier, it was possible to specify
plug-in entry points on a per-language basis using the `Ice.Plugin..` syntax. This feature was rarely used
and discouraged, as configuration files should not be shared across language mappings.
- Removed the `stringToIdentity` method from the Communicator class. This method was deprecated in Ice 3.7.
- The collocation optimization check no longer takes datagram endpoints into account. As a result, a call to a proxy
with only UDP endpoints is never collocation-optimized. This change is particularly useful for multicast UDP
endpoints (and by extension proxies), since multiple object adapters often listen on the same multicast address/port
combination.
- Added a new `ice2slice` compiler that converts Slice files in the `.ice` format (used by Ice) into Slice files in the
`.slice` format (used by IceRPC).
- Removed Slice checksums.
- Removed the `slice2html` compiler, which was previously used to convert Slice doc-comments to HTML. You can use
Doxygen to generate an API reference for your Slice files.
- Removed the `--impl` and `-E` options from the Slice compilers.
- Added stricter property validation. Ice now throws an exception during communicator initialization when an unknown
Ice property is set.
- Added `getIceProperty`, `getIcePropertyAsInt`, and `getIcePropertyAsList` methods to `Properties`. These methods
return the value of an Ice property, or the default value if the property is not set.
- The `Ice.ProgramName` property is now set to the executable/script name (when possible) during communicator
initialization in C++, MATLAB, PHP, Python, Ruby, and Swift. Previously, `Ice.ProgramName` was only set when the
args array was passed to `createProperties`, and was set to the first element of that array.
In C++, the first element of the `argv` array is still used if passed to `initialize`.
- Duplicated options are now rejected when parsing a stringified endpoint. For example,
"greeter:tcp -h host1 -h host2 -p 4061" was a valid proxy string in prior Ice releases. Its parsing now fails with a
ParseException.
### Packaging Changes
- The Windows MSI installer is now built using the WiX Toolset. The WiX project files are included in the packaging/msi
directory.
- The RPM packaging files, previously distributed in the ice-packaging repository, are now included in the packaging/rpm
directory.
- The DEB packaging files, previously distributed in the ice-packaging repository, are now included in the packaging/deb
directory.
- The monolithic `zeroc.ice.net` package has been replaced with modular NuGet packages:
| Package | Description |
| ------------------------- | ------------------------------------------------------------------------------------------------------- |
| iceboxnet | The IceBox server for .NET, packaged as a dotnet tool. |
| ZeroC.Glacier2 | The Glacier2 assembly, used by Glacier2 client applications. |
| ZeroC.Ice | The main Ice assembly. |
| ZeroC.Ice.Slice.Tools | The Slice compiler (slice2cs) and MSBuild integration. Replaces the `zeroc.icebuilder.msbuild` package. |
| ZeroC.IceBox | The IceBox assembly. |
| ZeroC.IceDiscovery | The IceDiscovery plug-in. |
| ZeroC.IceGrid | The IceGrid assembly, used by IceGrid client applications. |
| ZeroC.IceLocatorDiscovery | The IceLocatorDiscovery plug-in. |
| ZeroC.IceStorm | The IceStorm assembly, used by publishers and subscribers for IceStorm. |
ZeroC.Ice.Slice.Tools contains `slice2cs` binaries for Linux, macOS and Windows. As a result, `slice2cs` is no
longer distributed in any other package.
- The C++ NuGet package has been renamed to `ZeroC.Ice.Cpp`. This package replaces the `zeroc.ice.vXXX` packages from
Ice 3.7. It includes the Slice tools for C++ and no longer requires the `zeroc.icebuilder.msbuild` package.
Additionally, it provides CMake support files in the cmake directory.
- The `ice` NPM package has been converted into a scoped package named `@zeroc/ice` and also includes the `slice2js`
Slice compiler for Linux, macOS and Windows.
### Slice Language Changes
- Removed local Slice. `local` is no longer a Slice keyword.
- The type of an optional field or parameter can no longer be a class or contain a class.
- Added new metadata for customizing the mapped names of Slice definitions in each language.
This metadata is of the form: `[":identifier:"]`, where `` can be any of the standard language
prefixes, and that definition's identifier will be `` in the specified language.
For example:
```slice
["cs:identifier:MyNamespace"]
["java:identifier:com.example.mypackage"]
module MyModule {}
```
The argument is used as a drop-in replacement for the Slice identifier, with no additional processing.
For the above example, `slice2cs` will generate `namespace MyNamespace {}` and `slice2java` will generate
`package com.example.mypackage;`. All other compilers will map the module using its Slice-provided identifier,
as usual.
This metadata can be applied to any Slice definition with an identifier, and is available for all languages.
Note that this only affects the _mapped_ name of Slice definitions.
It has no effect on Slice type IDs, or a definition's on-the-wire representation.
- Deprecated the `cs:namespace`, `java:package`, and `swift:module` metadata. Removed the `python:package` metadata.
`:identifier` metadata is now the preferred way to change how Slice modules are mapped.
- Removed automatic escaping of Slice identifiers. Previously, the Slice compilers had a list of each language's
keywords and reserved identifiers, and would automatically escape conflicting identifiers during code-generation.
Now that this has been removed, conflicting identifiers should be fixed using `:identifier` metadata.
- Added a shorthand syntax for defining nested modules. For example, the following two definitions are equivalent:
```slice
module Foo { module Bar { module Baz { /*...*/ } } }
module Foo::Bar::Baz { /*...*/ }
```
Metadata cannot be applied to modules using this syntax, since it's ambiguous which module it would apply to.
- Added support for triple-slash doc-comments, in addition to the already supported JavaDoc comment syntax.
For example, the following two definitions are equivalent:
```slice
/// Sends a request.
/// @param message the message.
/// @return a response code.
int sendRequest(string message);
/**
* Sends a request.
* @param message the message.
* @return a response code.
*/
int sendRequest(string message);
```
- Added support for 2 new doc-comment tags: `@remark` and `@p`
`@remark` can be used to provide additional (often non-critical) information in a doc-comment:
```slice
/// Provides access to a radar scanner.
/// @remark For sonar, use {@link SonarScan} instead.
class RadarScan {}
```
`@p` can only be used on operations, and provides a way to reference parameters in its doc-comment.
This is different than `@param`. `@param` is used to describe a parameter, not reference one. For example:
```slice
/// @param start The start.
/// @param end The end. Must be greater than @p start.
int getDuration(int start, int end);
```
- Added support for Markdown style code-spans in doc-comments:
```slice
/// This is `true`, and can be used as a default value: `bool b = Yes;`
const bool Yes = true;
```
You can use any number of backticks to mark the beginning/end of the code-span, but they must match in number.
This is useful if the code-span itself will contain backticks:
```slice
/// This code-span ``contains a ` character`` just fine.
```
Outside of code-spans, you can escape a backtick with a backslash to get a normal textual backtick character:
```slice
/// This character \` doesn't start a code-span and will appear like a normal backtick character.
```
- Lists of metadata can be split into separate brackets now, allowing for longer metadata to be placed on separate lines
or for metadata to be grouped by functionality. For example, you can now write:
```slice
["deprecated:This operation should no longer be called"]
["marshaled-result"] ["format:sliced"]
void myOperation(MyClass c);
```
Previously, all metadata needed to be in a single comma-separated list (note that this syntax is still supported):
```slice
["deprecated:This operation should no longer be called", "marshaled-result", "format:sliced"]
void myOperation(MyClass c);
```
- Metadata can now be applied to Slice enumerators.
- Added `["deprecated"]` as an alias for the `["deprecate"]` metadata.
- Removed the `["protected"]` metadata. This was primarily for classes with operations, which are no longer allowed.
- Removed the `["preserve-slice"]` metadata. Slice classes marshaled in the sliced format are now always preserved when
unmarshaled.
- Exceptions are now always marshaled in the sliced format and no longer support preservation of unknown slices during
unmarshaling.
- Slice classes can no longer define operations or implement interfaces, and `implements` is no longer a Slice keyword.
This feature has been deprecated since Ice 3.7.
- Slice classes can no longer represent remote Ice objects; the syntax `MyClass*` (a proxy to a class) is now invalid.
- An interface can no longer be used as a type. This feature, known as "interface by value", has been deprecated since
Ice 3.7. You can still define proxies with the usual syntax, `Greeter*`, where `Greeter` represents an interface.
- It is no longer an error for a Slice definition to have the same identifier as one of its enclosing modules.
- Removed the `["ice-prefix"]` metadata and the `--ice` compiler option.
Slice identifiers can now start with `"ice"` without needing to specify either of these.
- Removed the `["underscore"]` metadata and the `--underscore` compiler option.
Slice identifiers can now contain single underscores without needing to specify either of these.
Double underscores (`__`) are still disallowed in Slice identifiers.
- `:` is now an alias for the `extends` keyword.
- Sequences can no longer be used as dictionary key types.
This feature has been deprecated since Ice 3.3.0.
### IceSSL Changes
The SSL transport is no longer a plug-in. It is now built into the main Ice library and always available.
#### Integration with Platform SSL Engines
Ice 3.8 introduces new IceSSL configuration APIs that allow you to configure the SSL transport using platform-native
SSL engine APIs. This provides significantly greater flexibility for advanced use cases.
- The SSL transport can now be fully configured programmatically, without relying on IceSSL properties.
- Separate configurations for outgoing and incoming SSL connections are supported.
- Per object adapter configuration is also possible.
> These APIs are platform-dependent. A good starting point is the `Ice/secure` demo for your target platform and
> language mapping.
#### Removed Support for OpenSSL on Windows
In Ice 3.7, IceSSL on Windows could be built with either Schannel or OpenSSL. In Ice 3.8, since IceSSL is now built-in,
it always uses the platform’s native SSL APIs. On Windows, this means **Schannel is always used**;
**OpenSSL is no longer supported** on Windows.
#### Removed IceSSL APIs
- **Certificate API**\
The `IceSSL::Certificate` type and related APIs have been removed. Applications that require access to certificate
data must now use platform-native certificate APIs.
- **Certificate Verifiers**\
Custom certificate verifiers have been replaced with new configuration APIs that allow applications to install
validation callbacks that directly use the underlying SSL engine APIs.
- **Password Callbacks**\
Password callback support has been removed. Applications can now provide certificates and keys directly through the
new configuration APIs.
#### Updated IceSSL Properties
- **IceSSL.CertFile**\
This property no longer accepts multiple files. In Ice 3.7, IceSSL with OpenSSL or Schannel allowed specifying two
files—one for RSA and one for DSA certificates. This uncommon use case is no longer supported. Applications requiring
more flexibility should use the new configuration APIs, which support selecting certificates on a per-connection
basis.
- **IceSSL.CheckCertName**\
In Ice 3.7, this property controlled two unrelated features:
(1) matching the target host name against the peer's certificate Subject Alternative Name or Common Name, and
(2) enabling SNI (Server Name Indication).
In Ice 3.8, **SNI is always enabled** for outgoing connections when the target endpoint uses a DNS name. The property
now only controls certificate name matching.
- **IceSSL.Truststore**\
The `IceSSL.Keystore` property is no longer used as a fallback for `IceSSL.Truststore`.
- **IceSSL.VerifyPeer**\
Setting `IceSSL.VerifyPeer=0` no longer suppresses verification errors. In Ice 3.7, this was often used alongside
the now-removed certificate verifier APIs. Applications requiring custom trust logic should use the new validation
callbacks.
#### Removed IceSSL Properties
Several IceSSL properties have been removed in Ice 3.8, either because better alternatives are now available, they are
no longer useful, or they go against best practices:
- **IceSSL.CertVerifier**\
Previously used to dynamically load custom certificate verifiers. This mechanism and the property have been removed.
- **IceSSL.Ciphers**\
Used to configure the list of allowed SSL ciphers. Ice 3.8 now uses system-wide defaults by default. For advanced use
cases, the new configuration APIs provide direct access to the underlying SSL engine.
- **IceSSL.DH.bits**, **IceSSL.DHParams**\
Used to configure Diffie-Hellman parameters for DH cipher suites. Since DH-based ciphers are no longer recommended,
these properties have been removed.
- **IceSSL.EntropyDaemon**\
Relevant only for legacy OpenSSL versions that are no longer supported.
- **IceSSL.InitOpenSSL**\
Controlled whether IceSSL performed global OpenSSL initialization. This is no longer needed with the OpenSSL versions
supported in Ice 3.8.
- **IceSSL.Random**\
Used to provide seed data to the SSL engine. Modern SSL platforms handle this internally, so the property is no longer
necessary.
- **IceSSL.SchannelStrongCrypto**\
Enabled the `SCH_USE_STRONG_CRYPTO` flag on Windows to disable weak cryptographic algorithms. This flag is now always
enabled by default, making the property redundant.
- **IceSSL.PasswordCallback**, **IceSSL.PasswordRetryMax**\
Supported dynamic password callbacks, which are no longer supported. These properties and their underlying mechanism
have been removed.
- **IceSSL.Protocols**, **IceSSL.ProtocolVersionMax**, **IceSSL.ProtocolVersionMin**\
Controlled which SSL/TLS protocol versions were allowed for connections. Ice 3.8 now uses the system defaults
(typically TLS 1.2 and TLS 1.3). Applications needing precise control can either adjust system settings or use the
new configuration APIs.
- **IceSSL.VerifyDepthMax**\
Previously used to set the maximum certificate chain length. This feature was rarely used. Applications requiring this
functionality should implement a custom certificate validation callback.
### C++ Changes
- There is now a single C++ mapping, based on the C++11 mapping provided by Ice 3.7. This new C++ mapping requires a
C++ compiler with support for C++17 or higher.
- Generated proxy classes are now concrete classes with public constructors.
- Nullable proxies are represented using `std::optional`.
- Removed the IceUtil namespace. All remaining utility classes and functions, such as `CtrlCHandler` and
`wstringToString`, are now in the Ice namespace.
- All functions that create proxies, including `Communicator::stringToProxy`, `ObjectAdapter::add`,
`Connection::createProxy` and more, are now template functions that allow you to choose the type of the returned
proxy. The default proxy type is `Ice::ObjectPrx` for backwards compatibility. We recommend you always specify the
desired proxy type explicitly. For example:
```cpp
// widget is a std::optional
auto widget = communicator->propertyToProxy("MyWidget");
```
- The Slice compiler now always generates an async skeleton (with an Async prefix) in addition to the usual skeleton
class. The async skeleton provides only async functions, just like if you added the `["amd"]` metadata directive on
your Slice interface. You should consider using this async skeleton instead of applying `["amd"]` to your interface or
to some of its operations.
- The C++ structs, classes, exception classes, and enumerations generated by the Slice compiler can now be printed using
`operator<<(ostream&, const T&)`. For structs, classes, and exceptions, this operator prints the type name and all the
field names and values; see the [Slice/print] test for examples.
- You can also implement your own custom printing by applying metadata `["cpp:custom-print"]` to your Slice type.
- When unmarshaling an array of short, int, long, float, or double, you can now choose to use unaligned unmarshaling by
defining ICE_UNALIGNED when building your application. This optimization requires the non-default array mapping for
Slice sequences, enabled by the `cpp:array` metadata directive, and a compatible little endian platform. In Ice 3.7 and
earlier releases, this unaligned unmarshaling was turned on automatically on x86 and x64 CPUs, and turned off on all
other CPUs.
- Replaced the `Ice::registerPluginFactory` mechanism (with `Ice::registerIceUDP`, `Ice::registerIceDiscovery`, etc.)
by plug-in factories on InitializationData. The corresponding plug-ins are created during communicator initialization.
See `InitializationData::pluginFactories`.
- Removed StringConverterPlugin and ThreadHookPlugin.
- Removed the `--nowarn` option, which was used to suppress warnings in `icegridnode`, `glacier2router`,
`icegridregistry`, and `icebox`.
- Added overloads for the `ice_invocationTimeout` and `ice_locatorCacheTimeout` proxy methods that accept
`std::chrono::duration` values. The corresponding `ice_getInvocationTimeout` and `ice_getLocatorCacheTimeout` methods
now return `std::chrono::milliseconds`.
- Removed support for using poll as a selector mechanism.
- The Ice runtime now calls std::abort when a selector internal error occurs.
The underlying platform selectors — IOCP, kqueue, or epoll — can fail with internal errors that indicate fatal
conditions such as application bugs or malfunctioning systems.
There is no clean way to recover from these errors, and keeping malfunctioning systems running is of no help;
aborting the application allows the replica management system to take over in a replicated setup.
### C# Changes
- Upgrade to .NET 8.0 / C# 12.
- Added full support for nullable types:
- Both the Ice C# API and the code generated by the Slice compiler are `#nullable enable`.
- Ice now uses the standard `?` notation for all nullable types.
- The thread pools created by Ice no longer set a synchronization context. As a result, the continuation from an async
invocation made from an Ice thread pool thread executes in a .NET thread pool thread; previously, this continuation
was executed in a thread managed by the same Ice thread pool unless you specified `.ConfigureAwait(false)`.
- The `cs:attribute` Slice metadata is now limited to enums, enumerators, fields, and constants. For other constructs,
you can define custom attributes using a C# partial class, struct, or interface.
- Replaced the `Ice.Util.registerPluginFactory` mechanism by plug-in factories on InitializationData. The corresponding
plug-ins are created during communicator initialization. See `InitializationData.pluginFactories`.
- Slice structs are now mapped to record structs or record classes:
- a Slice struct with only numeric, bool, enum, or record struct fields is mapped to a record struct.
- a Slice struct with any other field type is mapped to a sealed record class.
- Updated Ice.Communicator to implement IAsyncDisposable. The preferred way to create and dispose of a communicator is
now:
```cs
await using Ice.Communicator communicator = Ice.Util.initialize(ref args);
```
- The preferred way to wait for communicator shutdown in an async context is now:
```cs
await communicator.shutdownCompleted;
```
- The Logger interface is now disposable.
- Removed ThreadHookPlugin.
- Removed support for serializable objects (the `cs:serializable` metadata directive).
- Added overloads for the `ice_invocationTimeout` and `ice_locatorCacheTimeout` proxy methods that accept `TimeSpan`
values. The corresponding `ice_getInvocationTimeout` and `ice_getLocatorCacheTimeout` methods now return a `TimeSpan`.
- Removed support for using `clr` as an alias for `cs` in metadata declarations.
- The Slice compiler now always generates async skeletons (with an Async prefix) in addition to the usual skeleton
interface and class. The async skeletons provide only async methods, just like if you added the `["amd"]` metadata
directive on your Slice interface. You should consider using these async skeletons instead of applying `["amd"]` to
your interface or to some of its operations.
### Java Changes
- Upgrade to Java 17.
- Removed the Java-Compat mapping.
- Add plug-in factories to InitializationData. The corresponding plug-ins are created during communicator
initialization. See `InitializationData.pluginFactories`.
- Removed the `com.zeroc.Ice.Exception` base class. The common base class for all Ice exceptions is now
`java.lang.Exception`.
- Removed the `Ice.ThreadInterruptSafe` property. You no longer need to set a property to use Ice for Java with
interrupts.
- Removed ThreadHookPlugin.
- Reworked IceMX to avoid creating split packages.
- The Logger interface now extends AutoCloseable.
- Added overloads for the `ice_invocationTimeout` and `ice_locatorCacheTimeout` proxy methods that accept
`java.time.Duration` values. The corresponding `ice_getInvocationTimeout` and `ice_getLocatorCacheTimeout` methods
now return a `java.time.Duration`.
- The Slice compiler now always generates an async skeleton (with an Async prefix) in addition to the usual skeleton
interface. The async skeleton provides only async methods, just like if you added the `["amd"]` metadata directive
on your Slice interface. You should consider using this async skeleton instead of applying `["amd"]` to your interface
or to some of its operations.
- Added support for the `Ice.ClassGraphDepthMax` property, which controls the maximum depth allowed when unmarshaling a
graph of Slice class instances.
- Added the `Ice.WS.MaxBufferedAmount` property, which controls the maximum number of bytes that can be queued
by a WebSocket connection. Once the WebSocket `bufferedAmount` reaches this limit, sending additional data
is delayed until it drops below the threshold.
- Marshaling a `null` enum value will now result in a `NullPointerException` instead of marshaling the first enumerator
of the enum.
- Marshaling a `null` struct will now result in a `NullPointerException` instead of marshaling a default initialized
instance of that struct.
- The Ice runtime terminates the Java Virtual Machine after receiving a selector internal error.
This typically indicates an application bug or a malfunctioning system.
The underlying platform selectors — IOCP, kqueue, or epoll — can fail with internal errors that represent fatal
conditions.
There is no clean way to recover from these errors, and keeping malfunctioning systems running is of no help;
terminating the JVM allows the replica management system to take over in a replicated setup.
### JavaScript Changes
- Added support for `Symbol.asyncDispose` on `Ice.Communicator`. TypeScript applications can now use the communicator in
`await using` expressions.
```ts
await using communicator = Ice.initialize(process.argv);
```
- Ice for JavaScript now uses `console.assert`. You can configure your build to strip out these assertions in release
builds.
- Fixed a bug where a reply could be processed before the corresponding request was marked as sent. This could break
at-most-once semantics.
- Added support for `Ice.ClassGraphDepthMax` to control the maximum unmarshaling depth for graphs of Slice class
instances.
- Removed support for the Internet Explorer browser.
- Slice modules are now always mapped to JavaScript ES6 modules. The `js:es6-module` metadata has been removed, as a
single module mapping is now used by default.
- Slice `long` is now mapped to JavaScript `BigInt`. For input parameters, both `number` and `BigInt` are accepted.
The `Ice.Long` class has been removed.
- Dictionaries with `long` keys now use the built-in `Map` type.
Previously, `Ice.HashMap` was required because `Ice.Long` objects could not be used as keys in a `Map`.
- Marshaling `null` for a non-optional enum value will now result in an error, instead of marshaling the first
enumerator of the enum.
- Marshaling `null` for a non-optional struct will now result in an error, instead of marshaling a default
initialized instance of that struct.
- The WebSocket transport is now supported with Node.js 24 and higher. In Node.js 23 and earlier, WebSocket connections
do not reliably report errors during connection establishment. We advise against using the WebSocket transport on
these versions.
- The `js:module` file metadata directive can no longer be used to generate bundles with the Gulp Ice Builder. You must
now use a standard JavaScript bundler instead. This metadata remains useful to indicate that your generated code is
published as an npm package and to control how other generated code imports it.
### MATLAB Changes
- Upgrade to MATLAB 2024a.
- Added argument validation for generated proxy methods.
- All argument types are now validated, except for parameters that correspond to optional Slice parameters.
- A proxy or class argument to set to "null" must now be an empty array of the associated type, such as
`GreeterPrx.empty`. `[]` is no longer a valid value for such arguments.
- Changed the mapping for `sequence`. A `sequence` now maps to a MATLAB string array. This new mapping
remains highly compatible with the previous mapping (cell array of char).
- Changed the mapping for Slice dictionaries. A Slice dictionary now always maps to a MATLAB dictionary; the old
`containers.Map` are no longer used.
The dictionary key type is the mapped key type. The dictionary value type is as per the table below:
| Slice type T mapped to MATLAB MT | Value type of MATLAB dictionary | Mapping for `sequence` |
| ---------------------------------- | ------------------------------- | ------------------------- |
| bool, numeric, struct, enum | MT | array of MT |
| string | string (1) | array of string |
| sequence, dictionary, class, proxy | cell holding a MT | cell array of MT |
(1) A single Slice string maps to a MATLAB char array, not to a MATLAB string.
- All fields are now mapped to typed MATLAB properties except optional fields and fields whose type is a class or uses
a class.
- In such properties, a null proxy is represented by an empty array of the proxy type, for example `GreeterPrx.empty`.
Likewise, an empty sequence (array) is represented by an empty array of the correct type, such as `string.empty` or
`int32.empty`.
- `[]` is no longer a valid value for proxy and sequence properties: always use a typed array.
- Changed the default value for properties mapped from a Slice struct type. It's now an empty array of the mapped class;
it was previously a new instance of the mapped class created with no argument.
- The `slice2matlab` function has been updated to accept multiple arguments, which are passed directly to the
`slice2matlab` compiler. In Ice 3.7, all arguments had to be provided as a single string, which was less convenient.
### Objective-C Changes
- The Objective-C mapping was removed.
### PHP Changes
- Removed the flattened mapping deprecated in 3.7.
- Removed the `ice.hide_profiles` directive. This directive was intended to clear the `ice.profiles` setting after it
was read by the Ice extension, preventing untrusted applications on the same web server from accessing it. However,
it could be circumvented and thus provided only a false sense of security. The recommended and more secure approach
is to use PHP-FPM, which supports separate PHP pools per application and avoids the need of sharing PHP settings
between untrusted applications.
- Updated Ice\register to accept fractional minute values for the expires argument by using a double instead of an int.
- Removed support for Windows PHP builds.
- Removed support for PHP 5 builds.
- Removed the `ice_premarshal` and `ice_postunmarshal` "hooks" called during class marshaling and unmarshaling.
`ice_postunmarshal` only makes sense if the application can register a custom Slice loader and Ice for PHP does not
provide custom Slice loaders.
- Marshaling `null` for a struct will now result in an error, instead of marshaling a default initialized instance of
that struct.
### Python Changes
- Upgrade to Python 3.12.
- Added `Ice.EventLoopAdapter` for async event loop integration. This adapter integrates Ice asynchronous methods with
the event loop of your choice. With it:
- Asynchronous proxy invocations return an awaitable that can be awaited directly in the chosen event loop.
There is no longer a need to wrap the returned future to run in your event loop.
- The same applies to other asynchronous methods in the Ice API: the returned awaitable always uses the event loop
adapter to ensure it can be correctly awaited in the selected event loop.
- Asynchronous dispatch methods can be implemented as async methods that run in that event loop.
Ice includes a built-in adapter for Python’s asyncio, and the same mechanism can be extended to support other event
loop systems.
- Added async context manager support to `Ice.Communicator`. You can now use the communicator in `async with`
expressions.
```python
async def main():
async with Ice.initialize(
sys.argv,
eventLoop=asyncio.get_running_loop()) as communicator:
...
if __name__ == "__main__":
asyncio.run(main())
```
- Added a `checkedCastAsync` method to proxy objects to support asynchronous checked casts.
- Added a `Communicator.shutdownCompleted` method to asynchronously wait for communicator to shut down.
- Removed the copy parameter from the memory view factory. In Ice 3.8, the factory always receives a memory view over
the input stream data, making the copy parameter unnecessary.
- Ice no longer uses `Ice.Unset` to represent unset optional parameters. Starting with Ice 3.8, `None` is used
instead. The Ice.Unset global has been removed. Furthermore, there is no distinction between a non-set
optional parameter and an optional parameter set to `None`.
- Removed the `Ice.generateUUID` helper method. You should use Python’s built-in uuid module instead.
- Added support for building pip packages directly from the Ice source distribution. In previous releases, the pip
package was built from a separate tarball that included pre-generated source code.
- Enumerations now inherit from Python's `enum.Enum` type. The `Ice.EnumBase` class has been removed.
- The default value for struct, sequence, and dictionary Slice fields has been changed from `None` to a default
initialized instance.
- Marshaling `None` for a non-optional struct will now result in an error, instead of marshaling a default
initialized instance of that struct.
- Removed support for the `python:pkgdir` Slice metadata. Generated code is now always placed in the corresponding
package directory relative to the specified output directory.
- The Slice for Python compiler (`slice2py`) and dynamic Slice-to-Python compilation using `Ice.loadSlice` no longer
support the `--all` option, which previously allowed compiling files included by other Slice files. Instead, you must
explicitly pass all required Slice files to `slice2py` or `Ice.loadSlice`.
- The `--prefix` option, which previously allowed users to specify a custom prefix for generated file names, has been
removed from the Slice for Python compiler (`slice2py`). Generated file names are now always derived from the Slice
definition name. If a name would conflict with a Python built-in keyword or module, it must be renamed using the new
`python:identifier` metadata.
- The Slice for Python compiler now generates a separate Python module for each Slice definition. The module name is
derived from the Slice definition name. For example, `enum MyEnum` in Slice module `Foo::Bar` results in the Python
module `Foo.Bar.MyEnum`, generated in `Foo/Bar/MyEnum.py`.
For classes and interfaces, an additional `_forward` module is generated to contain forward declarations for proxies
and class meta-types. Application code does not need to import these files.
Package index files are also generated for each module unless the `--build=modules` option is specified to generate
only the module files.
- The Slice for Python compiler no longer edits existing package index files. Instead, it recreates them on each run.
When generating package index files, all Slice files contributing to the package must be passed to the compiler to
ensure that all definitions are included in the package exports.
- The `--no-package` and `--build-package` options have been replaced by the more comprehensive
`--build=modules|package-index|all` option.
- `--build=all` generates both the Python modules for each Slice definition and the package index files for each
module.
- `--build=modules` generates only the Python modules.
- `--build=package-index` generates only the package index files.
- A new `--list=all|modules|package-index` option has been added to `slice2py` to list the generated files. In previous
versions, the compiler generated a single Python module with a `_ice.py` extension per Slice file, making it easy to
track outputs. In 3.8, each Slice definition is compiled into a separate module under its Python package path. The
new `--list` option helps track the set of generated files.
- Removed support for the 'marshaled-result' metadata directive.
- Removed support for the `python:seq` metadata. Use `python:list` and `python:tuple` instead.
- Added additional (optional) argument to `python:memoryview` metadata directive which is used to specify a type hint.
For example, `["python:memoryview:CustomFactory.myByteSeq:array.array"]` indicates that the factory function
will return an `array.array`.
- Added type hints to the Ice package and generated code.
- The `Ice.loadSlice` function for dynamically loading Slice files at run time now accepts only a list of compiler
arguments (strings). Previously, it accepted both a command string and an optional list of arguments (which served
the same purpose). This has been simplified to require a single list of strings.
```python
# Old syntax (no longer supported)
Ice.loadSlice("-I. Foo.ice")
Ice.loadSlice("-I.", ["Foo.ice"])
Ice.loadSlice("", ["-I.", "Foo.ice"])
# New syntax
Ice.loadSlice(["-I.", "Foo.ice"])
```
- Removed the self-reference parameter from `InvocationFuture.add_sent_callback`. Registered callbacks no longer
receive the `Ice.InvocationFuture` instance as their first parameter.
### Ruby Changes
- Updated the optional `Ice.initialize` block to only accept a single argument, the communicator. Previously, this
optional block could accept one argument (the communicator), or two arguments (the communicator and the remaining
command-line arguments).
- The `Ice.loadSlice` function for dynamically loading Slice files at runtime now accepts only a list of compiler
arguments (strings). Previously, it accepted both a command string and an optional list of arguments (which served
the same purpose). This has been simplified to require a single list of strings.
```ruby
# Old syntax (no longer supported)
Ice.loadSlice("-I. Foo.ice")
Ice.loadSlice("-I.", ["Foo.ice"])
Ice.loadSlice("", ["-I.", "Foo.ice"])
# New syntax
Ice.loadSlice(["-I.", "Foo.ice"])
```
### Swift Changes
- Upgrade to Swift 6.1.
- Removed support for Carthage. Ice for Swift now uses the Swift Package Manager (SwiftPM) for dependency management.
- Updated to use async/await and fully support Swift's Structured Concurrency model.
- Removed the dependency on `PromiseKit`. Functions which previously returned a `Promise` are now async functions.
- Functions in dispatch protocols generated from Slice interfaces are now always async. The `amd` metadata directive has
no effect on the generated code.
- Servants must now conform to the `Sendable` protocol.
- Proxy methods generated from Slice interfaces are now always async. The `Async` suffixed functions have been
removed.
- Simplified the server-side mapping by removing the generated Disp structs. You can now use the generated server-side
protocols as servants / dispatchers, like in other language mappings.
- Added a SwiftPM plugin, `CompileSlice`, that lets you compile Slice files as part of SwiftPM and Xcode builds.
### Ice Service Changes
#### DataStorm
- The DataStorm publisher/subscriber framework has been integrated into the Ice distribution, and is no longer a
separate product.
- Added `NodeOptions` struct to configure a new `Node` instance.
- Added support for running DataStorm callbacks using a custom executor. The custom executor can be set in
`NodeOptions`.
- Added `DataStorm.Node.Name` property to configure the name of a DataStorm node. The node names must be unique within
a DataStorm deployment.
- Fixed a bug in DataStorm that can result in unexpected samples received after a session was recovered after
disconnection.
- Fixed a bug in filter initialization that can result in segmentation fault when using a key or a sample filter.
#### Glacier2
- Removed buffered mode. As a result, Glacier2 has now a single mode, the previous unbuffered mode.
- Removed support for request overrides (the `_ovrd` request context).
- Removed support for creating batches of requests (`Glacier2.Client.AlwaysBatch` and `Glacier2.Server.AlwayBatch`).
- Removed Glacier2 helper classes.
- Removed session timeouts configured using `Glacier2.SessionTimeout`. The Glacier2 router now relies on the common
idle check described under [General Changes](#general-changes) for these connection-bound sessions.
#### IceBox
- Added a new operation on `IceBox::ServiceManager`: `isServiceRunning`.
- Added a new command called "status SERVICE" to `iceboxadmin` and `com.zeroc.IceBox.Admin`.
- Added a new "service status SERVER SERVICE" command to `icegridadmin`.
#### IceGrid
- Renamed the icegridadmin command "server state SERVER" to "server status SERVER" for consistency with the
new "service status SERVER SERVICE" command.
- Removed deprecated server and application distributions in IceGrid. These distributions relied on the IcePatch2
service.
- Removed deprecated Freeze database environments (DbEnv).
- Removed client and admin-client session timeouts configured using `IceGrid.Registry.SessionTimeout`. IceGrid now
relies on the common idle check described under [General Changes](#general-changes) for these connection-bound
sessions.
- Interop/upgrade from 3.7
- IceGrid registry and IceGrid node must all use version 3.8. For example, you can't use a 3.7 node with a 3.8
registry.
- IceGridGUI 3.7 cannot connect to an IceGrid registry 3.8, and we recommend using icegridadmin 3.8 with IceGrid
registry 3.8.
- If you've written your own IceGrid admin tool using Ice 3.7, it may or may not work with a 3.8 registry, depending
on the APIs you're using. You should upgrade this tool to Ice 3.8.
- The registry database schema remains the same as in Ice 3.7. As a result, you can start a 3.8 registry with a
database created by a 3.7 registry, or vice-versa.
#### IcePatch2
- The IcePatch2 service was removed.
#### IceStorm
- The IceStorm configuration now uses the `IceStorm` prefix instead of the IceBox service name as prefix.
- Added a new operation on `TopicManager`: `createOrRetrieve` creates or retrieves a topic with the specified name, and
returns the corresponding proxy (the returned proxy is never null).
[Ice 3.7.10]: https://github.com/zeroc-ice/ice/blob/3.7/CHANGELOG-3.7.md
[IceRPC]: https://github.com/icerpc
[Slice/print]: cpp/test/Slice/print
zeroc-ice-3.8.1/CONTRIBUTING.md 0000664 0000000 0000000 00000002374 15165676005 0015655 0 ustar 00root root 0000000 0000000 # Contributing to Ice
Thank you for your interest in contributing to Ice!
## How to Contribute
To contribute code or documentation to this project, please follow these steps:
1. Review the [ZeroC Contributor Agreement](https://gist.github.com/zcabot/1a4c24dca55adaa83d78cdeabc63226b).
The CLA assistant bot will ask you to sign this agreement when you submit
your first pull request.
2. If you're planning to make a significant contribution, such as a new feature
or major changes, please discuss your ideas with the community first by
starting a [discussion](https://github.com/zeroc-ice/ice/discussions) or by
contacting us via [email](mailto:contributing@zeroc.com).
3. Fork this repository.
4. When implementing your contribution, please adhere to the project's naming
and coding conventions to maintain consistency in the source code.
5. Submit a pull request.
We review carefully any contribution that we accept, and these reviews may take
some time. Please keep in mind there is no guarantee your contribution will be
accepted: we may reject a pull request for any reason, or no reason.
## Contact
- GitHub Discussions:
- Twitter:
- Email:
zeroc-ice-3.8.1/LICENSE 0000664 0000000 0000000 00000043255 15165676005 0014434 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
zeroc-ice-3.8.1/Makefile 0000664 0000000 0000000 00000002024 15165676005 0015054 0 ustar 00root root 0000000 0000000 # Copyright (c) ZeroC, Inc.
top_srcdir := .
include $(top_srcdir)/config/Make.rules
define make-global-rule
$1::
+@for subdir in $2; \
do \
echo "making all in $$$$subdir"; \
( cd $$$$subdir && $(MAKE) $1 ) || exit 1; \
done
endef
$(eval $(call make-global-rule,srcs,$(languages)))
$(eval $(call make-global-rule,tests,$(languages)))
$(eval $(call make-global-rule,all,$(languages)))
$(eval $(call make-global-rule,clean,$(languages)))
$(eval $(call make-global-rule,distclean,$(languages)))
$(eval $(call make-global-rule,install,$(languages)))
#
# Install documentation and slice files (don't install IceDiscovery and IceLocatorDiscovery Lookup slice files)
#
install:: install-doc install-slice
$(eval $(call install-data-files,$(wildcard $(top_srcdir)/*LICENSE),$(top_srcdir),$(install_docdir),\
install-doc,"Installing documentation files"))
$(eval $(call install-data-files,$(filter-out Lookup.ice,$(wildcard $(slicedir)/*/*.ice)),$(slicedir),$(install_slicedir),\
install-slice,"Installing slice files"))
zeroc-ice-3.8.1/NIGHTLY.md 0000664 0000000 0000000 00000023210 15165676005 0015054 0 ustar 00root root 0000000 0000000 # Installing the Nightly Builds
This document describes the nightly builds for the 3.8 branch, which are expected to become the next 3.8.1 patch release.
Ice 3.8 nightly builds are produced daily from the 3.8 GitHub branch. For nightly builds of the next major release (3.9.0),
see `NIGHTLY.md` on the main branch.
- [Dev kits](#dev-kits)
- [Ice for C++](#ice-for-c)
- [Ice for C#](#ice-for-c-1)
- [Ice for Java](#ice-for-java)
- [Ice for JavaScript](#ice-for-javascript)
- [Ice for MATLAB](#ice-for-matlab)
- [Ice for PHP](#ice-for-php)
- [Ice for Python](#ice-for-python)
- [Ice for Ruby](#ice-for-ruby)
- [Ice for Swift](#ice-for-swift)
- [Ice Services](#ice-services)
- [Linux](#linux)
- [macOS](#macos)
- [Windows](#windows)
- [Linux Repositories](#linux-repositories)
- [RPM-based Linux (RHEL, Amazon Linux)](#rpm-based-linux-rhel-amazon-linux)
- [DEB-based Linux (Debian, Ubuntu)](#deb-based-linux-debian-ubuntu)
- [macOS Brew Formula and Cask](#macos-brew-formula-and-cask)
## Dev kits
### Ice for C++
#### Linux
First, enable the Ice nightly DNF or APT repository on your system as per [Linux Repositories](#linux-repositories).
Then, install the C++ dev kit:
##### RHEL, Amazon Linux
```shell
sudo dnf install libice-c++-devel
```
##### Debian, Ubuntu
```shell
sudo apt-get update
sudo apt-get install libzeroc-ice-dev
```
#### macOS
Ice for C++ is included in the [ice formula](#macos-brew-formula-and-cask).
#### Windows
Ice for C++ is distributed as the `ZeroC.Ice.Cpp` NuGet package on Windows.
Add the following feed to your NuGet sources to get the nightly package:
```shell
https://download.zeroc.com/nexus/repository/nuget-3.8-nightly/
```
> `ZeroC.Ice.Cpp` includes C++ libraries, header files, the Slice to C++ compiler, and the IceBox service.
### Ice for C#
Ice for C# is distributed as NuGet packages for all platforms.
Add the following feed to your NuGet sources to get the nightly packages:
```shell
https://download.zeroc.com/nexus/repository/nuget-3.8-nightly/
```
### Ice for Java
The nightly packages are available from the ZeroC `maven-3.8-nightly` Maven repository.
To use them, add the following Maven repository to your build configuration:
```shell
https://download.zeroc.com/nexus/repository/maven-3.8-nightly/
```
#### Gradle
Here’s an example configuration using Kotlin DSL:
```kotlin
// settings.gradle.kts
pluginManagement {
repositories {
gradlePluginPortal()
// Use the nightly build of the Slice Tools plugin, published to the ZeroC maven-nightly repository.
maven {
url = uri("https://download.zeroc.com/nexus/repository/maven-3.8-nightly/")
content {
includeGroupByRegex("com\\.zeroc.*")
}
}
}
}
dependencyResolutionManagement {
repositories {
mavenCentral()
// Use the nightly build of Ice, published to the ZeroC maven-nightly repository.
maven {
url = uri("https://download.zeroc.com/nexus/repository/maven-3.8-nightly/")
content {
includeGroupByRegex("com\\.zeroc.*")
}
}
}
}
```
### Ice for JavaScript
The nightly NPM package @zeroc/ice is available from the ZeroC NPM nightly registry.
To install it, add the following line to your project’s .npmrc file:
```shell
# Use ZeroC nightly registry for @zeroc packages
@zeroc:registry=https://download.zeroc.com/nexus/repository/npm-3.8-nightly/
```
Then add the `@zeroc/ice` package to your project:
```shell
npm install @zeroc/ice
```
### Ice for MATLAB
Ice toolbox for MATLAB R2025b:
- Windows: [ice-nightly-R2025b-win.mltbx](https://download.zeroc.com/ice/nightly/3.8/ice-nightly-R2025b-win.mltbx)
- Ubuntu 24.04: [ice-nightly-R2025b-linux.mltbx](https://download.zeroc.com/ice/nightly/3.8/ice-nightly-R2025b-linux.mltbx)
To install a toolbox, download the package corresponding to your platform and simply double-click on the `.mltbx` file
from MATLAB.
### Ice for PHP
#### Linux
First, enable the Ice nightly DNF or APT repository on your system as per [Linux Repositories](#linux-repositories).
Then, install the Ice for PHP package:
##### RHEL
```shell
sudo dnf install php-ice
```
##### Amazon Linux
```shell
sudo dnf install php8.4-ice
```
##### Debian, Ubuntu
```shell
sudo apt-get update
sudo apt-get install php-zeroc-ice
```
### Ice for Python
#### PyPI
The nightly package for all platforms (Linux, macOS, Windows) is available from the ZeroC PyPI nightly repository.
To install the latest zeroc-ice nightly package, add the following lines to your requirements.txt:
```shell
# Use ZeroC nightly repository as the main index for pip
--index-url https://download.zeroc.com/nexus/repository/pypi-3.8-nightly/simple/
# Allow installing packages from the official PyPI index if not found in the ZeroC repository
--extra-index-url https://pypi.org/simple/
# Enable installation of pre-release versions (required for nightly builds)
--pre
# Specify the zeroc-ice package (latest nightly version)
zeroc-ice
```
#### Linux
Ice for Python is also available as a RPM or DEB package, depending on your distribution.
First, enable the Ice nightly DNF or APT repository on your system as per [Linux Repositories](#linux-repositories).
Then, install the Ice for Python package:
##### RHEL, Amazon Linux
```shell
sudo dnf install python3-ice
```
##### Debian, Ubuntu
```shell
sudo apt-get update
sudo apt-get install python3-zeroc-ice
```
### Ice for Ruby
The nightly Ruby GEM package is available from the ZeroC RubyGems nightly repository.
You can install the latest Ruby gem by running the following command:
```shell
gem install zeroc-ice --source https://download.zeroc.com/nexus/repository/rubygems-3.8-nightly --user \
--pre --version '>= 3.8.1.pre'
```
### Ice for Swift
The nightly package is available via the Swift Package Manager (SPM).
To use it in your project, add the following URL as a dependency in your Package.swift:
```shell
https://github.com/zeroc-ice/ice-swift-nightly
```
## Ice Services
This section describes how to install the DataStorm, Glacier2, IceBox, IceBridge, IceGrid, IceStorm services, and the
associated admin tools.
> DataStorm is primarily a library-based service, installed as part of Ice for C++. The DataStorm component described
> in this section is the DataStorm server (dsnode).
### Linux
First, enable the Ice nightly DNF or APT repository on your system as per [Linux Repositories](#linux-repositories).
Then, install the desired service or tool. For example:
#### RHEL, Amazon Linux
```shell
sudo dnf install icegrid
```
Refer to the [RPM packages README] for a complete list of available service packages and their package names.
#### Debian, Ubuntu
```shell
sudo apt-get update
sudo apt-get install zeroc-icegrid
```
Refer to the [DEB packages README] for a complete list of available service packages and their package names.
### macOS
All Ice services and admin tools are included in the [ice formula](#macos-brew-formula-and-cask), except IceGrid GUI,
which is provided by a [cask](#macos-brew-formula-and-cask).
### Windows
The Ice services (Glacier2, IceGrid, IceStorm, etc.) and all admin tools for these services (IceGridGUI, icegridadmin,
etc.) are provided in a Windows installer package:
- [Ice-Services-nightly.exe](https://download.zeroc.com/ice/nightly/3.8/Ice-Services-nightly.exe)
## Linux Repositories
### RPM-based Linux (RHEL, Amazon Linux)
The nightly RPM packages for Red Hat Enterprise Linux and Amazon Linux are available from the ZeroC DNF nightly
repository.
To enable the nightly repository for your distribution run:
- Red Hat Enterprise Linux 9
```shell
sudo dnf install https://download.zeroc.com/ice/nightly/3.8/el9/ice-repo-3.8-nightly-1.0.0-1.el9.noarch.rpm
```
- Red Hat Enterprise Linux 10
```shell
sudo dnf install https://download.zeroc.com/ice/nightly/3.8/el10/ice-repo-3.8-nightly-1.0.0-1.el10.noarch.rpm
```
- Amazon Linux 2023
```shell
sudo dnf install https://download.zeroc.com/ice/nightly/3.8/amzn2023/ice-repo-3.8-nightly-1.0.0-1.amzn2023.noarch.rpm
```
See also: [RPM packages README]
### DEB-based Linux (Debian, Ubuntu)
The nightly DEB packages for Debian and Ubuntu are available from the ZeroC APT nightly repository.
To enable the nightly repository for your distribution run:
- Debian 12
```shell
wget "https://download.zeroc.com/ice/nightly/3.8/debian12/ice-repo-3.8-nightly_1.0.0_all.deb" -O ice-repo-3.8-nightly.deb
sudo dpkg -i ice-repo-3.8-nightly.deb
rm ice-repo-3.8-nightly.deb
```
- Debian 13
```shell
wget "https://download.zeroc.com/ice/nightly/3.8/debian13/ice-repo-3.8-nightly_1.0.0_all.deb" -O ice-repo-3.8-nightly.deb
sudo dpkg -i ice-repo-3.8-nightly.deb
rm ice-repo-3.8-nightly.deb
```
- Ubuntu 24.04
```shell
wget "https://download.zeroc.com/ice/nightly/3.8/ubuntu24.04/ice-repo-3.8-nightly_1.0.0_all.deb" -O ice-repo-3.8-nightly.deb
sudo dpkg -i ice-repo-3.8-nightly.deb
rm ice-repo-3.8-nightly.deb
```
See also: [DEB packages README]
## macOS Brew Formula and Cask
You can install the nightly ice@3.8 formula by running:
```shell
brew install zeroc-ice/nightly/ice@3.8
```
The ice@3.8 formula includes:
- the Ice for C++ runtime and dev kit.
- all Ice services (Glacier2, IceGrid, IceStorm, etc.) and all admin tools except IceGrid GUI.
You can install the nightly IceGridGUI cask by running:
```shell
brew install --cask zeroc-ice/nightly/icegridgui@3.9
```
[RPM packages README]: packaging/rpm/README
[DEB packages README]: packaging/deb/debian/README
zeroc-ice-3.8.1/Package.resolved 0000664 0000000 0000000 00000001252 15165676005 0016516 0 ustar 00root root 0000000 0000000 {
"originHash" : "17b3fe1bc76447ca7b611f83703debc194392a835971c87010aeb89c7e22dfd9",
"pins" : [
{
"identity" : "swift-docc-plugin",
"kind" : "remoteSourceControl",
"location" : "https://github.com/apple/swift-docc-plugin",
"state" : {
"revision" : "3e4f133a77e644a5812911a0513aeb7288b07d06",
"version" : "1.4.5"
}
},
{
"identity" : "swift-docc-symbolkit",
"kind" : "remoteSourceControl",
"location" : "https://github.com/swiftlang/swift-docc-symbolkit",
"state" : {
"revision" : "b45d1f2ed151d057b54504d653e0da5552844e34",
"version" : "1.0.0"
}
}
],
"version" : 3
}
zeroc-ice-3.8.1/Package.swift 0000664 0000000 0000000 00000006307 15165676005 0016035 0 ustar 00root root 0000000 0000000 // swift-tools-version: 6.1
import Foundation
import PackageDescription
let package = Package(
name: "ice",
defaultLocalization: "en",
platforms: [
.macOS(.v15),
.iOS(.v18),
],
products: [
.library(name: "Ice", targets: ["Ice"]),
.library(name: "Glacier2", targets: ["Glacier2"]),
.library(name: "IceGrid", targets: ["IceGrid"]),
.library(name: "IceBox", targets: ["IceBox"]),
.library(name: "IceStorm", targets: ["IceStorm"]),
.plugin(name: "CompileSlice", targets: ["CompileSlice"]),
],
dependencies: [
.package(url: "https://github.com/apple/swift-docc-plugin", from: "1.4.3")
],
targets: [
.target(
name: "Ice",
dependencies: ["IceImpl"],
path: "swift/src/Ice",
plugins: [.plugin(name: "CompileSlice")]
),
.target(
name: "Glacier2",
dependencies: ["Ice"],
path: "swift/src/Glacier2",
plugins: [.plugin(name: "CompileSlice")]
),
.target(
name: "IceGrid",
dependencies: ["Ice", "Glacier2"],
path: "swift/src/IceGrid",
plugins: [.plugin(name: "CompileSlice")]
),
.target(
name: "IceBox",
dependencies: ["Ice"],
path: "swift/src/IceBox",
plugins: [.plugin(name: "CompileSlice")]
),
.target(
name: "IceStorm",
dependencies: ["Ice"],
path: "swift/src/IceStorm",
plugins: [.plugin(name: "CompileSlice")]
),
.target(
name: "IceImpl",
dependencies: [
"IceCpp",
"IceDiscoveryCpp",
"IceLocatorDiscoveryCpp",
],
path: "swift/src/IceImpl",
linkerSettings: [
.linkedLibrary("bz2"),
.linkedFramework("ExternalAccessory"),
]
),
.binaryTarget(
name: "IceCpp",
url: "https://download.zeroc.com/ice/3.8/Ice-3.8.1.xcframework.zip",
checksum: "22d6ddc85a895321a8fb12b7cac06c12504b56849cef198517324342be719ad6"
),
.binaryTarget(
name: "IceDiscoveryCpp",
url: "https://download.zeroc.com/ice/3.8/IceDiscovery-3.8.1.xcframework.zip",
checksum: "943a3293a08fdf4d94288519c0d9d4f8815dcfd9bd83d18743b3c8361655f5cc"
),
.binaryTarget(
name: "IceLocatorDiscoveryCpp",
url: "https://download.zeroc.com/ice/3.8/IceLocatorDiscovery-3.8.1.xcframework.zip",
checksum: "371a9a8cfccb84666eba311a46e37c81d3a071dc036cfc4ba78df8e9f9e37f4a"
),
.binaryTarget(
name: "slice2swift",
url: "https://download.zeroc.com/ice/3.8/slice2swift-3.8.1.artifactbundle.zip",
checksum: "9efbeafe341c8c99c92c1fc20d4cea69dac54627dc7a9aeaa7877ad15e512ec6"
),
.plugin(
name: "CompileSlice",
capability: .buildTool(),
dependencies: ["slice2swift"],
path: "swift/Plugins/CompileSlice"
),
],
swiftLanguageModes: [.v6],
cxxLanguageStandard: .cxx20
)
zeroc-ice-3.8.1/README.md 0000664 0000000 0000000 00000012507 15165676005 0014702 0 ustar 00root root 0000000 0000000
