Question

我正在尝试构建一个自定义任务，用于在持续集成环境中构建项目。这是一系列步骤

将构建开始消息发送到聊天室
编译模板
运行npm测试
运行jshint
编译
构建应用程序工件
将工件上传到我们的部署服务器
运行测试
将测试结果发送到我们的部署服务器
将构建结果消息发送到聊天室

请注意，如果任何步骤失败，则应执行步骤10，并且应根据哪个步骤失败来自定义消息，例如，如果第5步失败，它应该说“编译失败”，如果第8步失败，应说明运行了多少次测试以及失败了多少次。

为了使事情变得更有趣，这是一个多项目构建，因此在运行测试和发布结果时，它应该运行所有测试并发布聚合结果。

为了让事情变得更有趣，npm测试，jshint和工件只在Javascript所在的webapp子项目和Web服务器所在的位置才有意义。

我一直在寻找sbt-release的灵感，但我在如何获取一个任务产生的值并在下一个任务中使用它，如何在聚合中运行任务并获得生成的值（我在Extracted中看到一个方法来运行聚合任务，但它没有给出生成的值），如何在子项目中运行任务并获取生成的值，以及如何进行错误处理。

到目前为止，我已尝试过两种方法

npmTest.result.value match {                                                                    
  case Inc(inc) =>                                                                              
    println(inc)                                                                                
  case Value(res) => Def.taskDyn {                                                              
    (executeTests in Test).result.value match {                                                 
      case Inc(inc) =>                                                                          
        println(inc)                                                                            
      case Value(res) =>                                                                        
        println(res)                                                                            
    }                                                                                           
  }

上述问题是executeTests始终在运行，即使npmTest失败也是如此。并且println都没有被执行。

npmTest.result.                                                                                    
 flatMap {-                                                                                       
   case Inc(inc) =>                                                                               
     task { println(inc) }                                                                        
   case Value(res) =>-                                                                            
     (executeTests in Test).result.                                                               
       flatMap {                                                                                  
         case Inc(inc) =>                                                                         
           task { println(inc) }                                                                  
         case Value(res) =>                                                                       
           task { println(res) }                                                                  
       }                                                                                          
 }

此版本无法编译，因为(executeTasks in Test)...生成Initialize[Task[Unit]]值且需要Task[Unit]。

有没有办法用sbt完成这个？

Answer 1

我找到了一个解决方案，可让您使用优秀的旧flatMap和map来撰写任务。

sealed abstract class Step[A] {
  def run: Def.Initialize[Task[Result[A]]]
  def map[B](f: A => B): Step[B]
  def flatMap[B](f: A => Step[B]): Step[B]
}

object Step {
  val thisProjectRef = settingKey(Keys.thisProjectRef)
  val clean = taskKey(Keys.clean)
  val compile = taskKey(Keys.compile.in(Compile))
  val assembly = taskKey(sbtassembly.AssemblyPlugin.autoImport.assembly)

  private[this] def apply[A](task: Def.Initialize[Task[Result[A]]]): Step[A] =
    new Step[A] {
      val run = task

      def map[B](f: A => B): Step[B] =
        apply[B](Def.taskDyn {
          run.value match {
            case Inc(inc) => Def.task(Inc(inc): Result[B])
            case Value(a) => Def.task(Value(f(a)))
          }
        })

      def flatMap[B](f: A => Step[B]): Step[B] =
        apply[B](Def.taskDyn {
          run.value match {
            case Inc(inc) => Def.task(Inc(inc): Result[B])
            case Value(a) => Def.task(f(a).run.value)
          }
        })
    }

  def task[A](t: Def.Initialize[Task[A]]): Step[A] =
    apply(t.result)

  def taskKey[A](t: TaskKey[A]): Step[A] =
    apply(Def.task(t.result.value))

  def settingKey[A](s: SettingKey[A]): Step[A] =
    apply(Def.task(s.value).result)
}

然后您可以将任务定义为

    rainicornPublish <<= {
      val result = 
        for {
          ass <- Step.assembly
          juri <- uploadAssemblyTask(ass)
          to <- runAllTests
          _ <- finish(ass, juri, to)
        } yield (ass, to)

      Def.task(result.run.value match {
        case Inc(inc) => throw new RainicornException(None)
        case Value(v) => v
      })
    }

每个任务都会按顺序发生，就像你期望的那样。

你如何在sbt中组成任务？

1 个答案: