Pitgull bootstrap cli

.github/workflows/native.yml

@@ -0,0 +1,56 @@
+name: Native Image
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+  release:
+    types: [published]
+jobs:
+  unix:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macOS-latest, ubuntu-latest, windows-latest]
+        include:
+          - os: macOS-latest
+            uploaded_filename: bootstrap-x86_64-apple-darwin
+            local_path: bootstrap/target/native-image/bootstrap
+          - os: ubuntu-latest
+            uploaded_filename: bootstrap-x86_64-pc-linux
+            local_path: bootstrap/target/native-image/bootstrap
+          - os: windows-latest
+            uploaded_filename: bootstrap-x86_64-pc-win32.exe
+            local_path: bootstrap\target\native-image\bootstrap.exe
+    steps:
+      - uses: actions/checkout@v2
+      - uses: olafurpg/setup-scala@v10
+      - run: git fetch --tags || true
+      - run: sbt bootstrap/nativeImage
+        shell: bash
+        if: ${{ matrix.os != 'windows-latest' }}
+      - run: echo $(pwd)
+        shell: bash
+      - name: sbt test
+        shell: cmd
+        if: ${{ matrix.os == 'windows-latest' }}
+        run: >-
+          "C:\Program Files (x86)\Microsoft Visual
+          Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && sbt
+          bootstrap/nativeImage
+      - uses: actions/upload-artifact@v2
+        with:
+          path: ${{ matrix.local_path }}
+          name: ${{ matrix.uploaded_filename }}
+      - name: Upload release
+        if: github.event_name == 'release'
+        uses: actions/upload-release-asset@v1.0.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ github.event.release.upload_url }}
+          asset_path: ${{ matrix.local_path }}
+          asset_name: ${{ matrix.uploaded_filename }}
+          asset_content_type: application/zip

bootstrap/src/main/scala/org/polyvariant/Args.scala

@@ -0,0 +1,21 @@
+package org.polyvariant
+
+object Args {
+  private val switch = "-(\\w+)".r
+  private val option = "--(\\w+)".r
+
+  private def parseNext(pendingArguments: List[String], previousResult: Map[String, String]): Map[String, String] =
+    pendingArguments match {
+      case Nil                          => previousResult
+      case option(opt) :: value :: tail => parseNext(tail, previousResult ++ Map(opt -> value))
+      case switch(opt) :: tail          => parseNext(tail, previousResult ++ Map(opt -> null))
+      case text :: Nil                  => previousResult ++ Map(text -> null)
+      case text :: tail                 => parseNext(tail, previousResult ++ Map(text -> null))
+    }
+
+
+  // TODO: Consider switching to https://ben.kirw.in/decline/
+  def parse(args: List[String]): Map[String, String] =
+    parseNext(args.toList, Map())
+
+}

bootstrap/src/main/scala/org/polyvariant/Gitlab.scala

