Skeleton for publishing to a local repo

LocalRepoPublish

trait CommonPublishModule extends LocalRepoPublishModule {
  def sonatypeUri: String = "http://artifactory.mysite.dev/artifactory/libs-release/"

  def publishVersion = "0.9.9"
  ... etc ...
}

import mill.define.{ExternalModule, Task}
import mill.api.PathRef
import mill.scalalib.publish.Artifact
import mill.scalalib.JavaModule

import $file.SonatypePublisher, SonatypePublisher.SonatypePublisher
/**
  * Configuration necessary for publishing a Scala module to Maven Central or similar
  */
trait LocalRepoPublishModule extends JavaModule { outer =>
  import mill.scalalib.publish.{Artifact => _, SonatypePublisher => _, _}

  override def moduleDeps = Seq.empty[LocalRepoPublishModule]

  def pomSettings: T[PomSettings]
  def publishVersion: T[String]

  def publishSelfDependency = T {
    Artifact(pomSettings().organization, artifactId(), publishVersion())
  }

  def publishXmlDeps = T.task {
    val ivyPomDeps = ivyDeps().map(resolvePublishDependency().apply(_))

    val compileIvyPomDeps = compileIvyDeps()
      .map(resolvePublishDependency().apply(_))
      .filter(!ivyPomDeps.contains(_))
      .map(_.copy(scope = Scope.Provided))

    val modulePomDeps = Task.sequence(moduleDeps.map(_.publishSelfDependency))()

    ivyPomDeps ++ compileIvyPomDeps ++ modulePomDeps.map(Dependency(_, Scope.Compile))
  }

  def pom = T {
    val pom = Pom(artifactMetadata(), publishXmlDeps(), artifactId(), pomSettings())
    val pomPath = T.ctx().dest / s"${artifactId()}-${publishVersion()}.pom"
    os.write.over(pomPath, pom)
    PathRef(pomPath)
  }

  def ivy = T {
    val ivy = Ivy(artifactMetadata(), publishXmlDeps())
    val ivyPath = T.ctx().dest / "ivy.xml"
    os.write.over(ivyPath, ivy)
    PathRef(ivyPath)
  }

  def artifactMetadata: T[Artifact] = T {
    Artifact(pomSettings().organization, artifactId(), publishVersion())
  }

  def publishLocal(): define.Command[Unit] = T.command {
    LocalPublisher.publish(
      jar = jar().path,
      sourcesJar = sourceJar().path,
      docJar = docJar().path,
      pom = pom().path,
      ivy = ivy().path,
      artifact = artifactMetadata()
    )
  }

  def sonatypeUri: String = "https://oss.sonatype.org/service/local"

  def sonatypeSnapshotUri: String = "https://oss.sonatype.org/content/repositories/snapshots"

  def publishArtifacts = T {
    val baseName = s"${artifactId()}-${publishVersion()}"
    PublishModule.PublishData(
      artifactMetadata(),
      Seq(
        jar() -> s"$baseName.jar",
        sourceJar() -> s"$baseName-sources.jar",
        docJar() -> s"$baseName-javadoc.jar",
        pom() -> s"$baseName.pom"
      )
    )
  }

  def publish(sonatypeCreds: String,
              gpgPassphrase: String = null,
              gpgKeyName: String = null,
              signed: Boolean = true,
              readTimeout: Int = 60000,
              connectTimeout: Int = 5000,
              release: Boolean,
              awaitTimeout: Int = 120 * 1000): define.Command[Unit] = T.command {
    println("publish")
    val PublishModule.PublishData(artifactInfo, artifacts) = publishArtifacts()
    new SonatypePublisher(
      sonatypeUri,
      sonatypeSnapshotUri,
      sonatypeCreds,
      Option(gpgPassphrase),
      Option(gpgKeyName),
      signed,
      readTimeout,
      connectTimeout,
      T.ctx().log,
      awaitTimeout
    ).publish(artifacts.map{case (a, b) => (a.path, b)}, artifactInfo, release)
  }
}

// Modified SonatypePublisher
import java.math.BigInteger
import java.security.MessageDigest

import mill.api.Logger
import os.Shellable

import mill.scalalib.publish.{SonatypeHttpApi, Artifact}


