feat(gateway): allow tenant to recover manifest of active lease (#251)

refs akash-network/support#227

---------

Signed-off-by: Artur Troian <[email protected]>

.golangci.yaml

@@ -26,7 +26,7 @@ linters:
     - staticcheck
     - revive
     - gosec
-    - exportloopref
+    - copyloopvar
     - prealloc
 linters-settings:
   gocritic:

_run/common-commands.mk

@@ -82,6 +82,14 @@ send-manifest:
 		--from "$(KEY_NAME)" \
 		--provider "$(PROVIDER_ADDRESS)"
 
+.PHONY: get-manifest
+get-manifest:
+	$(PROVIDER_SERVICES) get-manifest \
+		--dseq "$(DSEQ)"     \
+		--from "$(KEY_NAME)" \
+		--provider "$(PROVIDER_ADDRESS)"
+
+
 .PHONY: deployment-create
 deployment-create:
 	$(AKASH) tx deployment create "$(SDL_PATH)" \

bidengine/pricing.go

@@ -144,11 +144,11 @@ func (fp scalePricing) CalculatePrice(_ context.Context, req Request) (sdk.DecCo
 
 	endpointTotal := decimal.NewFromInt(0)
 	ipTotal := decimal.NewFromInt(0).Add(fp.ipScale)
-	ipTotal = ipTotal.Mul(decimal.NewFromInt(int64(util.GetEndpointQuantityOfResourceGroup(req.GSpec, atypes.Endpoint_LEASED_IP))))
+	ipTotal = ipTotal.Mul(decimal.NewFromInt(int64(util.GetEndpointQuantityOfResourceGroup(req.GSpec, atypes.Endpoint_LEASED_IP)))) // nolint: gosec
 
 	// iterate over everything & sum it up
 	for _, group := range req.GSpec.Resources {
-		groupCount := decimal.NewFromInt(int64(group.Count)) // Expand uint32 to int64
+		groupCount := decimal.NewFromInt(int64(group.Count)) // // nolint: gosec
 
 		cpuQuantity := decimal.NewFromBigInt(group.Resources.CPU.Units.Val.BigInt(), 0)
 		cpuQuantity = cpuQuantity.Mul(groupCount)
@@ -174,7 +174,7 @@ func (fp scalePricing) CalculatePrice(_ context.Context, req Request) (sdk.DecCo
 			total, exists := storageTotal[storageClass]
 
 			if !exists {
-				return sdk.DecCoin{}, errors.Wrapf(errNoPriceScaleForStorageClass, storageClass)
+				return sdk.DecCoin{}, errors.Wrapf(errNoPriceScaleForStorageClass, "%s", storageClass)
 			}
 
 			total = total.Add(storageQuantity)
@@ -250,14 +250,14 @@ func MakeRandomRangePricing() (BidPricingStrategy, error) {
 }
 
 func (randomRangePricing) CalculatePrice(_ context.Context, req Request) (sdk.DecCoin, error) {
-	min, max := calculatePriceRange(req.GSpec)
-	if min.IsEqual(max) {
-		return max, nil
+	minPrice, maxPrice := calculatePriceRange(req.GSpec)
+	if minPrice.IsEqual(maxPrice) {
+		return maxPrice, nil
 	}
 
 	const scale = 10000
 
-	delta := max.Amount.Sub(min.Amount).Mul(sdk.NewDec(scale))
+	delta := maxPrice.Amount.Sub(minPrice.Amount).Mul(sdk.NewDec(scale))
 
 	minbid := delta.TruncateInt64()
 	if minbid < 1 {
@@ -269,8 +269,8 @@ func (randomRangePricing) CalculatePrice(_ context.Context, req Request) (sdk.De
 	}
 
 	scaledValue := sdk.NewDecFromBigInt(val).QuoInt64(scale).QuoInt64(100)
-	amount := min.Amount.Add(scaledValue)
-	return sdk.NewDecCoinFromDec(min.Denom, amount), nil
+	amount := minPrice.Amount.Add(scaledValue)
+	return sdk.NewDecCoinFromDec(minPrice.Denom, amount), nil
 }
 
 func calculatePriceRange(gspec *dtypes.GroupSpec) (sdk.DecCoin, sdk.DecCoin) {

bidengine/pricing_test.go

@@ -186,7 +186,7 @@ func Test_ScalePricingOnMemory(t *testing.T) {
 	price, err := pricing.CalculatePrice(context.Background(), req)
 	require.NoError(t, err)
 
-	expectedPrice := testutil.AkashDecCoin(t, int64(memoryScale*memoryQuantity))
+	expectedPrice := testutil.AkashDecCoin(t, int64(memoryScale*memoryQuantity)) // nolint: gosec
 	require.Equal(t, expectedPrice, price)
 }
 
@@ -258,7 +258,7 @@ func Test_ScalePricingOnStorage(t *testing.T) {
 	price, err := pricing.CalculatePrice(context.Background(), req)
 	require.NoError(t, err)
 
-	decNearly(t, price.Amount, int64(storageScale*storageQuantity))
+	decNearly(t, price.Amount, int64(storageScale*storageQuantity)) // nolint: gosec
 }
 
 func Test_ScalePricingByCountOfResources(t *testing.T) {
@@ -282,12 +282,12 @@ func Test_ScalePricingByCountOfResources(t *testing.T) {
 	require.NoError(t, err)
 
 	require.NoError(t, err)
-	decNearly(t, firstPrice.Amount, int64(storageScale*storageQuantity))
+	decNearly(t, firstPrice.Amount, int64(storageScale*storageQuantity)) // nolint: gosec
 
 	gspec.Resources[0].Count = 2
 	secondPrice, err := pricing.CalculatePrice(context.Background(), req)
 	require.NoError(t, err)
-	decNearly(t, secondPrice.Amount, 2*int64(storageScale*storageQuantity))
+	decNearly(t, secondPrice.Amount, 2*int64(storageScale*storageQuantity)) // nolint: gosec
 }
 
 func Test_ScalePricingForIPs(t *testing.T) {
@@ -956,8 +956,6 @@ func Test_newDataForScript_GPUWildcard(t *testing.T) {
 	}
 
 	for _, c := range cases {
-		c := c
-
 		t.Run(c.desc, func(t *testing.T) {
 			d := newDataForScript(c.r)
 			assert.NotEmpty(t, d)

bidengine/service.go

@@ -228,7 +228,7 @@ loop:
 			}
 		case ch := <-s.statusch:
 			ch <- &Status{
-				Orders: uint32(len(s.orders)),
+				Orders: uint32(len(s.orders)), // nolint: gosec
 			}
 		case order := <-s.drainch:
 			// child done
@@ -237,7 +237,7 @@ loop:
 			ordersCounter.WithLabelValues("stop").Inc()
 			trySignal()
 		case <-signalch:
-			bus.Pub(provider.BidEngineStatus{Orders: uint32(len(s.orders))}, []string{ptypes.PubSubTopicBidengineStatus}, tpubsub.WithRetain())
+			bus.Pub(provider.BidEngineStatus{Orders: uint32(len(s.orders))}, []string{ptypes.PubSubTopicBidengineStatus}, tpubsub.WithRetain()) // nolint: gosec
 		}
 		s.updateOrderManagerGauge()
 	}

bidengine/shellscript.go

@@ -143,7 +143,7 @@ func (ssp shellScriptPricing) CalculatePrice(ctx context.Context, r Request) (sd
 
 	processCtx, cancel := context.WithTimeout(ctx, ssp.runtimeLimit)
 	defer cancel()
-	cmd := exec.CommandContext(processCtx, ssp.path) //nolint:gosec
+	cmd := exec.CommandContext(processCtx, ssp.path) // nolint: gosec
 	cmd.Stdin = buf
 	outputBuf := &bytes.Buffer{}
 	cmd.Stdout = outputBuf

cluster/client.go

@@ -195,8 +195,8 @@ func (c *nullClient) LeaseStatus(_ context.Context, lid mtypes.LeaseID) (map[str
 	for _, svc := range lease.group.Services {
 		resp[svc.Name] = &ctypes.ServiceStatus{
 			Name:      svc.Name,
-			Available: int32(svc.Count),
-			Total:     int32(svc.Count),
+			Available: int32(svc.Count), // nolint: gosec
+			Total:     int32(svc.Count), // nolint: gosec
 		}
 	}
 

cluster/inventory.go

@@ -212,7 +212,7 @@ func (is *inventoryService) reserve(order mtypes.OrderID, resources dtypes.Resou
 	}
 }
 
-func (is *inventoryService) unreserve(order mtypes.OrderID) error { // nolint:golint,unparam
+func (is *inventoryService) unreserve(order mtypes.OrderID) error { // nolint: golint,unparam
 	ch := make(chan inventoryResponse, 1)
 	req := inventoryRequest{
 		order: order,

cluster/inventory_test.go

@@ -263,7 +263,7 @@ func TestInventory_ClusterDeploymentDeployed(t *testing.T) {
 	}
 
 	// availableExternalEndpoints should be consumed because of the deployed reservation
-	require.Equal(t, uint(1000-countOfRandomPortService), inv.availableExternalPorts)
+	require.Equal(t, uint(1000-countOfRandomPortService), inv.availableExternalPorts) // nolint: gosec
 
 	// Unreserving the allocated reservation should reclaim the availableExternalEndpoints
 	err = inv.unreserve(lid.OrderID())
@@ -464,8 +464,8 @@ func TestInventory_ReserveIPUnavailableWithIPOperator(t *testing.T) {
 
 	ipQty := testutil.RandRangeInt(1, 100)
 	mockIP.On("GetIPAddressUsage", mock.Anything).Return(cip.AddressUsage{
-		Available: uint(ipQty),
-		InUse:     uint(ipQty),
+		Available: uint(ipQty), // nolint: gosec
+		InUse:     uint(ipQty), // nolint: gosec
 	}, nil)
 	mockIP.On("Stop")
 
@@ -520,8 +520,8 @@ func TestInventory_ReserveIPAvailableWithIPOperator(t *testing.T) {
 
 	ipQty := testutil.RandRangeInt(5, 10)
 	mockIP.On("GetIPAddressUsage", mock.Anything).Return(cip.AddressUsage{
-		Available: uint(ipQty),
-		InUse:     uint(ipQty - 1), // not all in use
+		Available: uint(ipQty),     // nolint: gosec
+		InUse:     uint(ipQty - 1), // nolint: gosec
 	}, nil)
 
 	ipAddrStatusCalled := make(chan struct{}, 2)
@@ -717,5 +717,5 @@ func TestInventory_OverReservations(t *testing.T) {
 	<-inv.lc.Done()
 
 	// No ports used yet
-	require.Equal(t, uint(1000-countOfRandomPortService), inv.availableExternalPorts)
+	require.Equal(t, uint(1000-countOfRandomPortService), inv.availableExternalPorts) // nolint: gosec
 }

cluster/kube/builder/workload.go

@@ -84,8 +84,8 @@ func (b *Workload) container() corev1.Container {
 
 	if cpu := service.Resources.CPU; cpu != nil {
 		requestedCPU := sdlutil.ComputeCommittedResources(b.settings.CPUCommitLevel, cpu.Units)
-		kcontainer.Resources.Requests[corev1.ResourceCPU] = resource.NewScaledQuantity(int64(requestedCPU.Value()), resource.Milli).DeepCopy()
-		kcontainer.Resources.Limits[corev1.ResourceCPU] = resource.NewScaledQuantity(int64(cpu.Units.Value()), resource.Milli).DeepCopy()
+		kcontainer.Resources.Requests[corev1.ResourceCPU] = resource.NewScaledQuantity(int64(requestedCPU.Value()), resource.Milli).DeepCopy() // nolint: gosec
+		kcontainer.Resources.Limits[corev1.ResourceCPU] = resource.NewScaledQuantity(int64(cpu.Units.Value()), resource.Milli).DeepCopy()      // nolint: gosec
 	}
 
 	if gpu := service.Resources.GPU; gpu != nil && gpu.Units.Value() > 0 {
@@ -105,8 +105,8 @@ func (b *Workload) container() corev1.Container {
 		//  - can specify GPU in both limits and requests but these two values must be equal.
 		//  - cannot specify GPU requests without specifying limits.
 		requestedGPU := sdlutil.ComputeCommittedResources(b.settings.GPUCommitLevel, gpu.Units)
-		kcontainer.Resources.Requests[resourceName] = resource.NewQuantity(int64(requestedGPU.Value()), resource.DecimalSI).DeepCopy()
-		kcontainer.Resources.Limits[resourceName] = resource.NewQuantity(int64(gpu.Units.Value()), resource.DecimalSI).DeepCopy()
+		kcontainer.Resources.Requests[resourceName] = resource.NewQuantity(int64(requestedGPU.Value()), resource.DecimalSI).DeepCopy() // nolint: gosec
+		kcontainer.Resources.Limits[resourceName] = resource.NewQuantity(int64(gpu.Units.Value()), resource.DecimalSI).DeepCopy()      // nolint: gosec
 	}
 
 	var requestedMem uint64
@@ -120,8 +120,8 @@ func (b *Workload) container() corev1.Container {
 		if !persistent {
 			if class == "" {
 				requestedStorage := sdlutil.ComputeCommittedResources(b.settings.StorageCommitLevel, ephemeral.Quantity)
-				kcontainer.Resources.Requests[corev1.ResourceEphemeralStorage] = resource.NewQuantity(int64(requestedStorage.Value()), resource.DecimalSI).DeepCopy()
-				kcontainer.Resources.Limits[corev1.ResourceEphemeralStorage] = resource.NewQuantity(int64(ephemeral.Quantity.Value()), resource.DecimalSI).DeepCopy()
+				kcontainer.Resources.Requests[corev1.ResourceEphemeralStorage] = resource.NewQuantity(int64(requestedStorage.Value()), resource.DecimalSI).DeepCopy() // nolint: gosec
+				kcontainer.Resources.Limits[corev1.ResourceEphemeralStorage] = resource.NewQuantity(int64(ephemeral.Quantity.Value()), resource.DecimalSI).DeepCopy() // nolint: gosec
 			} else if class == "ram" {
 				requestedMem += ephemeral.Quantity.Value()
 			}
@@ -131,8 +131,8 @@ func (b *Workload) container() corev1.Container {
 	// fixme: ram is never expected to be nil
 	if mem := service.Resources.Memory; mem != nil {
 		requestedRAM := sdlutil.ComputeCommittedResources(b.settings.MemoryCommitLevel, mem.Quantity)
-		kcontainer.Resources.Requests[corev1.ResourceMemory] = resource.NewQuantity(int64(requestedRAM.Value()), resource.DecimalSI).DeepCopy()
-		kcontainer.Resources.Limits[corev1.ResourceMemory] = resource.NewQuantity(int64(mem.Quantity.Value()+requestedMem), resource.DecimalSI).DeepCopy()
+		kcontainer.Resources.Requests[corev1.ResourceMemory] = resource.NewQuantity(int64(requestedRAM.Value()), resource.DecimalSI).DeepCopy()            // nolint: gosec
+		kcontainer.Resources.Limits[corev1.ResourceMemory] = resource.NewQuantity(int64(mem.Quantity.Value()+requestedMem), resource.DecimalSI).DeepCopy() // nolint: gosec
 	}
 
 	if service.Params != nil {
@@ -161,7 +161,7 @@ func (b *Workload) container() corev1.Container {
 
 	for _, expose := range service.Expose {
 		kcontainer.Ports = append(kcontainer.Ports, corev1.ContainerPort{
-			ContainerPort: int32(expose.Port),
+			ContainerPort: int32(expose.Port), // nolint: gosec
 		})
 	}
 
@@ -232,7 +232,7 @@ func (b *Workload) persistentVolumeClaims() []corev1.PersistentVolumeClaim {
 			},
 		}
 
-		pvc.Spec.Resources.Requests[corev1.ResourceStorage] = resource.NewQuantity(int64(storage.Quantity.Value()), resource.DecimalSI).DeepCopy()
+		pvc.Spec.Resources.Requests[corev1.ResourceStorage] = resource.NewQuantity(int64(storage.Quantity.Value()), resource.DecimalSI).DeepCopy() // nolint: gosec
 
 		attr = storage.Attributes.Find(sdl.StorageAttributeClass)
 		if class, valid := attr.AsString(); valid && class != sdl.StorageClassDefault {
@@ -262,7 +262,7 @@ func (b *Workload) runtimeClass() *string {
 
 func (b *Workload) replicas() *int32 {
 	replicas := new(int32)
-	*replicas = int32(b.deployment.ManifestGroup().Services[b.serviceIdx].Count)
+	*replicas = int32(b.deployment.ManifestGroup().Services[b.serviceIdx].Count) // nolint: gosec
 
 	return replicas
 }

cluster/kube/client.go

@@ -402,7 +402,6 @@ func newEventsFeedList(ctx context.Context, events []eventsv1.Event) ctypes.Even
 
 	done:
 		for _, evt := range events {
-			evt := evt
 			if !wtch.SendEvent(&evt) {
 				break done
 			}
@@ -552,8 +551,8 @@ func (c *client) ForwardedPortStatus(ctx context.Context, leaseID mtypes.LeaseID
 						// Record the actual port inside the container that is exposed
 						v := ctypes.ForwardedPortStatus{
 							Host:         settings.ClusterPublicHostname,
-							Port:         uint16(port.TargetPort.IntVal),
-							ExternalPort: uint16(nodePort),
+							Port:         uint16(port.TargetPort.IntVal), // nolint: gosec
+							ExternalPort: uint16(nodePort),               // nolint: gosec
 							Name:         deploymentName,
 						}
 

cluster/kube/operators/clients/inventory/client.go

@@ -338,7 +338,7 @@ func newInventoryConnector(ctx context.Context, svc *corev1.Service, invch chan<
 				return nil, err
 			}
 		} else {
-			ports = append(ports, portforward.ForwardedPort{Local: uint16(svcPort)})
+			ports = append(ports, portforward.ForwardedPort{Local: uint16(svcPort)}) // nolint: gosec
 		}
 
 		endpoint = fmt.Sprintf("localhost:%d", ports[0].Local)

cluster/kube/operators/clients/inventory/client_test.go

@@ -118,7 +118,7 @@ func (sf *inventoryScaffold) createFakeOperator(t *testing.T) {
 				{
 					Name:       "grpc",
 					Protocol:   "tcp",
-					Port:       int32(sf.ports[0]),
+					Port:       int32(sf.ports[0]), // nolint: gosec
 					TargetPort: intstr.FromString("grpc"),
 				},
 			},
@@ -144,7 +144,7 @@ func (sf *inventoryScaffold) createFakeOperator(t *testing.T) {
 							Ports: []corev1.ContainerPort{
 								{
 									Name:          "grpc",
-									ContainerPort: int32(sf.ports[0]),
+									ContainerPort: int32(sf.ports[0]), // nolint: gosec
 								},
 							},
 						},
@@ -168,7 +168,7 @@ func (sf *inventoryScaffold) createFakeOperator(t *testing.T) {
 					Ports: []corev1.ContainerPort{
 						{
 							Name:          "grpc",
-							ContainerPort: int32(sf.ports[0]),
+							ContainerPort: int32(sf.ports[0]), // nolint: gosec
 						},
 					},
 				},

cluster/kube/operators/clients/inventory/inventory.go

@@ -335,32 +335,32 @@ func (inv *inventory) Metrics() inventoryV1.Metrics {
 		invNode := inventoryV1.NodeMetrics{
 			Name: nd.Name,
 			Allocatable: inventoryV1.ResourcesMetric{
-				CPU:              uint64(nd.Resources.CPU.Quantity.Allocatable.MilliValue()),
-				GPU:              uint64(nd.Resources.GPU.Quantity.Allocatable.Value()),
-				Memory:           uint64(nd.Resources.Memory.Quantity.Allocatable.Value()),
-				StorageEphemeral: uint64(nd.Resources.EphemeralStorage.Allocatable.Value()),
+				CPU:              uint64(nd.Resources.CPU.Quantity.Allocatable.MilliValue()), // nolint: gosec
+				GPU:              uint64(nd.Resources.GPU.Quantity.Allocatable.Value()),      // nolint: gosec
+				Memory:           uint64(nd.Resources.Memory.Quantity.Allocatable.Value()),   // nolint: gosec
+				StorageEphemeral: uint64(nd.Resources.EphemeralStorage.Allocatable.Value()),  // nolint: gosec
 			},
 		}
 
-		cpuTotal += uint64(nd.Resources.CPU.Quantity.Allocatable.MilliValue())
-		gpuTotal += uint64(nd.Resources.GPU.Quantity.Allocatable.Value())
-		memoryTotal += uint64(nd.Resources.Memory.Quantity.Allocatable.Value())
-		storageEphemeralTotal += uint64(nd.Resources.EphemeralStorage.Allocatable.Value())
+		cpuTotal += uint64(nd.Resources.CPU.Quantity.Allocatable.MilliValue())             // nolint: gosec
+		gpuTotal += uint64(nd.Resources.GPU.Quantity.Allocatable.Value())                  // nolint: gosec
+		memoryTotal += uint64(nd.Resources.Memory.Quantity.Allocatable.Value())            // nolint: gosec
+		storageEphemeralTotal += uint64(nd.Resources.EphemeralStorage.Allocatable.Value()) // nolint: gosec
 
 		avail := nd.Resources.CPU.Quantity.Available()
-		invNode.Available.CPU = uint64(avail.MilliValue())
+		invNode.Available.CPU = uint64(avail.MilliValue()) // nolint: gosec
 		cpuAvailable += invNode.Available.CPU
 
 		avail = nd.Resources.GPU.Quantity.Available()
-		invNode.Available.GPU = uint64(avail.Value())
+		invNode.Available.GPU = uint64(avail.Value()) // nolint: gosec
 		gpuAvailable += invNode.Available.GPU
 
 		avail = nd.Resources.Memory.Quantity.Available()
-		invNode.Available.Memory = uint64(avail.Value())
+		invNode.Available.Memory = uint64(avail.Value()) // nolint: gosec
 		memoryAvailable += invNode.Available.Memory
 
 		avail = nd.Resources.EphemeralStorage.Available()
-		invNode.Available.StorageEphemeral = uint64(avail.Value())
+		invNode.Available.StorageEphemeral = uint64(avail.Value()) // nolint: gosec
 		storageEphemeralAvailable += invNode.Available.StorageEphemeral
 
 		ret.Nodes = append(ret.Nodes, invNode)