@@ -0,0 +1,151 @@
+package org.polyvariant
+
+import cats.implicits.*
+
+import scala.util.chaining._
+import io.pg.gitlab.graphql.*
+import sttp.model.Uri
+import sttp.client3.*
+import caliban.client.SelectionBuilder
+import caliban.client.CalibanClientError.DecodingError
+import io.pg.gitlab.graphql.MergeRequest
+import io.pg.gitlab.graphql.MergeRequestConnection
+import io.pg.gitlab.graphql.MergeRequestState
+import io.pg.gitlab.graphql.Pipeline
+import io.pg.gitlab.graphql.PipelineStatusEnum
+import io.pg.gitlab.graphql.Project
+import io.pg.gitlab.graphql.ProjectConnection
+import io.pg.gitlab.graphql.Query
+import io.pg.gitlab.graphql.UserCore
+import caliban.client.Operations.IsOperation
+import sttp.model.Method
+import cats.MonadThrow
+
+trait Gitlab[F[_]] {
+  def mergeRequests(projectId: Long): F[List[Gitlab.MergeRequestInfo]]
+  def deleteMergeRequest(projectId: Long, mergeRequestId: Long): F[Unit]
+  def createWebhook(projectId: Long, pitgullUrl: Uri): F[Unit]
+}
+
+object Gitlab {
+
+  def sttpInstance[F[_]: Logger: MonadThrow](
+    baseUri: Uri,
+    accessToken: String
+  )(
+    using backend: SttpBackend[Identity, Any] // FIXME: all cats-effect compatible backends rely on Netty, while netty breaks native-image build
+  ): Gitlab[F] = {
+    def runRequest[O](request: Request[O, Any]): F[O] =
+      request.header("Private-Token", accessToken).send(backend).pure[F].map(_.body) // FIXME - change to async backend
+
+    def runGraphQLQuery[A: IsOperation, B](a: SelectionBuilder[A, B]): F[B] =
+      runRequest(a.toRequest(baseUri.addPath("api", "graphql"))).rethrow
+
+    new Gitlab[F] {
+      def mergeRequests(projectId: Long): F[List[MergeRequestInfo]] =
+        Logger[F].info(s"Looking up merge requests for project: $projectId") *>
+          mergeRequestsQuery(projectId)
+            .mapEither(_.toRight(DecodingError("Project not found")))
+            .pipe(runGraphQLQuery(_))
+            .flatTap { result =>
+              Logger[F].info(s"Found merge requests. Size: ${result.size}")
+            }
+
+      def deleteMergeRequest(projectId: Long, mergeRequestId: Long): F[Unit] = for {
+        _ <- Logger[F].debug(s"Request to remove $mergeRequestId")
+        result <- runRequest(
+          basicRequest.delete(
+            baseUri
+              .addPath(
+                Seq(
+                  "api",
+                  "v4",
+                  "projects",
+                  projectId.toString,
+                  "merge_requests",
+                  mergeRequestId.toString
+                )
+              )
+          )
+        )
+      } yield ()
+
+      def createWebhook(projectId: Long, pitgullUrl: Uri): F[Unit] = for {
+        _ <- Logger[F].debug(s"Creating webhook to $pitgullUrl")
+        result <- runRequest(
+          basicRequest.post(
+            baseUri
+              .addPath(
+                Seq(
+                  "api",
+                  "v4",
+                  "projects",
+                  projectId.toString,
+                  "hooks"
+                )
+              )
+          )
+          .body(s"""{"merge_requests_events": true, "pipeline_events": true, "note_events": true, "url": "$pitgullUrl"}""")
+          .contentType("application/json")
+        )
+      } yield ()
+    }
+
+  }
+
+  final case class MergeRequestInfo(
+    projectId: Long,
+    mergeRequestIid: Long,
+    authorUsername: String,
+    description: Option[String],
+    needsRebase: Boolean,
+    hasConflicts: Boolean
+  )
+
+  private def flattenTheEarth[A]: Option[List[Option[Option[Option[List[Option[A]]]]]]] => List[A] =
+    _.toList.flatten.flatten.flatten.flatten.flatten.flatten
+
+  private def mergeRequestInfoSelection(projectId: Long): SelectionBuilder[MergeRequest, MergeRequestInfo] = (
+    MergeRequest.iid.mapEither(_.toLongOption.toRight(DecodingError("MR IID wasn't a Long"))) ~
+      MergeRequest
+        .author(UserCore.username)
+        .mapEither(_.toRight(DecodingError("MR has no author"))) ~
+      MergeRequest.description ~
+      MergeRequest.shouldBeRebased ~
+      MergeRequest.conflicts
+  ).mapN((buildMergeRequest(projectId) _))
+
+  private def buildMergeRequest(
+    projectId: Long
+  )(
+    mergeRequestIid: Long,
+    authorUsername: String,
+    description: Option[String],
+    needsRebase: Boolean,
+    hasConflicts: Boolean
+  ): MergeRequestInfo = MergeRequestInfo(
+    projectId = projectId,
+    mergeRequestIid = mergeRequestIid,
+    authorUsername = authorUsername,
+    description = description,
+    needsRebase = needsRebase,
+    hasConflicts = hasConflicts
+  )
+
+  private def mergeRequestsQuery(projectId: Long) =
+    Query
+      .projects(ids = List(show"gid://gitlab/Project/$projectId").some)(
+        ProjectConnection
+          .nodes(
+            Project
+              .mergeRequests(
+                state = MergeRequestState.opened.some
+              )(
+                MergeRequestConnection
+                  .nodes(mergeRequestInfoSelection(projectId))
+              )
+          )
+          .map(flattenTheEarth)
+      )
+
+}

bootstrap/src/main/scala/org/polyvariant/Logger.scala

@@ -0,0 +1,28 @@
+package org.polyvariant
+
+import cats.syntax.apply
+import cats.effect.kernel.Sync
+import scala.io.AnsiColor._
+
+trait Logger[F[_]] {
+  def debug(msg: String): F[Unit]
+  def success(msg: String): F[Unit]
+  def info(msg: String): F[Unit]
+  def warn(msg: String): F[Unit]
+  def error(msg: String): F[Unit]
+}
+
+object Logger {
+  def apply[F[_]](using ev: Logger[F]): Logger[F] = ev
+
+  def wrappedPrint[F[_]: Sync] = new Logger[F] {
+    private def colorPrinter(color: String)(msg: String): F[Unit] = 
+      Sync[F].delay(println(s"${color}${msg}${RESET}"))
+
+    override def debug(msg: String): F[Unit] = colorPrinter(CYAN)(msg)
+    override def success(msg: String): F[Unit] = colorPrinter(GREEN)(msg)
+    override def info(msg: String): F[Unit] = colorPrinter(WHITE)(msg)
+    override def warn(msg: String): F[Unit] = colorPrinter(YELLOW)(msg)
+    override def error(msg: String): F[Unit] = colorPrinter(RED)(msg)
+  }
+}

