3466

pending completion

Build # 3466

Build Type

Pull #328

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/broadinstitute/workbench-libs/commit/<a class=hub.com/broadinstitute/workbench-libs/commit/<a class="double-link" href="https://git"><a class=hub.com/broadinstitute/workbench-libs/commit/<a class="double-link" href="https://git"><a class=hub.com/broadinstitute/workbench-libs/commit/<a class="double-link" href="https://git"><a class=hub.com/broadinstitute/workbench-libs/commit/7ad1e58f2188b911043eb422b0bc773e39d48fb4">7ad1e58f2">&lt;a href=&quot;https://github.com/broadinstitute/workbench-libs/commit/</a><a class="double-link" href="https://github.com/broadinstitute/workbench-libs/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/broadinstitute/workbench-libs/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/broadinstitute/workbench-libs/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/broadinstitute/workbench-libs/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/broadinstitute/workbench-libs/commit/7ad1e58f2188b911043eb422b0bc773e39d48fb4">7ad1e58f2</a><a href="https://github.com/broadinstitute/workbench-libs/commit/7ad1e58f2188b911043eb422b0bc773e39d48fb4">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/broadinstitute/workbench-libs/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/broadinstitute/workbench-libs/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/broadinstitute/workbench-libs/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/broadinstitute/workbench-libs/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/broadinstitute/workbench-libs/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/broadinstitute/workbench-libs/commit/7ad1e58f2188b911043eb422b0bc773e39d48fb4&quot;&gt;7ad1e58f2&lt;/a&gt;&lt;a href=&quot;https://github.com/broadinstitute/workbench-libs/commit/7ad1e58f2188b911043eb422b0bc773e39d48fb4&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #328: IA-2000 fix detach bug

Run Details

5 of 5 new or added lines in 2 files covered. (100.0%)

403 of 1649 relevant lines covered (24.44%)

0.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/google2/src/main/scala/org/broadinstitute/dsde/workbench/google2/GoogleComputeInterpreter.scala

package org.broadinstitute.dsde.workbench
package google2

import _root_.io.chrisdavenport.log4cats.StructuredLogger
import cats.Parallel
import cats.effect.concurrent.Semaphore
import cats.effect.{Async, Blocker, ContextShift, Timer}
import cats.implicits._
import cats.mtl.ApplicativeAsk
import com.google.cloud.compute.v1._
import org.broadinstitute.dsde.workbench.google2.util.RetryPredicates._
import org.broadinstitute.dsde.workbench.model.google.GoogleProject
import org.broadinstitute.dsde.workbench.model.{TraceId, WorkbenchException}

import scala.collection.JavaConverters._
import scala.concurrent.TimeoutException
import scala.concurrent.duration._

