add timeout to fetching dependency sources

metals/src/main/scala/scala/meta/internal/metals/ImportedBuild.scala

@@ -107,7 +107,7 @@ object ImportedBuild {
       dependencySources: DependencySourcesResult,
       javacOptions: JavacOptionsResult,
       scalacOptions: ScalacOptionsResult,
-  )(implicit ec: ExecutionContext): Future[DependencySourcesResult] = Future {
+  )(implicit ec: ExecutionContext): Future[DependencySourcesResult] = {
     val dependencySourcesItems = dependencySources.getItems().asScala.toList
     val idsLookup = dependencySourcesItems.map(_.getTarget()).toSet
     val classpaths = javacOptions
@@ -119,16 +119,21 @@ object ImportedBuild {
         .asScala
         .map(item => (item.getTarget(), item.getClasspath()))
 
-    val newItems =
-      classpaths.collect {
-        case (id, classpath) if !idsLookup(id) =>
-          val items = JarSourcesProvider.fetchSources(
-            classpath.asScala.filter(_.endsWith(".jar")).toSeq
-          )
-          new DependencySourcesItem(id, items.asJava)
+    val newItemsFuture =
+      Future.sequence {
+        classpaths.collect {
+          case (id, classpath) if !idsLookup(id) =>
+            for {
+              items <- JarSourcesProvider.fetchSources(
+                classpath.asScala.filter(_.endsWith(".jar")).toSeq
+              )
+            } yield new DependencySourcesItem(id, items.asJava)
+        }
       }
 
-    new DependencySourcesResult((dependencySourcesItems ++ newItems).asJava)
+    newItemsFuture.map { newItems =>
+      new DependencySourcesResult((dependencySourcesItems ++ newItems).asJava)
+    }
   }
 
   def fromList(data: Seq[ImportedBuild]): ImportedBuild =

metals/src/main/scala/scala/meta/internal/metals/JarSourcesProvider.scala

@@ -1,9 +1,14 @@
 package scala.meta.internal.metals
 
 import java.nio.file.Path
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
 
+import scala.concurrent.ExecutionContext
+import scala.concurrent.Future
 import scala.util.Success
 import scala.util.Try
+import scala.util.control.NonFatal
 import scala.xml.XML
 
 import scala.meta.internal.metals.MetalsEnrichments._
@@ -12,12 +17,13 @@ import scala.meta.io.AbsolutePath
 
 import coursierapi.Dependency
 import coursierapi.Fetch
+import coursierapi.error.CoursierError
 
 object JarSourcesProvider {
 
   private val sbtRegex = "sbt-(.*)".r
 
-  def fetchSources(jars: Seq[String]): Seq[String] = {
+  def fetchSources(jars: Seq[String])(implicit ec: ExecutionContext): Future[Seq[String]] = {
     def sourcesPath(jar: String) = s"${jar.stripSuffix(".jar")}-sources.jar"
 
     val (haveSources, toDownload) = jars.partition { jar =>
@@ -37,25 +43,33 @@ object JarSourcesProvider {
     }.distinct
 
     val fetchedSources =
-      dependencies.flatMap { dep =>
-        Try(fetchDependencySources(dep)).toEither match {
-          case Right(fetched) => fetched.map(_.toUri().toString())
-          case Left(error) =>
-            scribe.warn(
-              s"could not fetch dependency sources for $dep, error: $error"
-            )
-            None
+      Future.sequence {
+        dependencies.map{ dep =>
+          fetchDependencySources(dep)
+          .recover {
+            case error : CoursierError =>
+              scribe.warn(s"Could not fetch dependency sources for $dep, error: $error")
+              Nil
+          }
         }
-      }
+      }.recover {
+        case _: TimeoutException =>
+          scribe.warn(s"Timeout when fetching dependency sources.")
+          Nil
+        case NonFatal(e) =>
+          scribe.warn(s"Could not fetch dependency sources, error: $e.")
+          Nil
+      }.map(_.flatten.map(_.toUri().toString()))
+
     val existingSources = haveSources.map(sourcesPath)
-    fetchedSources ++ existingSources
+    fetchedSources.map(_ ++ existingSources)
 
   }
 
   private def sbtFallback(jar: AbsolutePath): Option[Dependency] = {
     val filename = jar.filename.stripSuffix(".jar")
     filename match {
-      case sbtRegex(versionStr) if Try().isSuccess =>
+      case sbtRegex(versionStr) =>
         Try(SemVer.Version.fromString(versionStr)) match {
           case Success(version) if version.toString == versionStr =>
             Some(Dependency.of("org.scala-sbt", "sbt", versionStr))
@@ -91,7 +105,7 @@ object JarSourcesProvider {
 
   private def fetchDependencySources(
       dependency: Dependency
-  ): List[Path] = {
+  )(implicit ec: ExecutionContext): Future[List[Path]] = Future {
     Fetch
       .create()
       .withDependencies(dependency)
@@ -101,6 +115,6 @@ object JarSourcesProvider {
       .asScala
       .map(_.toPath())
       .toList
-  }
+  }.withTimeout(5, TimeUnit.MINUTES)
 
 }

tests/unit/src/test/scala/tests/JarSourcesProviderSuite.scala

@@ -1,18 +1,26 @@
 package tests
 
+import scala.concurrent.ExecutionContext
+
 import scala.meta.internal.metals.JarSourcesProvider
 import scala.meta.internal.metals.MetalsEnrichments._
 
 class JarSourcesProviderSuite extends BaseSuite {
 
+  private implicit val ctx: ExecutionContext = this.munitExecutionContext
+
   test("download-deps") {
-    val downloadedSources =
-      JarSourcesProvider.fetchSources(Library.cats.map(_.toURI.toString()))
-    assert(downloadedSources.nonEmpty)
-    downloadedSources.foreach { pathStr =>
-      val path = pathStr.toAbsolutePath
-      assert(path.exists)
-      assert(path.filename.endsWith("-sources.jar"))
+    for {
+      downloadedSources <- JarSourcesProvider.fetchSources(
+        Library.cats.map(_.toURI.toString())
+      )
+    } yield {
+      assert(downloadedSources.nonEmpty)
+      downloadedSources.foreach { pathStr =>
+        val path = pathStr.toAbsolutePath
+        assert(path.exists)
+        assert(path.filename.endsWith("-sources.jar"))
+      }
     }
   }