bootstrap/src/main/scala/org/polyvariant/Main.scala

@@ -0,0 +1,60 @@
+package org.polyvariant
+
+import cats.implicits.*
+import cats.effect.*
+
+import sttp.model.Uri
+
+import sttp.client3.*
+import org.polyvariant.Gitlab.MergeRequestInfo
+import cats.Applicative
+import sttp.monad.MonadError
+
+object Main extends IOApp {
+
+  private def printMergeRequests[F[_]: Logger: Applicative](mergeRequests: List[MergeRequestInfo]): F[Unit] = 
+    mergeRequests.traverse { mr =>
+      Logger[F].info(s"ID: ${mr.mergeRequestIid} by: ${mr.authorUsername}")
+    }.void
+
+  private def qualifyMergeRequestsForDeletion(botUserName: String, mergeRequests: List[MergeRequestInfo]): List[MergeRequestInfo] = 
+    mergeRequests.filter(_.authorUsername == botUserName)
+
+  private def program[F[_]: Logger: Async](args: List[String]): F[Unit] =
+    given backend: SttpBackend[Identity, Any] = HttpURLConnectionBackend()
+    for {
+      _   <- Logger[F].info("Starting pitgull bootstrap!")
+      parsedArgs = Args.parse(args)
+      config = Config.fromArgs(parsedArgs)
+      gitlab = Gitlab.sttpInstance[F](config.gitlabUri, config.token)
+      mrs <- gitlab.mergeRequests(config.project)
+      _   <- Logger[F].info(s"Merge requests found: ${mrs.length}")
+      _   <- printMergeRequests(mrs)
+      botMrs = qualifyMergeRequestsForDeletion(config.botUser, mrs)
+      _   <- Logger[F].info(s"Will delete merge requests: ${botMrs.map(_.mergeRequestIid)}")
+      _   <- botMrs.traverse(mr => gitlab.deleteMergeRequest(config.project, mr.mergeRequestIid))
+      _   <- Logger[F].info("Done processing merge requests")
+      _   <- Logger[F].info("Creating webhook")
+      _   <- gitlab.createWebhook(config.project, config.pitgullWebhookUrl)
+      _   <- Logger[F].info("Webhook created")
+      _   <- Logger[F].success("Bootstrap finished")
+    } yield ()
+
+  override def run(args: List[String]): IO[ExitCode] = {
+    given Logger[IO] = Logger.wrappedPrint[IO]
+    program[IO](args) *>
+      IO.pure(ExitCode.Success)
+  }
+
+  final case class Config(
+    gitlabUri: Uri,
+    token: String,
+    project: Long,
+    botUser: String,
+    pitgullWebhookUrl: Uri
+  )
+  object Config {
+    def fromArgs(args: Map[String, String]): Config = // FIXME: this is unsafe
+      Config(Uri.unsafeParse(args("url")), args("token"), args("project").toLong, args("bot"), Uri.unsafeParse(args("webhook")))
+  }
+}

build.sbt

@@ -1,5 +1,5 @@
-import com.typesafe.sbt.packager.docker.ExecCmd
 import com.typesafe.sbt.packager.docker.Cmd
+import com.typesafe.sbt.packager.docker.ExecCmd
 
 inThisBuild(
   List(
@@ -100,6 +100,23 @@ lazy val gitlab = project
   )
   .dependsOn(core)
 
+lazy val bootstrap = project
+  .settings(
+    scalaVersion := "3.0.0",
+    libraryDependencies ++= List(
+      "org.typelevel" %% "cats-core" % "2.6.1",
+      "org.typelevel" %% "cats-effect" % "3.1.1",
+      "com.kubukoz" %% "caliban-gitlab" % "0.1.0",
+      "com.softwaremill.sttp.client3" %% "core" % "3.3.6"
+    ),
+    testFrameworks += new TestFramework("weaver.framework.TestFramework"),
+    publish / skip := true,
+    Compile / mainClass := Some("org.polyvariant.Main"),
+    scalacOptions --= Seq("-source", "future"),
+    githubWorkflowArtifactUpload := false
+  )
+  .enablePlugins(NativeImagePlugin)
+
 lazy val core = project.settings(commonSettings).settings(name += "-core")
 
 //workaround for docker not accepting + (the default separator in sbt-dynver)

project/plugins.sbt

@@ -4,3 +4,4 @@ addSbtPlugin("com.codecommit" % "sbt-github-actions" % "0.12.0")
 addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.10.0")
 addSbtPlugin("com.dwijnand" % "sbt-dynver" % "4.1.1")
 addSbtPlugin("ch.epfl.scala" % "sbt-missinglink" % "0.3.2")
+addSbtPlugin("org.scalameta" % "sbt-native-image" % "0.3.0")