private[google2] class GoogleComputeInterpreter[F[_]: Async: Parallel: StructuredLogger: Timer: ContextShift](
  instanceClient: InstanceClient,
  firewallClient: FirewallClient,
  zoneClient: ZoneClient,
  machineTypeClient: MachineTypeClient,
  networkClient: NetworkClient,
  subnetworkClient: SubnetworkClient,
  retryConfig: RetryConfig,
  blocker: Blocker,
  blockerBound: Semaphore[F]
) extends GoogleComputeService[F] {

  override def createInstance(project: GoogleProject, zone: ZoneName, instance: Instance)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Operation] = {
    val projectZone = ProjectZoneName.of(project.value, zone.value)
    retryF(
      Async[F].delay(instanceClient.insertInstance(projectZone, instance)),
      s"com.google.cloud.compute.v1.InstanceClient.insertInstance(${projectZone.toString}, ${instance.getName})"
    )
  }

  override def deleteInstanceWithAutoDeleteDisk(project: GoogleProject,
                                                zone: ZoneName,
                                                instanceName: InstanceName,
                                                autoDeleteDisks: Set[DiskName])(
    implicit ev: ApplicativeAsk[F, TraceId],
    computePollOperation: ComputePollOperation[F]
  ): F[Operation] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)

    for {
      traceId <- ev.ask
      _ <- autoDeleteDisks.toList.parTraverse { diskName =>
        for {
          operation <- withLogging(
            Async[F].delay(instanceClient.setDiskAutoDeleteInstance(projectZoneInstanceName, true, diskName.value)),
            Some(traceId),
            s"com.google.cloud.compute.v1.InstanceClient.setDiskAutoDeleteInstance(${projectZoneInstanceName.toString}, true, ${diskName.value})"
          )
          _ <- computePollOperation.pollZoneOperation(project,
                                                      zone,
                                                      OperationName(operation.getName),
                                                      1 seconds,
                                                      5,
                                                      None)(
            Async[F].unit,
            Async[F].raiseError[Unit](
              new TimeoutException(s"Fail to setDiskAutoDeleteInstance for ${diskName} in a timely manner")
            ),
            Async[F].unit
          )
        } yield ()
      }
      deleteOp <- retryF(
        Async[F].delay(instanceClient.deleteInstance(projectZoneInstanceName)),
        s"com.google.cloud.compute.v1.InstanceClient.deleteInstance(${projectZoneInstanceName.toString})"
      )
    } yield deleteOp
  }

  override def deleteInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Operation] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)

    retryF(
      Async[F].delay(instanceClient.deleteInstance(projectZoneInstanceName)),
      s"com.google.cloud.compute.v1.InstanceClient.deleteInstance(${projectZoneInstanceName.toString})"
    )
  }

  override def detachDisk(project: GoogleProject, zone: ZoneName, instanceName: InstanceName, deviceName: DeviceName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Operation] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)

    for {
      traceId <- ev.ask
      op <- withLogging(
        Async[F].delay(instanceClient.detachDiskInstance(projectZoneInstanceName, deviceName.asString)),
        Some(traceId),
        s"com.google.cloud.compute.v1.InstanceClient.detachDiskInstance(${projectZoneInstanceName.toString}, ${deviceName.asString})"
      )
    } yield op
  }

  override def getInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Option[Instance]] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)
    retryF(
      recoverF(
        Async[F].delay(instanceClient.getInstance(projectZoneInstanceName)),
        whenStatusCode(404)
      ),
      s"com.google.cloud.compute.v1.InstanceClient.getInstance(${projectZoneInstanceName.toString})"
    )
  }

  override def stopInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Operation] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)
    retryF(
      Async[F].delay(instanceClient.stopInstance(projectZoneInstanceName)),
      s"com.google.cloud.compute.v1.InstanceClient.stopInstance(${projectZoneInstanceName.toString})"
    )
  }

  override def startInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Operation] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)
    retryF(
      Async[F].delay(instanceClient.startInstance(projectZoneInstanceName)),
      s"com.google.cloud.compute.v1.InstanceClient.startInstance(${projectZoneInstanceName.toString})"
    )
  }

  override def modifyInstanceMetadata(
    project: GoogleProject,
    zone: ZoneName,
    instanceName: InstanceName,
    metadataToAdd: Map[String, String],
    metadataToRemove: Set[String]
  )(implicit ev: ApplicativeAsk[F, TraceId]): F[Unit] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)
    val readAndUpdate = for {
      instanceOpt <- recoverF(Async[F].delay(instanceClient.getInstance(projectZoneInstanceName)), whenStatusCode(404))
      instance <- Async[F].fromEither(
        instanceOpt.toRight(new WorkbenchException(s"Instance not found: ${projectZoneInstanceName.toString}"))
      )
      curMetadataOpt = Option(instance.getMetadata)

      fingerprint = curMetadataOpt.map(_.getFingerprint).orNull
      curItems = curMetadataOpt.flatMap(m => Option(m.getItemsList)).map(_.asScala).getOrElse(List.empty)
      filteredItems = curItems.filterNot { i =>
        metadataToRemove.contains(i.getKey) || metadataToAdd.contains(i.getKey)
      }
      newItems = filteredItems ++ metadataToAdd.toList.map {
        case (k, v) =>
          Items.newBuilder().setKey(k).setValue(v).build()
      }
      // Only make google call if there is a change
      _ <- if (!newItems.equals(curItems)) {
        Async[F]
          .delay(
            instanceClient.setMetadataInstance(projectZoneInstanceName,
                                               Metadata
                                                 .newBuilder()
                                                 .setFingerprint(fingerprint)
                                                 .addAllItems(newItems.asJava)
                                                 .build)
          )
          .void
      } else Async[F].unit
    } yield ()

    // block and retry the read-modify-write as an atomic unit
    retryF(
      readAndUpdate,
      s"com.google.cloud.compute.v1.InstanceClient.setMetadataInstance(${projectZoneInstanceName.toString})"
    )
  }

  override def addFirewallRule(project: GoogleProject,
                               firewall: Firewall)(implicit ev: ApplicativeAsk[F, TraceId]): F[Operation] =
    retryF(
      Async[F].delay(firewallClient.insertFirewall(project.value, firewall)),
      s"com.google.cloud.compute.v1.FirewallClient.insertFirewall(${project.value}, ${firewall.getName})"
    )

  override def getFirewallRule(project: GoogleProject, firewallRuleName: FirewallRuleName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Option[Firewall]] = {
    val projectFirewallRuleName = ProjectGlobalFirewallName.of(firewallRuleName.value, project.value)
    retryF(
      recoverF(
        Async[F].delay(firewallClient.getFirewall(projectFirewallRuleName)),
        whenStatusCode(404)
      ),
      s"com.google.cloud.compute.v1.FirewallClient.insertFirewall(${project.value}, ${firewallRuleName.value})"
    )
  }

  override def deleteFirewallRule(project: GoogleProject, firewallRuleName: FirewallRuleName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Unit] = {
    val request =
      ProjectGlobalFirewallName.newBuilder().setProject(project.value).setFirewall(firewallRuleName.value).build
    retryF(
      recoverF(Async[F].delay(firewallClient.deleteFirewall(request)), whenStatusCode(404)),
      s"com.google.cloud.compute.v1.FirewallClient.deleteFirewall(${project.value}, ${firewallRuleName.value})"
    ).void
  }

  override def setMachineType(project: GoogleProject,
                              zone: ZoneName,
                              instanceName: InstanceName,
                              machineTypeName: MachineTypeName)(implicit ev: ApplicativeAsk[F, TraceId]): F[Unit] = {
    val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)
    val request =
      InstancesSetMachineTypeRequest.newBuilder().setMachineType(buildMachineTypeUri(zone, machineTypeName)).build()
    retryF(
      Async[F].delay(instanceClient.setMachineTypeInstance(projectZoneInstanceName, request)),
      s"com.google.cloud.compute.v1.InstanceClient.setMachineTypeInstance(${projectZoneInstanceName.toString}, ${machineTypeName.value})"
    )
  }

  override def getZones(project: GoogleProject,
                        regionName: RegionName)(implicit ev: ApplicativeAsk[F, TraceId]): F[List[Zone]] = {
    val request = ListZonesHttpRequest
      .newBuilder()
      .setProject(project.value)
      .setFilter(s"region eq ${buildRegionUri(project, regionName)}")
      .build()

    retryF(
      Async[F].delay(zoneClient.listZones(request)),
      s"com.google.cloud.compute.v1.ZoneClient.listZones(${project.value}, ${regionName.value})"
    ).map(_.iterateAll.asScala.toList)
  }

  override def getMachineType(project: GoogleProject, zone: ZoneName, machineTypeName: MachineTypeName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Option[MachineType]] = {
    val projectZoneMachineTypeName = ProjectZoneMachineTypeName.of(machineTypeName.value, project.value, zone.value)
    retryF(
      recoverF(Async[F].delay(machineTypeClient.getMachineType(projectZoneMachineTypeName)), whenStatusCode(404)),
      s"com.google.cloud.compute.v1.MachineTypeClient.getMachineType(${projectZoneMachineTypeName.toString})"
    )
  }

  override def getNetwork(project: GoogleProject,
                          networkName: NetworkName)(implicit ev: ApplicativeAsk[F, TraceId]): F[Option[Network]] = {
    val projectNetworkName =
      ProjectGlobalNetworkName.newBuilder().setProject(project.value).setNetwork(networkName.value).build
    retryF(
      recoverF(Async[F].delay(networkClient.getNetwork(projectNetworkName)), whenStatusCode(404)),
      s"com.google.cloud.compute.v1.NetworkClient.getNetwork(${projectNetworkName.toString})"
    )
  }

  override def createNetwork(project: GoogleProject,
                             network: Network)(implicit ev: ApplicativeAsk[F, TraceId]): F[Operation] = {
    val projectName = ProjectName.newBuilder().setProject(project.value).build
    retryF(
      Async[F].delay(networkClient.insertNetwork(projectName, network)),
      s"com.google.cloud.compute.v1.NetworkClient.insertNetwork(${projectName.toString}, ${network.getName})"
    )
  }

  override def getSubnetwork(project: GoogleProject, region: RegionName, subnetwork: SubnetworkName)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Option[Subnetwork]] = {
    val projectRegionSubnetworkName = ProjectRegionSubnetworkName
      .newBuilder()
      .setProject(project.value)
      .setRegion(region.value)
      .setSubnetwork(subnetwork.value)
      .build
    retryF(
      recoverF(Async[F].delay(subnetworkClient.getSubnetwork(projectRegionSubnetworkName)), whenStatusCode(404)),
      s"com.google.cloud.compute.v1.SubnetworkClient.getSubnetwork(${projectRegionSubnetworkName.toString})"
    )
  }

  override def createSubnetwork(project: GoogleProject, region: RegionName, subnetwork: Subnetwork)(
    implicit ev: ApplicativeAsk[F, TraceId]
  ): F[Operation] = {
    val projectRegionName = ProjectRegionName.newBuilder().setProject(project.value).setRegion(region.value).build
    retryF(
      Async[F].delay(subnetworkClient.insertSubnetwork(projectRegionName, subnetwork)),
      s"com.google.cloud.compute.v1.SubnetworkClient.insertSubnetwork(${projectRegionName.toString}, ${subnetwork.getName})"
    )
  }

  private def buildMachineTypeUri(zone: ZoneName, machineTypeName: MachineTypeName): String =
    s"zones/${zone.value}/machineTypes/${machineTypeName.value}"

  private def buildRegionUri(googleProject: GoogleProject, regionName: RegionName): String =
    s"https://www.googleapis.com/compute/v1/projects/${googleProject.value}/regions/${regionName.value}"

  private def retryF[A](fa: F[A], loggingMsg: String)(implicit ev: ApplicativeAsk[F, TraceId]): F[A] =
    tracedRetryGoogleF(retryConfig)(blockerBound.withPermit(blocker.blockOn(fa)), loggingMsg).compile.lastOrError

}

