blob: b935aba450d324b7a6569e6f257fc18d0ab45c13 [file] [log] [blame]
Nan Zhangdb0b9a32017-02-27 10:12:13 -08001// Copyright 2017 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package python
16
17// This file contains the module types for building Python binary.
18
19import (
20 "fmt"
Cole Faust4d247e62023-01-23 10:14:58 -080021 "path/filepath"
22 "strings"
23
Nan Zhangdb0b9a32017-02-27 10:12:13 -080024 "android/soong/android"
25)
26
27func init() {
Paul Duffind0890452021-03-17 21:57:08 +000028 registerPythonBinaryComponents(android.InitRegistrationContext)
Jingwen Chen13b9b422021-03-08 07:32:28 -050029}
30
Paul Duffind0890452021-03-17 21:57:08 +000031func registerPythonBinaryComponents(ctx android.RegistrationContext) {
32 ctx.RegisterModuleType("python_binary_host", PythonBinaryHostFactory)
33}
34
Nan Zhangd4e641b2017-07-12 12:55:28 -070035type BinaryProperties struct {
Nan Zhangdb0b9a32017-02-27 10:12:13 -080036 // the name of the source file that is the main entry point of the program.
37 // this file must also be listed in srcs.
38 // If left unspecified, module name is used instead.
39 // If name doesn’t match any filename in srcs, main must be specified.
Cole Faustd82f0362023-04-12 17:32:19 -070040 Main *string
Nan Zhangdb0b9a32017-02-27 10:12:13 -080041
42 // set the name of the output binary.
Nan Zhangea568a42017-11-08 21:20:04 -080043 Stem *string `android:"arch_variant"`
Nan Zhangdb0b9a32017-02-27 10:12:13 -080044
45 // append to the name of the output binary.
Nan Zhangea568a42017-11-08 21:20:04 -080046 Suffix *string `android:"arch_variant"`
Nan Zhangc9c6cb72017-11-03 16:54:05 -070047
48 // list of compatibility suites (for example "cts", "vts") that the module should be
49 // installed into.
50 Test_suites []string `android:"arch_variant"`
Dan Willemsen6ca390f2019-02-14 23:17:08 -080051
52 // whether to use `main` when starting the executable. The default is true, when set to
53 // false it will act much like the normal `python` executable, but with the sources and
54 // libraries automatically included in the PYTHONPATH.
55 Autorun *bool `android:"arch_variant"`
Dan Shi6ffaaa82019-09-26 11:41:36 -070056
57 // Flag to indicate whether or not to create test config automatically. If AndroidTest.xml
58 // doesn't exist next to the Android.bp, this attribute doesn't need to be set to true
59 // explicitly.
60 Auto_gen_config *bool
Nan Zhangdb0b9a32017-02-27 10:12:13 -080061}
62
Cole Faust4d247e62023-01-23 10:14:58 -080063type PythonBinaryModule struct {
64 PythonLibraryModule
Nan Zhangd4e641b2017-07-12 12:55:28 -070065 binaryProperties BinaryProperties
Nan Zhangdb0b9a32017-02-27 10:12:13 -080066
Cole Faust4d247e62023-01-23 10:14:58 -080067 // (.intermediate) module output path as installation source.
68 installSource android.Path
69
70 // Final installation path.
71 installedDest android.Path
72
73 androidMkSharedLibs []string
Nan Zhangdb0b9a32017-02-27 10:12:13 -080074}
75
Cole Faust4d247e62023-01-23 10:14:58 -080076var _ android.AndroidMkEntriesProvider = (*PythonBinaryModule)(nil)
77var _ android.Module = (*PythonBinaryModule)(nil)
78
Nan Zhangd4e641b2017-07-12 12:55:28 -070079type IntermPathProvider interface {
80 IntermPathForModuleOut() android.OptionalPath
Nan Zhang5323f8e2017-05-10 13:37:54 -070081}
82
Cole Faust4d247e62023-01-23 10:14:58 -080083func NewBinary(hod android.HostOrDeviceSupported) *PythonBinaryModule {
84 return &PythonBinaryModule{
85 PythonLibraryModule: *newModule(hod, android.MultilibFirst),
86 }
Nan Zhangdb0b9a32017-02-27 10:12:13 -080087}
88
Nan Zhangd4e641b2017-07-12 12:55:28 -070089func PythonBinaryHostFactory() android.Module {
Cole Faust4d247e62023-01-23 10:14:58 -080090 return NewBinary(android.HostSupported).init()
Nan Zhangd4e641b2017-07-12 12:55:28 -070091}
92
Cole Faust4d247e62023-01-23 10:14:58 -080093func (p *PythonBinaryModule) init() android.Module {
94 p.AddProperties(&p.properties, &p.protoProperties)
95 p.AddProperties(&p.binaryProperties)
96 android.InitAndroidArchModule(p, p.hod, p.multilib)
97 android.InitDefaultableModule(p)
Cole Faust4d247e62023-01-23 10:14:58 -080098 return p
Dan Willemsen6ca390f2019-02-14 23:17:08 -080099}
100
Cole Faust4d247e62023-01-23 10:14:58 -0800101func (p *PythonBinaryModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
102 p.PythonLibraryModule.GenerateAndroidBuildActions(ctx)
103 p.buildBinary(ctx)
104 p.installedDest = ctx.InstallFile(installDir(ctx, "bin", "", ""),
105 p.installSource.Base(), p.installSource)
Nan Zhangd4e641b2017-07-12 12:55:28 -0700106}
107
Cole Faust4d247e62023-01-23 10:14:58 -0800108func (p *PythonBinaryModule) buildBinary(ctx android.ModuleContext) {
Cole Faust5c503d12023-01-24 11:48:08 -0800109 embeddedLauncher := p.isEmbeddedLauncherEnabled()
110 depsSrcsZips := p.collectPathsFromTransitiveDeps(ctx, embeddedLauncher)
Dan Willemsen6ca390f2019-02-14 23:17:08 -0800111 main := ""
Cole Faust4d247e62023-01-23 10:14:58 -0800112 if p.autorun() {
113 main = p.getPyMainFile(ctx, p.srcsPathMappings)
Dan Willemsen6ca390f2019-02-14 23:17:08 -0800114 }
Nan Zhangd4e641b2017-07-12 12:55:28 -0700115
Nan Zhangcba97e62018-09-26 15:14:10 -0700116 var launcherPath android.OptionalPath
Nan Zhang1db85402017-12-18 13:20:23 -0800117 if embeddedLauncher {
Colin Crossee6143c2017-12-30 17:54:27 -0800118 ctx.VisitDirectDepsWithTag(launcherTag, func(m android.Module) {
Nan Zhangd4e641b2017-07-12 12:55:28 -0700119 if provider, ok := m.(IntermPathProvider); ok {
Nan Zhangcba97e62018-09-26 15:14:10 -0700120 if launcherPath.Valid() {
Nan Zhangd4e641b2017-07-12 12:55:28 -0700121 panic(fmt.Errorf("launcher path was found before: %q",
Nan Zhang1db85402017-12-18 13:20:23 -0800122 launcherPath))
Nan Zhangd4e641b2017-07-12 12:55:28 -0700123 }
Nan Zhangcba97e62018-09-26 15:14:10 -0700124 launcherPath = provider.IntermPathForModuleOut()
Nan Zhangd4e641b2017-07-12 12:55:28 -0700125 }
126 })
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800127 }
Cole Faust5c503d12023-01-24 11:48:08 -0800128 srcsZips := make(android.Paths, 0, len(depsSrcsZips)+1)
129 if embeddedLauncher {
130 srcsZips = append(srcsZips, p.precompiledSrcsZip)
131 } else {
132 srcsZips = append(srcsZips, p.srcsZip)
133 }
134 srcsZips = append(srcsZips, depsSrcsZips...)
Cole Faust4d247e62023-01-23 10:14:58 -0800135 p.installSource = registerBuildActionForParFile(ctx, embeddedLauncher, launcherPath,
136 p.getHostInterpreterName(ctx, p.properties.Actual_version),
Cole Faust5c503d12023-01-24 11:48:08 -0800137 main, p.getStem(ctx), srcsZips)
Cole Faust909d2372023-02-13 23:17:40 +0000138
139 var sharedLibs []string
140 // if embedded launcher is enabled, we need to collect the shared library dependencies of the
141 // launcher
142 for _, dep := range ctx.GetDirectDepsWithTag(launcherSharedLibTag) {
143 sharedLibs = append(sharedLibs, ctx.OtherModuleName(dep))
144 }
145 p.androidMkSharedLibs = sharedLibs
Cole Faust4d247e62023-01-23 10:14:58 -0800146}
147
148func (p *PythonBinaryModule) AndroidMkEntries() []android.AndroidMkEntries {
149 entries := android.AndroidMkEntries{OutputFile: android.OptionalPathForPath(p.installSource)}
150
151 entries.Class = "EXECUTABLES"
152
153 entries.ExtraEntries = append(entries.ExtraEntries,
154 func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
155 entries.AddCompatibilityTestSuites(p.binaryProperties.Test_suites...)
156 })
157
158 entries.Required = append(entries.Required, "libc++")
159 entries.ExtraEntries = append(entries.ExtraEntries,
160 func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
161 path, file := filepath.Split(p.installedDest.String())
162 stem := strings.TrimSuffix(file, filepath.Ext(file))
163
164 entries.SetString("LOCAL_MODULE_SUFFIX", filepath.Ext(file))
165 entries.SetString("LOCAL_MODULE_PATH", path)
166 entries.SetString("LOCAL_MODULE_STEM", stem)
167 entries.AddStrings("LOCAL_SHARED_LIBRARIES", p.androidMkSharedLibs...)
168 entries.SetBool("LOCAL_CHECK_ELF_FILES", false)
169 })
170
171 return []android.AndroidMkEntries{entries}
172}
173
174func (p *PythonBinaryModule) DepsMutator(ctx android.BottomUpMutatorContext) {
175 p.PythonLibraryModule.DepsMutator(ctx)
176
Cole Faust4d247e62023-01-23 10:14:58 -0800177 if p.isEmbeddedLauncherEnabled() {
Cole Faust909d2372023-02-13 23:17:40 +0000178 p.AddDepsOnPythonLauncherAndStdlib(ctx, pythonLibTag, launcherTag, launcherSharedLibTag, p.autorun(), ctx.Target())
Cole Faust4d247e62023-01-23 10:14:58 -0800179 }
180}
181
182// HostToolPath returns a path if appropriate such that this module can be used as a host tool,
183// fulfilling the android.HostToolProvider interface.
184func (p *PythonBinaryModule) HostToolPath() android.OptionalPath {
185 // TODO: This should only be set when building host binaries -- tests built for device would be
186 // setting this incorrectly.
187 return android.OptionalPathForPath(p.installedDest)
188}
189
190// OutputFiles returns output files based on given tag, returns an error if tag is unsupported.
191func (p *PythonBinaryModule) OutputFiles(tag string) (android.Paths, error) {
192 switch tag {
193 case "":
194 return android.Paths{p.installSource}, nil
195 default:
196 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
197 }
198}
199
200func (p *PythonBinaryModule) isEmbeddedLauncherEnabled() bool {
Cole Faustf09101e2024-04-18 18:33:15 +0000201 return BoolDefault(p.properties.Embedded_launcher, true)
Cole Faust4d247e62023-01-23 10:14:58 -0800202}
203
204func (b *PythonBinaryModule) autorun() bool {
205 return BoolDefault(b.binaryProperties.Autorun, true)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800206}
207
Nan Zhangd4e641b2017-07-12 12:55:28 -0700208// get host interpreter name.
Cole Faust4d247e62023-01-23 10:14:58 -0800209func (p *PythonBinaryModule) getHostInterpreterName(ctx android.ModuleContext,
Nan Zhang1db85402017-12-18 13:20:23 -0800210 actualVersion string) string {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800211 var interp string
Nan Zhang1db85402017-12-18 13:20:23 -0800212 switch actualVersion {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800213 case pyVersion2:
Dan Willemsen7d1681a2017-09-25 13:47:40 -0700214 interp = "python2.7"
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800215 case pyVersion3:
216 interp = "python3"
217 default:
218 panic(fmt.Errorf("unknown Python actualVersion: %q for module: %q.",
Nan Zhang1db85402017-12-18 13:20:23 -0800219 actualVersion, ctx.ModuleName()))
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800220 }
221
222 return interp
223}
224
225// find main program path within runfiles tree.
Cole Faust4d247e62023-01-23 10:14:58 -0800226func (p *PythonBinaryModule) getPyMainFile(ctx android.ModuleContext,
Nan Zhangd4e641b2017-07-12 12:55:28 -0700227 srcsPathMappings []pathMapping) string {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800228 var main string
Cole Faust4d247e62023-01-23 10:14:58 -0800229 if String(p.binaryProperties.Main) == "" {
Nan Zhangd4e641b2017-07-12 12:55:28 -0700230 main = ctx.ModuleName() + pyExt
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800231 } else {
Cole Faust4d247e62023-01-23 10:14:58 -0800232 main = String(p.binaryProperties.Main)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800233 }
234
Nan Zhangd4e641b2017-07-12 12:55:28 -0700235 for _, path := range srcsPathMappings {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800236 if main == path.src.Rel() {
237 return path.dest
238 }
239 }
240 ctx.PropertyErrorf("main", "%q is not listed in srcs.", main)
241
242 return ""
243}
244
Cole Faust4d247e62023-01-23 10:14:58 -0800245func (p *PythonBinaryModule) getStem(ctx android.ModuleContext) string {
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800246 stem := ctx.ModuleName()
Cole Faust4d247e62023-01-23 10:14:58 -0800247 if String(p.binaryProperties.Stem) != "" {
248 stem = String(p.binaryProperties.Stem)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800249 }
250
Cole Faust4d247e62023-01-23 10:14:58 -0800251 return stem + String(p.binaryProperties.Suffix)
252}
253
254func installDir(ctx android.ModuleContext, dir, dir64, relative string) android.InstallPath {
255 if ctx.Arch().ArchType.Multilib == "lib64" && dir64 != "" {
256 dir = dir64
257 }
258 if !ctx.Host() && ctx.Config().HasMultilibConflict(ctx.Arch().ArchType) {
259 dir = filepath.Join(dir, ctx.Arch().ArchType.String())
260 }
261 return android.PathForModuleInstall(ctx, dir, relative)
Nan Zhangdb0b9a32017-02-27 10:12:13 -0800262}