class SonatypePublisher(uri: String,
                        snapshotUri: String,
                        credentials: String,
                        gpgPassphrase: Option[String],
                        gpgKeyName: Option[String],
                        signed: Boolean,
                        readTimeout: Int,
                        connectTimeout: Int,
                        log: Logger,
                        awaitTimeout: Int) {

  private val api = new SonatypeHttpApi(uri, credentials, readTimeout = readTimeout, connectTimeout = connectTimeout)

  def publish(fileMapping: Seq[(os.Path, String)], artifact: Artifact, release: Boolean): Unit = {
    publishAll(release, fileMapping -> artifact)
  }

  def publishAll(release: Boolean, artifacts: (Seq[(os.Path, String)], Artifact)*): Unit = {

    val mappings = for ((fileMapping0, artifact) <- artifacts) yield {
      val publishPath = Seq(
        artifact.group.replace(".", "/"),
        artifact.id,
        artifact.version
      ).mkString("/")
      val fileMapping = fileMapping0.map { case (file, name) => (file, publishPath + "/" + name) }

      val signedArtifacts = if (signed) fileMapping.map {
        case (file, name) => poorMansSign(file, gpgPassphrase, gpgKeyName) -> s"$name.asc"
      } else Seq()

      artifact -> (fileMapping ++ signedArtifacts).flatMap {
        case (file, name) =>
          val content = os.read.bytes(file)

          Seq(
            name -> content,
            (name + ".md5") -> md5hex(content),
            (name + ".sha1") -> sha1hex(content)
          )
      }
    }

    val (snapshots, releases) = mappings.partition(_._1.isSnapshot)
    if (snapshots.nonEmpty) {
      publishSnapshot(snapshots.flatMap(_._2), snapshots.map(_._1))
    }
    val releaseGroups = releases.groupBy(_._1.group)
    for ((group, groupReleases) <- releaseGroups) {
      publishRelease(
        release,
        groupReleases.flatMap(_._2),
        group,
        releases.map(_._1),
        awaitTimeout
      )
    }
  }

  private def publishSnapshot(payloads: Seq[(String, Array[Byte])],
                              artifacts: Seq[Artifact]): Unit = {

    val publishResults = payloads.map {
      case (fileName, data) =>
        log.info(s"Uploading $fileName")
        val resp = api.upload(s"$snapshotUri/$fileName", data)
        resp
    }
    reportPublishResults(publishResults, artifacts)
  }

  private def publishRelease(release: Boolean,
                             payloads: Seq[(String, Array[Byte])],
                             stagingProfile: String,
                             artifacts: Seq[Artifact],
                             awaitTimeout: Int): Unit = {
    // val profileUri = api.getStagingProfileUri(stagingProfile)
    // val stagingRepoId = api.createStagingRepo(profileUri, stagingProfile)
    val baseUri = s"$uri" ///staging/deployByRepositoryId/$stagingRepoId/"

    val publishResults = payloads.map {
      case (fileName, data) =>
        log.info(s"Uploading ${fileName} to ${s"$baseUri/$fileName"}")
        api.upload(s"$baseUri/$fileName", data)
    }
    reportPublishResults(publishResults, artifacts)

    // if (release) {
    //   log.info("Closing staging repository")
    //   api.closeStagingRepo(profileUri, stagingRepoId)

    //   log.info("Waiting for staging repository to close")
    //   awaitRepoStatus("closed", stagingRepoId, awaitTimeout)

    //   log.info("Promoting staging repository")
    //   api.promoteStagingRepo(profileUri, stagingRepoId)

    //   log.info("Waiting for staging repository to release")
    //   awaitRepoStatus("released", stagingRepoId, awaitTimeout)

    //   log.info("Dropping staging repository")
    //   api.dropStagingRepo(profileUri, stagingRepoId)

    //   log.info(s"Published ${artifacts.map(_.id).mkString(", ")} successfully")
    // }
  }

  private def reportPublishResults(publishResults: Seq[requests.Response],
                                   artifacts: Seq[Artifact]) = {
    if (publishResults.forall(_.is2xx)) {
      log.info(s"Published ${artifacts.map(_.id).mkString(", ")} to Sonatype")
    } else {
      val errors = publishResults.filterNot(_.is2xx).map { response =>
        s"Code: ${response.statusCode}, message: ${response.data.text}"
      }
      throw new RuntimeException(
        s"Failed to publish ${artifacts.map(_.id).mkString(", ")} to Sonatype. Errors: \n${errors.mkString("\n")}"
      )
    }
  }

  private def awaitRepoStatus(status: String,
                              stagingRepoId: String,
                              awaitTimeout: Int): Unit = {
    def isRightStatus =
      api.getStagingRepoState(stagingRepoId).equalsIgnoreCase(status)

    var attemptsLeft = awaitTimeout / 3000

    while (attemptsLeft > 0 && !isRightStatus) {
      Thread.sleep(3000)
      attemptsLeft -= 1
      if (attemptsLeft == 0) {
        throw new RuntimeException(
          s"Couldn't wait for staging repository to be ${status}. Failing")
      }
    }
  }

  // http://central.sonatype.org/pages/working-with-pgp-signatures.html#signing-a-file
  private def poorMansSign(file: os.Path, maybePassphrase: Option[String], maybeKeyName: Option[String]): os.Path = {
    val fileName = file.toString
    val optionFlag = (flag: String, ov: Option[String]) => ov.map(flag :: _ :: Nil).getOrElse(Nil)
    val command = "gpg" ::
      optionFlag("--passphrase", maybePassphrase) ++ optionFlag("-u", maybeKeyName) ++
        Seq("--batch", "--yes", "-a", "-b", fileName)

    os.proc(command.map(v => v: Shellable))
      .call(stdin = os.Inherit, stdout = os.Inherit, stderr = os.Inherit)
    os.Path(fileName + ".asc")
  }

  private def md5hex(bytes: Array[Byte]): Array[Byte] =
    hexArray(md5.digest(bytes)).getBytes

  private def sha1hex(bytes: Array[Byte]): Array[Byte] =
    hexArray(sha1.digest(bytes)).getBytes

  private def md5 = MessageDigest.getInstance("md5")

  private def sha1 = MessageDigest.getInstance("sha1")

  private def hexArray(arr: Array[Byte]) =
    String.format("%0" + (arr.length << 1) + "x", new BigInteger(1, arr))

}

I am confused. I compared this to original PublishModule source and it is almost identical. Both publish and publishLocal delegates to same LocalPublisher and SonatypePublisher respectively. Or is import on line 13 referring to some custom publisher implementation? Thanks!

Sorry, you are right I had copied the SonatypePublisher and commented things out. I've added that below for reference. It works but as you can see it needs a lot of work.