// device name that's known to the instance (same device name when you create runtime)
final case class DeviceName(asString: String) extends AnyVal

1	package org.broadinstitute.dsde.workbench
2	package google2
3
4	import _root_.io.chrisdavenport.log4cats.StructuredLogger
5	import cats.Parallel
6	import cats.effect.concurrent.Semaphore
7	import cats.effect.{Async, Blocker, ContextShift, Timer}
8	import cats.implicits._
9	import cats.mtl.ApplicativeAsk
10	import com.google.cloud.compute.v1._
11	import org.broadinstitute.dsde.workbench.google2.util.RetryPredicates._
12	import org.broadinstitute.dsde.workbench.model.google.GoogleProject
13	import org.broadinstitute.dsde.workbench.model.{TraceId, WorkbenchException}
14
15	import scala.collection.JavaConverters._
16	import scala.concurrent.TimeoutException
17	import scala.concurrent.duration._
18
19	private[google2] class GoogleComputeInterpreter[F[_]: Async: Parallel: StructuredLogger: Timer: ContextShift](
20	instanceClient: InstanceClient,
21	firewallClient: FirewallClient,
22	zoneClient: ZoneClient,
23	machineTypeClient: MachineTypeClient,
24	networkClient: NetworkClient,
25	subnetworkClient: SubnetworkClient,
26	retryConfig: RetryConfig,
27	blocker: Blocker,
28	blockerBound: Semaphore[F]
29	) extends GoogleComputeService[F] {
30
31	override def createInstance(project: GoogleProject, zone: ZoneName, instance: Instance)(
32	implicit ev: ApplicativeAsk[F, TraceId]
33	): F[Operation] = {
34	val projectZone = ProjectZoneName.of(project.value, zone.value)	×
35	retryF(	×
36	Async[F].delay(instanceClient.insertInstance(projectZone, instance)),
37	s"com.google.cloud.compute.v1.InstanceClient.insertInstance(${projectZone.toString}, ${instance.getName})"
38	)
39	}
40
41	override def deleteInstanceWithAutoDeleteDisk(project: GoogleProject,
42	zone: ZoneName,
43	instanceName: InstanceName,
44	autoDeleteDisks: Set[DiskName])(
45	implicit ev: ApplicativeAsk[F, TraceId],
46	computePollOperation: ComputePollOperation[F]
47	): F[Operation] = {
48	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
49
50	for {
51	traceId <- ev.ask	×
52	_ <- autoDeleteDisks.toList.parTraverse { diskName =>	×
53	for {
54	operation <- withLogging(	×
55	Async[F].delay(instanceClient.setDiskAutoDeleteInstance(projectZoneInstanceName, true, diskName.value)),	×
56	Some(traceId),	×
57	s"com.google.cloud.compute.v1.InstanceClient.setDiskAutoDeleteInstance(${projectZoneInstanceName.toString}, true, ${diskName.value})"	×
58	)
59	_ <- computePollOperation.pollZoneOperation(project,	×
60	zone,
61	OperationName(operation.getName),
62	1 seconds,
63	5,
64	None)(	×
65	Async[F].unit,
66	Async[F].raiseError[Unit](
67	new TimeoutException(s"Fail to setDiskAutoDeleteInstance for ${diskName} in a timely manner")
68	),
69	Async[F].unit
70	)
71	} yield ()	×
72	}
73	deleteOp <- retryF(	×
74	Async[F].delay(instanceClient.deleteInstance(projectZoneInstanceName)),
75	s"com.google.cloud.compute.v1.InstanceClient.deleteInstance(${projectZoneInstanceName.toString})"
76	)
77	} yield deleteOp
78	}
79
80	override def deleteInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
81	implicit ev: ApplicativeAsk[F, TraceId]
82	): F[Operation] = {
83	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
84
85	retryF(	×
86	Async[F].delay(instanceClient.deleteInstance(projectZoneInstanceName)),
87	s"com.google.cloud.compute.v1.InstanceClient.deleteInstance(${projectZoneInstanceName.toString})"
88	)
89	}
90
91	override def detachDisk(project: GoogleProject, zone: ZoneName, instanceName: InstanceName, deviceName: DeviceName)(
92	implicit ev: ApplicativeAsk[F, TraceId]
93	): F[Operation] = {
94	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
95
96	for {
97	traceId <- ev.ask	×
98	op <- withLogging(	×
99	Async[F].delay(instanceClient.detachDiskInstance(projectZoneInstanceName, deviceName.asString)),	×
100	Some(traceId),	×
101	s"com.google.cloud.compute.v1.InstanceClient.detachDiskInstance(${projectZoneInstanceName.toString}, ${deviceName.asString})"	×
102	)
103	} yield op
104	}
105
106	override def getInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
107	implicit ev: ApplicativeAsk[F, TraceId]
108	): F[Option[Instance]] = {
109	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
110	retryF(	×
111	recoverF(
112	Async[F].delay(instanceClient.getInstance(projectZoneInstanceName)),
113	whenStatusCode(404)
114	),
115	s"com.google.cloud.compute.v1.InstanceClient.getInstance(${projectZoneInstanceName.toString})"
116	)
117	}
118
119	override def stopInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
120	implicit ev: ApplicativeAsk[F, TraceId]
121	): F[Operation] = {
122	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
123	retryF(	×
124	Async[F].delay(instanceClient.stopInstance(projectZoneInstanceName)),
125	s"com.google.cloud.compute.v1.InstanceClient.stopInstance(${projectZoneInstanceName.toString})"
126	)
127	}
128
129	override def startInstance(project: GoogleProject, zone: ZoneName, instanceName: InstanceName)(
130	implicit ev: ApplicativeAsk[F, TraceId]
131	): F[Operation] = {
132	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
133	retryF(	×
134	Async[F].delay(instanceClient.startInstance(projectZoneInstanceName)),
135	s"com.google.cloud.compute.v1.InstanceClient.startInstance(${projectZoneInstanceName.toString})"
136	)
137	}
138
139	override def modifyInstanceMetadata(
140	project: GoogleProject,
141	zone: ZoneName,
142	instanceName: InstanceName,
143	metadataToAdd: Map[String, String],
144	metadataToRemove: Set[String]
145	)(implicit ev: ApplicativeAsk[F, TraceId]): F[Unit] = {
146	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
147	val readAndUpdate = for {
148	instanceOpt <- recoverF(Async[F].delay(instanceClient.getInstance(projectZoneInstanceName)), whenStatusCode(404))	×
149	instance <- Async[F].fromEither(	×
150	instanceOpt.toRight(new WorkbenchException(s"Instance not found: ${projectZoneInstanceName.toString}"))	×
151	)
152	curMetadataOpt = Option(instance.getMetadata)	×
153
154	fingerprint = curMetadataOpt.map(_.getFingerprint).orNull	×
155	curItems = curMetadataOpt.flatMap(m => Option(m.getItemsList)).map(_.asScala).getOrElse(List.empty)	×
156	filteredItems = curItems.filterNot { i =>	×
157	metadataToRemove.contains(i.getKey) \|\| metadataToAdd.contains(i.getKey)	×
158	}
159	newItems = filteredItems ++ metadataToAdd.toList.map {	×
160	case (k, v) =>
161	Items.newBuilder().setKey(k).setValue(v).build()	×
162	}
163	// Only make google call if there is a change
164	_ <- if (!newItems.equals(curItems)) {	×
165	Async[F]	×
166	.delay(	×
167	instanceClient.setMetadataInstance(projectZoneInstanceName,	×
168	Metadata
169	.newBuilder()
170	.setFingerprint(fingerprint)
171	.addAllItems(newItems.asJava)
172	.build)	×
173	)
174	.void	×
175	} else Async[F].unit	×
176	} yield ()	×
177
178	// block and retry the read-modify-write as an atomic unit
179	retryF(	×
180	readAndUpdate,
181	s"com.google.cloud.compute.v1.InstanceClient.setMetadataInstance(${projectZoneInstanceName.toString})"
182	)
183	}
184
185	override def addFirewallRule(project: GoogleProject,
186	firewall: Firewall)(implicit ev: ApplicativeAsk[F, TraceId]): F[Operation] =
187	retryF(	×
188	Async[F].delay(firewallClient.insertFirewall(project.value, firewall)),
189	s"com.google.cloud.compute.v1.FirewallClient.insertFirewall(${project.value}, ${firewall.getName})"
190	)
191
192	override def getFirewallRule(project: GoogleProject, firewallRuleName: FirewallRuleName)(
193	implicit ev: ApplicativeAsk[F, TraceId]
194	): F[Option[Firewall]] = {
195	val projectFirewallRuleName = ProjectGlobalFirewallName.of(firewallRuleName.value, project.value)	×
196	retryF(	×
197	recoverF(
198	Async[F].delay(firewallClient.getFirewall(projectFirewallRuleName)),
199	whenStatusCode(404)
200	),
201	s"com.google.cloud.compute.v1.FirewallClient.insertFirewall(${project.value}, ${firewallRuleName.value})"
202	)
203	}
204
205	override def deleteFirewallRule(project: GoogleProject, firewallRuleName: FirewallRuleName)(
206	implicit ev: ApplicativeAsk[F, TraceId]
207	): F[Unit] = {
208	val request =
209	ProjectGlobalFirewallName.newBuilder().setProject(project.value).setFirewall(firewallRuleName.value).build	×
210	retryF(	×
211	recoverF(Async[F].delay(firewallClient.deleteFirewall(request)), whenStatusCode(404)),
212	s"com.google.cloud.compute.v1.FirewallClient.deleteFirewall(${project.value}, ${firewallRuleName.value})"
213	).void	×
214	}
215
216	override def setMachineType(project: GoogleProject,
217	zone: ZoneName,
218	instanceName: InstanceName,
219	machineTypeName: MachineTypeName)(implicit ev: ApplicativeAsk[F, TraceId]): F[Unit] = {
220	val projectZoneInstanceName = ProjectZoneInstanceName.of(instanceName.value, project.value, zone.value)	×
221	val request =
222	InstancesSetMachineTypeRequest.newBuilder().setMachineType(buildMachineTypeUri(zone, machineTypeName)).build()	×
223	retryF(	×
224	Async[F].delay(instanceClient.setMachineTypeInstance(projectZoneInstanceName, request)),
225	s"com.google.cloud.compute.v1.InstanceClient.setMachineTypeInstance(${projectZoneInstanceName.toString}, ${machineTypeName.value})"
226	)
227	}
228
229	override def getZones(project: GoogleProject,
230	regionName: RegionName)(implicit ev: ApplicativeAsk[F, TraceId]): F[List[Zone]] = {
231	val request = ListZonesHttpRequest
232	.newBuilder()
233	.setProject(project.value)
234	.setFilter(s"region eq ${buildRegionUri(project, regionName)}")
235	.build()	×
236
237	retryF(	×
238	Async[F].delay(zoneClient.listZones(request)),
239	s"com.google.cloud.compute.v1.ZoneClient.listZones(${project.value}, ${regionName.value})"
240	).map(_.iterateAll.asScala.toList)	×
241	}
242
243	override def getMachineType(project: GoogleProject, zone: ZoneName, machineTypeName: MachineTypeName)(
244	implicit ev: ApplicativeAsk[F, TraceId]
245	): F[Option[MachineType]] = {
246	val projectZoneMachineTypeName = ProjectZoneMachineTypeName.of(machineTypeName.value, project.value, zone.value)	×
247	retryF(	×
248	recoverF(Async[F].delay(machineTypeClient.getMachineType(projectZoneMachineTypeName)), whenStatusCode(404)),
249	s"com.google.cloud.compute.v1.MachineTypeClient.getMachineType(${projectZoneMachineTypeName.toString})"
250	)
251	}
252
253	override def getNetwork(project: GoogleProject,
254	networkName: NetworkName)(implicit ev: ApplicativeAsk[F, TraceId]): F[Option[Network]] = {
255	val projectNetworkName =
256	ProjectGlobalNetworkName.newBuilder().setProject(project.value).setNetwork(networkName.value).build	×
257	retryF(	×
258	recoverF(Async[F].delay(networkClient.getNetwork(projectNetworkName)), whenStatusCode(404)),
259	s"com.google.cloud.compute.v1.NetworkClient.getNetwork(${projectNetworkName.toString})"
260	)
261	}
262
263	override def createNetwork(project: GoogleProject,
264	network: Network)(implicit ev: ApplicativeAsk[F, TraceId]): F[Operation] = {
265	val projectName = ProjectName.newBuilder().setProject(project.value).build	×
266	retryF(	×
267	Async[F].delay(networkClient.insertNetwork(projectName, network)),
268	s"com.google.cloud.compute.v1.NetworkClient.insertNetwork(${projectName.toString}, ${network.getName})"
269	)
270	}
271
272	override def getSubnetwork(project: GoogleProject, region: RegionName, subnetwork: SubnetworkName)(
273	implicit ev: ApplicativeAsk[F, TraceId]
274	): F[Option[Subnetwork]] = {
275	val projectRegionSubnetworkName = ProjectRegionSubnetworkName
276	.newBuilder()
277	.setProject(project.value)
278	.setRegion(region.value)
279	.setSubnetwork(subnetwork.value)
280	.build	×
281	retryF(	×
282	recoverF(Async[F].delay(subnetworkClient.getSubnetwork(projectRegionSubnetworkName)), whenStatusCode(404)),
283	s"com.google.cloud.compute.v1.SubnetworkClient.getSubnetwork(${projectRegionSubnetworkName.toString})"
284	)
285	}
286
287	override def createSubnetwork(project: GoogleProject, region: RegionName, subnetwork: Subnetwork)(
288	implicit ev: ApplicativeAsk[F, TraceId]
289	): F[Operation] = {
290	val projectRegionName = ProjectRegionName.newBuilder().setProject(project.value).setRegion(region.value).build	×
291	retryF(	×
292	Async[F].delay(subnetworkClient.insertSubnetwork(projectRegionName, subnetwork)),
293	s"com.google.cloud.compute.v1.SubnetworkClient.insertSubnetwork(${projectRegionName.toString}, ${subnetwork.getName})"
294	)
295	}
296
297	private def buildMachineTypeUri(zone: ZoneName, machineTypeName: MachineTypeName): String =
298	s"zones/${zone.value}/machineTypes/${machineTypeName.value}"	×
299
300	private def buildRegionUri(googleProject: GoogleProject, regionName: RegionName): String =
301	s"https://www.googleapis.com/compute/v1/projects/${googleProject.value}/regions/${regionName.value}"	×
302
303	private def retryF[A](fa: F[A], loggingMsg: String)(implicit ev: ApplicativeAsk[F, TraceId]): F[A] =
304	tracedRetryGoogleF(retryConfig)(blockerBound.withPermit(blocker.blockOn(fa)), loggingMsg).compile.lastOrError	×
305
306	}
307
308	// device name that's known to the instance (same device name when you create runtime)
309	final case class DeviceName(asString: String) extends AnyVal

broadinstitute / workbench-libs / 3466

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous