tor-browser

autopublish-settings.gradle (7739B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// This settings file configures an Android project for substituting a
// local Application Services and/or Glean.
//
// For convenience, this file reads the `autoPublish.*` properties from
// `$topsrcdir/local.properties`, so that you only need to set them once
// for all Android projects.
//
// You can also set or override these properties on a per-project basis,
// by setting them in `$topsrcdir/mobile/android/{project}/local.properties`,
// if you want to only substitute App Services or Glean for a specific project,
// or to substitute different versions for different projects.
//
// This settings file configures the build to automatically publish the
// contents of your Application Services and Glean checkouts to the
// Maven local repository. Any dependencies are then substituted to use
// the locally published versions.

def rootLocalProperties = new File(gradle.mozconfig.topsrcdir, "local.properties").with { localPropertiesFile ->
   def localProperties = new Properties()
   if (localPropertiesFile.canRead()) {
       localPropertiesFile.withInputStream { localProperties.load(it) }
   }
   localProperties
}

[
   "autoPublish.application-services.dir",
   "autoPublish.glean.dir",
   "uniffiBindgenNoop.executable",
].each { key ->
   def relativeOrAbsolutePath = rootLocalProperties."$key"
   if (relativeOrAbsolutePath != null) {
       def autoPublishDir = new File(gradle.mozconfig.topsrcdir).toPath().resolve(relativeOrAbsolutePath)
       gradle.ext."localProperties.$key" = autoPublishDir.toString()
   }
}

gradle.settingsEvaluated {
   if (gradle.hasProperty("localProperties.autoPublish.application-services.dir")) {
       if (!gradle.hasProperty("localProperties.uniffiBindgenNoop.executable")) {
           throw new GradleException("Set uniffiBindgenNoop.executable to your local.properties in order to auto publish application-services.")
       }

       def appServicesLocalPath = gradle."localProperties.autoPublish.application-services.dir"
       logger.lifecycle("settings.gradle> Enabling automatic publication of application-services from: $appServicesLocalPath")
       // Windows can't execute .py files directly, so we assume a "manually installed" python,
       // which comes with a "py" launcher and respects the shebang line to specify the version.
       def publishAppServicesCmd = [];
       if (System.properties["os.name"].toLowerCase().contains("windows")) {
           publishAppServicesCmd << "py";
       }
       publishAppServicesCmd << "./automation/publish_to_maven_local_if_modified.py" << gradle."localProperties.uniffiBindgenNoop.executable";
       runCmd(publishAppServicesCmd, appServicesLocalPath, "Published application-services for local development.", false)
   } else {
       logger.lifecycle("settings.gradle> Disabled auto-publication of application-services. Enable it by settings 'autoPublish.application-services.dir' in local.properties")
   }

   if (gradle.hasProperty("localProperties.autoPublish.glean.dir")) {
       if (!gradle.hasProperty("localProperties.uniffiBindgenNoop.executable")) {
           throw new GradleException("Set uniffiBindgenNoop.executable to your local.properties in order to auto publish glean.")
       }

       def gleanLocalPath = gradle."localProperties.autoPublish.glean.dir"
       logger.lifecycle("settings.gradle> Enabling automatic publication of Glean from: $gleanLocalPath")
       // As above, hacks to execute .py files on Windows.
       def publishGleanCmd = [];
       if (System.properties["os.name"].toLowerCase().contains("windows")) {
           publishGleanCmd << "py";
       }

       // We do not have a fork of Glean. In order for this to work, on your local
       // copy of the Glean repo, modify this python script to accept and use the uniffi-bindgen path.
       publishGleanCmd << "./build-scripts/publish_to_maven_local_if_modified.py" << gradle."localProperties.uniffiBindgenNoop.executable";
       runCmd(publishGleanCmd, gleanLocalPath, "Published Glean for local development.", false)
   } else {
       logger.lifecycle("settings.gradle> Disabled auto-publication of Glean. Enable it by settings 'autoPublish.glean.dir' in local.properties")
   }
}

gradle.projectsLoaded { ->
   gradle.rootProject.allprojects {
       if (gradle.ext.mozconfig.substs.MOZ_APPSERVICES_IN_TREE) {
           // in tree, so we update our legacy "external" dep name to a local project.
           // ie, `"${ApplicationServicesConfig.groupId}:syncmanager:${ApplicationServicesConfig.version}"`
           // becomes `project(':syncmanager')`
           configurations.all { config ->
               if (config.isCanBeResolved()) {
                   config.resolutionStrategy { strategy ->
                       dependencySubstitution {
                           all { dependency ->
                               // We only care about substituting for a module, not a project.
                               if (!(dependency.requested instanceof ModuleComponentSelector)) {
                                   return
                               }
                               def group = dependency.requested.group
                               if (group == 'org.mozilla.appservices' || group == 'org.mozilla.appservices.nightly') {
                                   def name = dependency.requested.module
                                   // What to do about full-megazord-libsForTests is tbd - it's a convenience;
                                   // but we don't lose test coverage, just local test convience.
                                   if (name == "full-megazord-libsForTests") {
                                       name = "full-megazord"
                                   }
                                   dependency.useTarget(project(":${name}"))
                               }
                           }
                       }
                   }
               }
           }
       } else {
           // Allow local appservices substitution in each project.
           if (gradle.hasProperty("localProperties.autoPublish.application-services.dir")) {
               def appServicesSrcDir = gradle."localProperties.autoPublish.application-services.dir"
               apply from: rootProject.file("${appServicesSrcDir}/build-scripts/substitute-local-appservices.gradle")
           }
       }

       // Allow local Glean substitution in each project.
       if (gradle.hasProperty('localProperties.autoPublish.glean.dir')) {
           def gleanSrcDir = gradle."localProperties.autoPublish.glean.dir"
           apply from: rootProject.file("${gleanSrcDir}/build-scripts/substitute-local-glean.gradle")
       }
   }
}

def runCmd(cmd, workingDirectory, successMessage, captureStdout = true) {
   def proc = providers.exec {
       commandLine(cmd)
       ignoreExitValue = true
       workingDir = workingDirectory
   }

   def result = proc.result.get().exitValue

   if (result != 0) {
       def message = "Process '${cmd}' finished with non-zero exit value ${result}"
       println(message)
       proc.standardOutput.asText.get().readLines().each { println("> ${it}") }
       proc.standardError.asText.get().readLines().each { println("> ${it}") }
       throw new GradleException(message)
   } else {
       logger.lifecycle("settings.gradle> ${successMessage}")
   }
   return captureStdout ? proc.standardOutput.asText.get() : null
}