xamarin
/
xamarin-macios
зеркало из
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
xamarin-macios/dotnet/Makefile

236 строки
13 KiB
Makefile
Исходник Обычный вид История

Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
TOP = ..
include $(TOP)/Make.config
include $(TOP)/mk/rules.mk
[dotnet] Install our workloads into the dotnet directory (as symlinks).
2020-10-15 12:38:29 +03:00
DOTNET_MANIFESTS_PATH=$(DOTNET5_DIR)/sdk-manifests/$(DOTNET5_VERSION_BAND)
[dotnet] Install the Sdk and Ref packages too into the dotnet directory (as symlinks).
2020-10-15 12:39:20 +03:00
DOTNET_PACKS_PATH=$(DOTNET5_DIR)/packs
[dotnet] Create Microsoft.<platform>.Bundle.pkg packages for installing workloads manually.
2020-10-15 12:45:36 +03:00
TMP_PKG_DIR=_pkg
[dotnet] Install our workloads into the dotnet directory (as symlinks).
2020-10-15 12:38:29 +03:00
[dotnet] Create a WorkloadManifest.json for each platform.
2020-10-15 12:35:03 +03:00
# Create variables prefixed with the correctly cased platform name from the upper-cased platform name. This makes some of the next sections somewhat simpler.
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(platform)_NUGET_VERSION_NO_METADATA:=$($(shell echo $(platform) | tr a-z A-Z)_NUGET_VERSION_NO_METADATA)))
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
define DefineTargets
$(1)_NUGET_TARGETS = \
[dotnet] Add AutoImport.props.
2020-10-15 12:46:16 +03:00
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/Sdk/AutoImport.props \
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/Sdk/Sdk.targets \
[dotnet] Rename Microsoft.<platform>.Sdk.SupportedTargetPlatforms.props to Microsoft.<platform>.Sdk.SupportedTargetPlatforms.targets.
2020-10-15 17:47:55 +03:00
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Microsoft.$(1).Sdk.SupportedTargetPlatforms.targets \
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Microsoft.$(1).Sdk.DefaultItems.props \
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Microsoft.$(1).Sdk.targets \
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Microsoft.$(1).TargetFrameworkInference.targets \
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Xamarin.Shared.Sdk.DefaultItems.props \
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Xamarin.Shared.Sdk.DefaultItems.targets \
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Xamarin.Shared.Sdk.TargetFrameworkInference.targets \
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Xamarin.Shared.Sdk.targets \
[dotnet] Rename Xamarin.Shared.Sdk.Versions.props to Xamarin.Shared.Sdk.Versions.targets.
2020-10-15 17:43:29 +03:00
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Xamarin.Shared.Sdk.Versions.targets \
$(DOTNET_DESTDIR)/Microsoft.$(1).Sdk/targets/Xamarin.Shared.Sdk.Versions.template.targets
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
endef
[dotnet] Ship libxamarin.dylib and friends. (#8830) * [dotnet] Ship libxamarin.dylib and friends. Add libxamarin[-debug].[a|dylib] to the NuGets. * [dotnet] Create a DOTNET_PLATFORMS variable in Make.config. Create a DOTNET_PLATFORMS variable in Make.config and use it everywhere instead of the PLATFORMS variable we were defining in multiple Makefiles. Also move the creation of the DOTNET_<platform>_RUNTIME_IDENTIFIERS variables from dotnet/Makefile to Make.config, it'll soon be needed elsewhere as well. * [runtime] Conditionally include bits. * Make the contents of the DOTNET_[PLATFORMS|RUNTIME_IDENTIFIERS] variables depend on the INCLUDE_[IOS|TVOS|WATCH] variables.
2020-06-15 18:47:18 +03:00
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call DefineTargets,$(platform))))
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
DIRECTORIES += \
$(DOTNET_NUPKG_DIR) \
[dotnet] Create Microsoft.<platform>.Bundle.pkg packages for installing workloads manually.
2020-10-15 12:45:36 +03:00
$(DOTNET_PKG_DIR) \
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
$(DOTNET_FEED_DIR) \
[dotnet] Ship libxamarin.dylib and friends. (#8830) * [dotnet] Ship libxamarin.dylib and friends. Add libxamarin[-debug].[a|dylib] to the NuGets. * [dotnet] Create a DOTNET_PLATFORMS variable in Make.config. Create a DOTNET_PLATFORMS variable in Make.config and use it everywhere instead of the PLATFORMS variable we were defining in multiple Makefiles. Also move the creation of the DOTNET_<platform>_RUNTIME_IDENTIFIERS variables from dotnet/Makefile to Make.config, it'll soon be needed elsewhere as well. * [runtime] Conditionally include bits. * Make the contents of the DOTNET_[PLATFORMS|RUNTIME_IDENTIFIERS] variables depend on the INCLUDE_[IOS|TVOS|WATCH] variables.
2020-06-15 18:47:18 +03:00
$(foreach platform,$(DOTNET_PLATFORMS),$(DOTNET_DESTDIR)/Microsoft.$(platform).Sdk/Sdk) \
$(foreach platform,$(DOTNET_PLATFORMS),$(DOTNET_DESTDIR)/Microsoft.$(platform).Sdk/targets) \
[dotnet] Install our workloads into the dotnet directory (as symlinks).
2020-10-15 12:38:29 +03:00
$(DOTNET_MANIFESTS_PATH) \
[dotnet] Install the Sdk and Ref packages too into the dotnet directory (as symlinks).
2020-10-15 12:39:20 +03:00
$(DOTNET_PACKS_PATH) \
$(foreach platform,$(DOTNET_PLATFORMS),$(DOTNET_PACKS_PATH)/Microsoft.$(platform).Sdk) \
$(foreach platform,$(DOTNET_PLATFORMS),$(DOTNET_PACKS_PATH)/Microsoft.$(platform).Ref) \
[dotnet] Create Microsoft.<platform>.Bundle.pkg packages for installing workloads manually.
2020-10-15 12:45:36 +03:00
$(TMP_PKG_DIR) \
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
$(DIRECTORIES):
$(Q) mkdir -p $@
CURRENT_HASH_LONG:=$(shell git log -1 --pretty=%H)
[dotnet] Ship libxamarin.dylib and friends. (#8830) * [dotnet] Ship libxamarin.dylib and friends. Add libxamarin[-debug].[a|dylib] to the NuGets. * [dotnet] Create a DOTNET_PLATFORMS variable in Make.config. Create a DOTNET_PLATFORMS variable in Make.config and use it everywhere instead of the PLATFORMS variable we were defining in multiple Makefiles. Also move the creation of the DOTNET_<platform>_RUNTIME_IDENTIFIERS variables from dotnet/Makefile to Make.config, it'll soon be needed elsewhere as well. * [runtime] Conditionally include bits. * Make the contents of the DOTNET_[PLATFORMS|RUNTIME_IDENTIFIERS] variables depend on the INCLUDE_[IOS|TVOS|WATCH] variables.
2020-06-15 18:47:18 +03:00
$(DOTNET_DESTDIR)/Microsoft.%: Microsoft.% | $(foreach platform,$(DOTNET_PLATFORMS),$(DOTNET_DESTDIR)/Microsoft.$(platform).Sdk/Sdk $(DOTNET_DESTDIR)/Microsoft.$(platform).Sdk/targets)
[dotnet] Add the Sdk build files to the Sdk NuGet. (#8644) Also add a very simple net5 test app (which doesn't build yet). Current (expected) build result: > xamarin-macios/tests/dotnet/MySingleView $ dotnet build Microsoft (R) Build Engine version 16.7.0-preview-20258-02+26f6d1d87 for .NET Copyright (C) Microsoft Corporation. All rights reserved. Determining projects to restore... xamarin-macios/tests/dotnet/MySingleView/MySingleView.csproj : error NU1102: Unable to find package Microsoft.NETCore.App.Runtime.ios-x64 with version (= 5.0.0-preview.6.20264.1) xamarin-macios/tests/dotnet/MySingleView/MySingleView.csproj : error NU1102: - Found 1 version(s) in nuget.org [ Nearest version: 5.0.0-preview.4.20251.6 ] xamarin-macios/tests/dotnet/MySingleView/MySingleView.csproj : error NU1102: - Found 1 version(s) in Nuget Official [ Nearest version: 5.0.0-preview.4.20251.6 ] xamarin-macios/tests/dotnet/MySingleView/MySingleView.csproj : error NU1102: - Found 0 version(s) in local-dotnet-feed xamarin-macios/tests/dotnet/MySingleView/MySingleView.csproj : error NU1102: - Found 0 version(s) in Dotnet arcade Failed to restore xamarin-macios/tests/dotnet/MySingleView/MySingleView.csproj (in 951 ms). This fails because the .NET build logic isn't being told that it should look for the mono runtime packs instead of the .NET Core runtime packs.
2020-05-25 16:22:29 +03:00
$(Q) $(CP) $< $@
$(DOTNET_DESTDIR)/Microsoft.iOS.Sdk/targets/%: targets/% | $(DOTNET_DESTDIR)/Microsoft.iOS.Sdk/targets
$(Q) $(CP) $< $@
$(DOTNET_DESTDIR)/Microsoft.tvOS.Sdk/targets/%: targets/% | $(DOTNET_DESTDIR)/Microsoft.tvOS.Sdk/targets
$(Q) $(CP) $< $@
$(DOTNET_DESTDIR)/Microsoft.watchOS.Sdk/targets/%: targets/% | $(DOTNET_DESTDIR)/Microsoft.watchOS.Sdk/targets
$(Q) $(CP) $< $@
$(DOTNET_DESTDIR)/Microsoft.macOS.Sdk/targets/%: targets/% | $(DOTNET_DESTDIR)/Microsoft.macOS.Sdk/targets
$(Q) $(CP) $< $@
[dotnet] Rename Xamarin.Shared.Sdk.Versions.props to Xamarin.Shared.Sdk.Versions.targets.
2020-10-15 17:43:29 +03:00
targets/%.targets: targets/%.template.targets Makefile $(TOP)/Make.config.inc $(TOP)/.git/HEAD $(TOP)/.git/index
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
$(Q_GEN) sed \
-e "s/@IOS_NUGET_VERSION_NO_METADATA@/$(IOS_NUGET_VERSION_NO_METADATA)/g" \
-e "s/@TVOS_NUGET_VERSION_NO_METADATA@/$(TVOS_NUGET_VERSION_NO_METADATA)/g" \
-e "s/@WATCHOS_NUGET_VERSION_NO_METADATA@/$(WATCHOS_NUGET_VERSION_NO_METADATA)/g" \
-e "s/@MACOS_NUGET_VERSION_NO_METADATA@/$(MACOS_NUGET_VERSION_NO_METADATA)/g" \
-e "s/@IOS_NUGET_VERSION_FULL@/$(IOS_NUGET_VERSION_FULL)/g" \
-e "s/@TVOS_NUGET_VERSION_FULL@/$(TVOS_NUGET_VERSION_FULL)/g" \
-e "s/@WATCHOS_NUGET_VERSION_FULL@/$(WATCHOS_NUGET_VERSION_FULL)/g" \
-e "s/@MACOS_NUGET_VERSION_FULL@/$(MACOS_NUGET_VERSION_FULL)/g" \
-e "s/@CURRENT_BRANCH@/$(CURRENT_BRANCH_SED_ESCAPED)/g" \
-e "s/@CURRENT_HASH_LONG@/$(CURRENT_HASH_LONG)/g" \
$< > $@
[dotnet] Use net5.0-[ios|tvos|watchos|macos] TargetFrameworks. (#9532) * [dotnet] Set TargetPlatformSupported when the right TargetPlatformIdentifier is used. * [dotnet] Generate a list of valid OS versions for each platform, and add it to the SupportedTargetPlatform item group. The generated files: https://gist.github.com/rolfbjarne/765c4e4b38b1b017380c9378d9666317 * [dotnet] Define and set the default platform version if it's not set in the TargetFramework variable. * [dotnet] Switch to using the new-style TargetFramework values. This includes bumping spouliot/Touch.Unit to get new-style TargetFramework values for Touch.Client. * spouliot/Touch.Unit@89afaf7 [Touch.Client] Use the right TargetFrameworks for watchOS and macOS as well. (#92) * spouliot/Touch.Unit@fd0e576 [Touch.Client] Use the right TargetFrameworks. (#91) * spouliot/Touch.Unit@40f47db [Touch.Client] Add a macOS and watchOS version for .NET. (#90) * spouliot/Touch.Unit@1d4b8c0 Add .gitignore for NuGet.config and global.json. (#89) * spouliot/Touch.Unit@49441f3 Call `mlaunch` instead of `mtouch` (#88) * spouliot/Touch.Unit@b157cf4 Fix a few markdown issues found by markdownlint. (#87) Diff: https://github.com/spouliot/Touch.Unit/compare/d7f55a61673e18ae5a8f9628600081a54b4e074c..89afaf7e05a942c87231cf5601b3a5b59640e218 * [dotnet] Document the script that generates the lists of the target platform versions a little bit better. * [dotnet] Make the [Platform]SupportedTargetPlatform variables public. This matches how Android and Windows do it: * https://github.com/xamarin/xamarin-android/pull/5007 * https://github.com/dotnet/sdk/blob/18ee4eac8b3abe6d554d2e0c39d8952da0f23ce5/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.WindowsSupportedTargetPlatforms.props * [xharness] Update the TargetFramework value when creating project variations.
2020-08-31 10:27:19 +03:00
define SupportedTargetPlatforms
[dotnet] Rename Microsoft.<platform>.Sdk.SupportedTargetPlatforms.props to Microsoft.<platform>.Sdk.SupportedTargetPlatforms.targets.
2020-10-15 17:47:55 +03:00
Microsoft.$(1).Sdk/targets/Microsoft.$(1).Sdk.SupportedTargetPlatforms.targets: $(TOP)/Versions-ios.plist.in $(TOP)/Versions-mac.plist.in Makefile ./generate-target-platforms.csharp Makefile
[dotnet] Use net5.0-[ios|tvos|watchos|macos] TargetFrameworks. (#9532) * [dotnet] Set TargetPlatformSupported when the right TargetPlatformIdentifier is used. * [dotnet] Generate a list of valid OS versions for each platform, and add it to the SupportedTargetPlatform item group. The generated files: https://gist.github.com/rolfbjarne/765c4e4b38b1b017380c9378d9666317 * [dotnet] Define and set the default platform version if it's not set in the TargetFramework variable. * [dotnet] Switch to using the new-style TargetFramework values. This includes bumping spouliot/Touch.Unit to get new-style TargetFramework values for Touch.Client. * spouliot/Touch.Unit@89afaf7 [Touch.Client] Use the right TargetFrameworks for watchOS and macOS as well. (#92) * spouliot/Touch.Unit@fd0e576 [Touch.Client] Use the right TargetFrameworks. (#91) * spouliot/Touch.Unit@40f47db [Touch.Client] Add a macOS and watchOS version for .NET. (#90) * spouliot/Touch.Unit@1d4b8c0 Add .gitignore for NuGet.config and global.json. (#89) * spouliot/Touch.Unit@49441f3 Call `mlaunch` instead of `mtouch` (#88) * spouliot/Touch.Unit@b157cf4 Fix a few markdown issues found by markdownlint. (#87) Diff: https://github.com/spouliot/Touch.Unit/compare/d7f55a61673e18ae5a8f9628600081a54b4e074c..89afaf7e05a942c87231cf5601b3a5b59640e218 * [dotnet] Document the script that generates the lists of the target platform versions a little bit better. * [dotnet] Make the [Platform]SupportedTargetPlatform variables public. This matches how Android and Windows do it: * https://github.com/xamarin/xamarin-android/pull/5007 * https://github.com/dotnet/sdk/blob/18ee4eac8b3abe6d554d2e0c39d8952da0f23ce5/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.WindowsSupportedTargetPlatforms.props * [xharness] Update the TargetFramework value when creating project variations.
2020-08-31 10:27:19 +03:00
$(Q) rm -f $$@.tmp
$(Q) ./generate-target-platforms.csharp $(1) $$@.tmp
$(Q) mv $$@.tmp $$@
endef
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call SupportedTargetPlatforms,$(platform))))
[dotnet] Create a WorkloadManifest.json for each platform.
2020-10-15 12:35:03 +03:00
define WorkloadTargets
Microsoft.NET.Workload.$(1)/WorkloadManifest.json: targets/WorkloadManifest.template.json Makefile $(TOP)/Make.config.inc $(TOP)/.git/HEAD $(TOP)/.git/index
$$(Q) rm -f $$@.tmp
$$(Q_GEN) sed \
-e "s/@VERSION@/$3/g" \
-e "s/@PLATFORM_LOWERCASE@/$2/g" \
-e "s/@PLATFORM@/$1/g" \
$$< > $$@.tmp
$$(Q) mv $$@.tmp $$@
WORKLOAD_TARGETS += Microsoft.NET.Workload.$(1)/WorkloadManifest.json
endef
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call WorkloadTargets,$(platform),$(shell echo $(platform) | tr A-Z a-z),$($(platform)_NUGET_VERSION_NO_METADATA))))
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
TEMPLATED_FILES = \
[dotnet] Rename Xamarin.Shared.Sdk.Versions.props to Xamarin.Shared.Sdk.Versions.targets.
2020-10-15 17:43:29 +03:00
targets/Xamarin.Shared.Sdk.Versions.targets \
[dotnet] Rename Microsoft.<platform>.Sdk.SupportedTargetPlatforms.props to Microsoft.<platform>.Sdk.SupportedTargetPlatforms.targets.
2020-10-15 17:47:55 +03:00
$(foreach platform,$(DOTNET_PLATFORMS),Microsoft.$(platform).Sdk/targets/Microsoft.$(platform).Sdk.SupportedTargetPlatforms.targets) \
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
nupkgs/$(IOS_NUGET).%.nupkg: CURRENT_VERSION_NO_METADATA=$(IOS_NUGET_VERSION_NO_METADATA)
nupkgs/$(TVOS_NUGET).%.nupkg: CURRENT_VERSION_NO_METADATA=$(TVOS_NUGET_VERSION_NO_METADATA)
nupkgs/$(WATCHOS_NUGET).%.nupkg: CURRENT_VERSION_NO_METADATA=$(WATCHOS_NUGET_VERSION_NO_METADATA)
nupkgs/$(MACOS_NUGET).%.nupkg: CURRENT_VERSION_NO_METADATA=$(MACOS_NUGET_VERSION_NO_METADATA)
nupkgs/$(IOS_NUGET).%.nupkg: CURRENT_VERSION_FULL=$(IOS_NUGET_VERSION_FULL)
nupkgs/$(TVOS_NUGET).%.nupkg: CURRENT_VERSION_FULL=$(TVOS_NUGET_VERSION_FULL)
nupkgs/$(WATCHOS_NUGET).%.nupkg: CURRENT_VERSION_FULL=$(WATCHOS_NUGET_VERSION_FULL)
nupkgs/$(MACOS_NUGET).%.nupkg: CURRENT_VERSION_FULL=$(MACOS_NUGET_VERSION_FULL)
# Create the nuget in a temporary directory (nupkgs/)
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
define CreateNuGetTemplate
[dotnet] Use the exact same dotnet version in our global.jsons as in Make.config. (#8984) This avoids a possible difference in behavior, because in our system dependency check we verify that the system has a specific version (which might succeed), but if we don't pick a specific dotnet version in global.json, dotnet will pick the latest version, which may behave differently than the one we have in Make.config. Thus always use the exact same version, so that we don't run into a difference in behavior between developers and/or bots.
2020-07-01 18:08:46 +03:00
nupkgs/$(1).$(2)+$(NUGET_BUILD_METADATA).nupkg: $(TEMPLATED_FILES) $(3) package/$(1)/package.csproj $(wildcard package/*.csproj) $(wildcard $(DOTNET_DESTDIR)/$(1)/* $(DOTNET_DESTDIR)/$(1)/*/* $(DOTNET_DESTDIR)/$(1)/*/*/* $(DOTNET_DESTDIR)/$(1)/*/*/*/*) global.json
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
@# Delete any versions of the nuget we're building
$$(Q) rm -f nupkgs/$(1).*.nupkg
$$(Q_PACK) $(DOTNET5) pack package/$(1)/package.csproj --output "$$(dir $$@)" $(DOTNET_PACK_VERBOSITY)
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
@# Nuget pack doesn't add the metadata to the filename, but we want that, so rename nuget to contain the full name
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
$$(Q) mv "nupkgs/$(1).$(2).nupkg" "$$@"
@# Clean the local feed
$$(Q_NUGET_DEL) if test -d $(DOTNET_FEED_DIR)/$(shell echo $(1) | tr A-Z a-z)/$(2); then nuget delete $(1) $(2) -source $(abspath $(DOTNET_FEED_DIR)) -NonInteractive $(NUGET_VERBOSITY); fi
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
@# Add the nupkg to our local feed
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
$$(Q_NUGET_ADD) nuget add "$$@" -source $(DOTNET_FEED_DIR) -NonInteractive $(NUGET_VERBOSITY)
endef
# Create the NuGet packaging targets. It's amazing what make allows you to do...
[dotnet] Ship libxamarin.dylib and friends. (#8830) * [dotnet] Ship libxamarin.dylib and friends. Add libxamarin[-debug].[a|dylib] to the NuGets. * [dotnet] Create a DOTNET_PLATFORMS variable in Make.config. Create a DOTNET_PLATFORMS variable in Make.config and use it everywhere instead of the PLATFORMS variable we were defining in multiple Makefiles. Also move the creation of the DOTNET_<platform>_RUNTIME_IDENTIFIERS variables from dotnet/Makefile to Make.config, it'll soon be needed elsewhere as well. * [runtime] Conditionally include bits. * Make the contents of the DOTNET_[PLATFORMS|RUNTIME_IDENTIFIERS] variables depend on the INCLUDE_[IOS|TVOS|WATCH] variables.
2020-06-15 18:47:18 +03:00
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call CreateNuGetTemplate,Microsoft.$(platform).Sdk,$($(platform)_NUGET_VERSION_NO_METADATA),$($(platform)_NUGET_TARGETS))))
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call CreateNuGetTemplate,Microsoft.$(platform).Ref,$($(platform)_NUGET_VERSION_NO_METADATA))))
$(foreach platform,$(DOTNET_PLATFORMS),$(foreach rid,$(DOTNET_$(platform)_RUNTIME_IDENTIFIERS),$(eval $(call CreateNuGetTemplate,Microsoft.$(platform).Runtime.$(rid),$($(platform)_NUGET_VERSION_NO_METADATA)))))
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
# Copy the nuget from the temporary directory into the final directory
$(DOTNET_NUPKG_DIR)/%.nupkg: nupkgs/%.nupkg | $(DOTNET_NUPKG_DIR)
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
$(Q) $(CP) $< $@
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
[dotnet] Improve incremental builds in make. (#8754) * Be more exact when specifying dependencies for nuget packages: instead of making every package depend on every file within this directory, only make the specific package the files go into depend on those files. This means that if any of these files change, only the package that contains that file will be rebuilt. * Have each package depend on all the files that are to be included in that package. This means that if any other directory adds or updates a file for a nuget, we'll rebuild that nuget here. * Removes packages from the local feed before trying to (re-)add them. This makes them actually install locally, instead of nuget just skipping them, when the version hasn't changed. This was easier to express with make templates than pattern rules, so some of the logic was re-implemented as make templates.
2020-06-04 17:39:19 +03:00
RUNTIME_PACKS_IOS = $(foreach rid,$(DOTNET_IOS_RUNTIME_IDENTIFIERS),$(DOTNET_NUPKG_DIR)/$(IOS_NUGET).Runtime.$(rid).$(IOS_NUGET_VERSION_FULL).nupkg)
RUNTIME_PACKS_TVOS = $(foreach rid,$(DOTNET_TVOS_RUNTIME_IDENTIFIERS),$(DOTNET_NUPKG_DIR)/$(TVOS_NUGET).Runtime.$(rid).$(TVOS_NUGET_VERSION_FULL).nupkg)
RUNTIME_PACKS_WATCHOS = $(foreach rid,$(DOTNET_WATCHOS_RUNTIME_IDENTIFIERS),$(DOTNET_NUPKG_DIR)/$(WATCHOS_NUGET).Runtime.$(rid).$(WATCHOS_NUGET_VERSION_FULL).nupkg)
RUNTIME_PACKS_MACOS = $(foreach rid,$(DOTNET_MACOS_RUNTIME_IDENTIFIERS),$(DOTNET_NUPKG_DIR)/$(MACOS_NUGET).Runtime.$(rid).$(MACOS_NUGET_VERSION_FULL).nupkg)
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
RUNTIME_PACKS = $(RUNTIME_PACKS_IOS) $(RUNTIME_PACKS_TVOS) $(RUNTIME_PACKS_WATCHOS) $(RUNTIME_PACKS_MACOS)
REF_PACK_IOS = $(DOTNET_NUPKG_DIR)/$(IOS_NUGET).Ref.$(IOS_NUGET_VERSION_FULL).nupkg
REF_PACK_TVOS = $(DOTNET_NUPKG_DIR)/$(TVOS_NUGET).Ref.$(TVOS_NUGET_VERSION_FULL).nupkg
REF_PACK_WATCHOS = $(DOTNET_NUPKG_DIR)/$(WATCHOS_NUGET).Ref.$(WATCHOS_NUGET_VERSION_FULL).nupkg
REF_PACK_MACOS = $(DOTNET_NUPKG_DIR)/$(MACOS_NUGET).Ref.$(MACOS_NUGET_VERSION_FULL).nupkg
REF_PACKS = $(REF_PACK_IOS) $(REF_PACK_TVOS) $(REF_PACK_WATCHOS) $(REF_PACK_MACOS)
SDK_PACK_IOS = $(DOTNET_NUPKG_DIR)/$(IOS_NUGET).Sdk.$(IOS_NUGET_VERSION_FULL).nupkg
SDK_PACK_TVOS = $(DOTNET_NUPKG_DIR)/$(TVOS_NUGET).Sdk.$(TVOS_NUGET_VERSION_FULL).nupkg
SDK_PACK_WATCHOS = $(DOTNET_NUPKG_DIR)/$(WATCHOS_NUGET).Sdk.$(WATCHOS_NUGET_VERSION_FULL).nupkg
SDK_PACK_MACOS = $(DOTNET_NUPKG_DIR)/$(MACOS_NUGET).Sdk.$(MACOS_NUGET_VERSION_FULL).nupkg
SDK_PACKS = $(SDK_PACK_IOS) $(SDK_PACK_TVOS) $(SDK_PACK_WATCHOS) $(SDK_PACK_MACOS)
pack-ios: $(RUNTIME_PACKS_IOS) $(REF_PACK_IOS) $(SDK_PACK_IOS)
pack-tvos: $(RUNTIME_PACKS_TVOS) $(REF_PACK_TVOS) $(SDK_PACK_TVOS)
pack-watchos: $(RUNTIME_PACKS_WATCHOS) $(REF_PACK_WATCHOS) $(SDK_PACK_WATCHOS)
pack-macos: $(RUNTIME_PACKS_MACOS) $(REF_PACK_MACOS) $(SDK_PACK_MACOS)
TARGETS += $(RUNTIME_PACKS) $(REF_PACKS) $(SDK_PACKS)
[dotnet] Install our workloads into the dotnet directory (as symlinks).
2020-10-15 12:38:29 +03:00
define InstallWorkload
$(DOTNET_MANIFESTS_PATH)/Microsoft.NET.Workload.$1: | $(DOTNET_MANIFESTS_PATH)
$$(Q_LN) ln -Fhs $$(abspath Microsoft.NET.Workload.$1) $$(abspath $$@)
[dotnet] Install the Sdk and Ref packages too into the dotnet directory (as symlinks).
2020-10-15 12:39:20 +03:00
$(DOTNET_PACKS_PATH)/Microsoft.$1.Sdk/$2: | $(DOTNET_PACKS_PATH)/Microsoft.$1.Sdk
$$(Q_LN) ln -Fhs $$(abspath $(DOTNET_DESTDIR)/Microsoft.$1.Sdk) $$(abspath $$@)
$(DOTNET_PACKS_PATH)/Microsoft.$1.Ref/$2: | $(DOTNET_PACKS_PATH)/Microsoft.$1.Ref
$$(Q_LN) ln -Fhs $$(abspath $(DOTNET_DESTDIR)/Microsoft.$1.Ref) $$(abspath $$@)
[dotnet] Install our workloads into the dotnet directory (as symlinks).
2020-10-15 12:38:29 +03:00
WORKLOAD_TARGETS += \
$(DOTNET_MANIFESTS_PATH)/Microsoft.NET.Workload.$1 \
[dotnet] Install the Sdk and Ref packages too into the dotnet directory (as symlinks).
2020-10-15 12:39:20 +03:00
$(DOTNET_PACKS_PATH)/Microsoft.$1.Sdk/$2 \
$(DOTNET_PACKS_PATH)/Microsoft.$1.Ref/$2
[dotnet] Install our workloads into the dotnet directory (as symlinks).
2020-10-15 12:38:29 +03:00
endef
[dotnet] Create Microsoft.<platform>.Bundle.pkg packages for installing workloads manually.
2020-10-15 12:45:36 +03:00
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call InstallWorkload,$(platform),$($(platform)_NUGET_VERSION_NO_METADATA))))
# We create three packages: one for the workload, one for the sdk package, and one for the ref package,
# and then bundle them into a single pkg for distribution (named Microsoft.<platform>.Bundle.<version>.pkg).
# This way we can create and publish separate updated for each workload/sdk/ref package later if we want to.
define CreatePackage
# The workload package
$(TMP_PKG_DIR)/Microsoft.$1.Workload.$2.pkg: $($(1)_NUGET_TARGETS) $(WORKLOAD_TARGETS) Makefile | $(TMP_PKG_DIR)
$$(Q) rm -f $$@
$$(Q_GEN) pkgbuild --quiet --version '$2' --root Microsoft.NET.Workload.$1 --component-plist PackageInfo.plist --install-location /usr/local/share/dotnet/sdk-manifests/$(DOTNET5_VERSION_BAND)/Microsoft.NET.Workload.$1 --identifier com.microsoft.net.$3.workload.pkg $$@.tmp
$$(Q) mv $$@.tmp $$@
# The sdk package
$(TMP_PKG_DIR)/Microsoft.$1.Sdk.$2.pkg: $(REF_PACK_$(4)) | $(TMP_PKG_DIR)
$$(Q) rm -f $$@
$$(Q_GEN) pkgbuild --quiet --version '$2' --root $(DOTNET_DESTDIR)/Microsoft.$1.Sdk --component-plist PackageInfo.plist --install-location /usr/local/share/dotnet/packs/Microsoft.$1.Sdk/$2 --identifier com.microsoft.net.$3.sdk.pkg $$@.tmp
$$(Q) mv $$@.tmp $$@
# The ref package
$(TMP_PKG_DIR)/Microsoft.$1.Ref.$2.pkg: $(SDK_PACK_$(4)) | $(TMP_PKG_DIR)
$$(Q) rm -f $$@
$$(Q_GEN) pkgbuild --quiet --version '$2' --root $(DOTNET_DESTDIR)/Microsoft.$1.Ref --component-plist PackageInfo.plist --install-location /usr/local/share/dotnet/packs/Microsoft.$1.Ref/$2 --identifier com.microsoft.net.$3.ref.pkg $$@.tmp
$$(Q) mv $$@.tmp $$@
# The final bundle package for distribution
$(TMP_PKG_DIR)/Microsoft.$1.Bundle.$2.pkg: $(TMP_PKG_DIR)/Microsoft.$1.Workload.$2.pkg $(TMP_PKG_DIR)/Microsoft.$1.Sdk.$2.pkg $(TMP_PKG_DIR)/Microsoft.$1.Ref.$2.pkg
$$(Q) rm -f $$@
$$(Q_GEN) productbuild \
--quiet \
--identifier com.microsoft.net.$3.pkg \
--version '$2' \
--package $(TMP_PKG_DIR)/Microsoft.$1.Workload.$2.pkg \
--package $(TMP_PKG_DIR)/Microsoft.$1.Sdk.$2.pkg \
--package $(TMP_PKG_DIR)/Microsoft.$1.Ref.$2.pkg \
$$@.tmp
$$(Q) mv $$@.tmp $$@
# Copy the bundle package from our temporary directory to the target directory
$(DOTNET_PKG_DIR)/Microsoft.$1.Bundle.$2.pkg: $(TMP_PKG_DIR)/Microsoft.$1.Bundle.$2.pkg | $(DOTNET_PKG_DIR)
$$(Q) $(CP) $$< $$@
PACKAGE_TARGETS += $(DOTNET_PKG_DIR)/Microsoft.$1.Bundle.$2.pkg
endef
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call CreatePackage,$(platform),$($(platform)_NUGET_VERSION_NO_METADATA),$(shell echo $(platform) | tr A-Z a-z),$(shell echo $(platform) | tr a-z A-Z))))
[dotnet] Install our workloads into the dotnet directory (as symlinks).
2020-10-15 12:38:29 +03:00
TARGETS += $(WORKLOAD_TARGETS)
[dotnet] Create Microsoft.<platform>.Bundle.pkg packages for installing workloads manually.
2020-10-15 12:45:36 +03:00
package: $(PACKAGE_TARGETS)
Only build dotnet/ if dotnet is enabled. (#8614)
2020-05-20 10:26:27 +03:00
ifdef ENABLE_DOTNET
[dotnet] Rename Xamarin.Shared.Sdk.Versions.props to Xamarin.Shared.Sdk.Versions.targets.
2020-10-15 17:43:29 +03:00
all-local:: $(TARGETS) targets/Xamarin.Shared.Sdk.Versions.targets
Only build dotnet/ if dotnet is enabled. (#8614)
2020-05-20 10:26:27 +03:00
endif
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
[dotnet] Use the exact same dotnet version in our global.jsons as in Make.config. (#8984) This avoids a possible difference in behavior, because in our system dependency check we verify that the system has a specific version (which might succeed), but if we don't pick a specific dotnet version in global.json, dotnet will pick the latest version, which may behave differently than the one we have in Make.config. Thus always use the exact same version, so that we don't run into a difference in behavior between developers and/or bots.
2020-07-01 18:08:46 +03:00
# This tells NuGet to use the exact same dotnet version we've configured in Make.config
[src] Build the .NET version of our product assemblies using a .NET 5 BCL. (#9637) * [src] Build the .NET version of our product assemblies using a .NET 5 BCL. We're not shipping the .NET product assemblies in any stable release, so we can use a preview version of the .NET 5 BCL. Also: * Add all the nuget feeds we need to the top-level NuGet.config, even for .NET 5/6, there shouldn't be any conflicts with stable feeds since we use exact version numbers. * Generate a top-level global5.json which is copied to every directory that needs a .NET 5 global.json (overriding the .NET 3.1 global.json in the root directory). * Use the expected dotnet binary during our local build. * [tests] Fix the bgen tests to use .NET 5. * [xharness] Set the current directory to the project directory when running .NET tests. This way we end up using the dotnet version that's configured in global.json for the tests.
2020-09-21 14:22:44 +03:00
global.json: $(TOP)/global5.json
$(CP) $< $@
[dotnet] Use the exact same dotnet version in our global.jsons as in Make.config. (#8984) This avoids a possible difference in behavior, because in our system dependency check we verify that the system has a specific version (which might succeed), but if we don't pick a specific dotnet version in global.json, dotnet will pick the latest version, which may behave differently than the one we have in Make.config. Thus always use the exact same version, so that we don't run into a difference in behavior between developers and/or bots.
2020-07-01 18:08:46 +03:00
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
clean-local::
[dotnet] Improve the 'clean' target. (#8729) Don't nuke the entire DOTNET_DESTDIR, because that means it will be necessary to run 'make' in the top-level directory again. Instead only clean files that the dotnet/ directory will re-build.
2020-06-03 10:00:19 +03:00
$(Q) rm -Rf $(DOTNET_NUPKG_DIR) $(DOTNET_FEED_DIR)
Create and publish .NET NuGet packages. (#8576) Create the various NuGet packages to support .NET 5+. The packages are currently empty (and not very useful), but the actual content will come later. The current set of NuGet packages are (this list is duplicated for each platform: iOS, tvOS, watchOS and macOS): * Microsoft.iOS.Sdk: currently contains the basic MSBuild targets files for an MSBuild Project SDK. Will eventually contain all the build logic. Might also eventually contain other tools (mlaunch, bgen, etc.), but these might also end up in a different package. * Microsoft.iOS.Ref: will contain the Xamarin.iOS.dll reference assembly. * Microsoft.iOS.Runtime.[RID]: will contain architecture-specific files (libxamarin*.dylib, the Xamarin.iOS.dll implementation assembly, etc.): The NuGets built on CI are automatically published to a NuGet feed. The versioning for the NuGet packages required a few changes: OS bumps are now changed in Make.versions instead of Make.config (this is explained in the files themselves as well).
2020-05-13 16:23:29 +03:00
$(Q) git clean -xfdq
.SECONDARY: