wip

Author: michaelfig

golang/cosmos/proto/agoric/swingset/msgs.proto

@@ -187,6 +187,7 @@ message MsgSendChunkResponse {
     (gogoproto.jsontag)    = "chunk",
     (gogoproto.moretags)   = "yaml:\"chunk\""
   ];
+  // If this chunk completed the installation, this is the response from the chain.
   MsgInstallBundleResponse install_response = 3 [
     (gogoproto.jsontag)    = "install_response",
     (gogoproto.moretags)   = "yaml:\"install_response\""

golang/cosmos/proto/agoric/swingset/swingset.proto

@@ -218,23 +218,18 @@ message SwingStoreArtifact {
     ];
 }
 
+// FIXME: mhofman: ChunkedArtifact?
 // BundleChunks is the manifest for a chunked InstallBundle.
 message BundleChunks {
-    // The hash of the complete bundle.
-    string bundle_hash = 1 [
-        (gogoproto.jsontag)    = "bundle_hash",
-        (gogoproto.moretags)   = "yaml:\"bundle_hash\""
-    ];
-
-    // The size of the final bundle artifact in bytes.
-    uint64 bundle_size = 2 [
-        (gogoproto.jsontag)    = "bundle_size",
-        (gogoproto.moretags)   = "yaml:\"bundle_size\""
+    // The size of the final artifact in bytes.
+    uint64 total_size = 1 [
+        (gogoproto.jsontag)    = "total_size",
+        (gogoproto.moretags)   = "yaml:\"total_size\""
     ];
 
     // Information about the chunks that will be concatenated to form this
     // bundle.
-    repeated ChunkInfo chunks = 3 [
+    repeated ChunkInfo chunks = 2 [
         (gogoproto.jsontag)    = "chunks",
         (gogoproto.moretags)   = "yaml:\"chunks\""
     ];

golang/cosmos/x/swingset/abci.go

@@ -35,8 +35,6 @@ type afterCommitBlockAction struct {
 func BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock, keeper Keeper) error {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker)
 
-	keeper.PruneExpiredBundleInstalls(ctx)
-
 	action := beginBlockAction{
 		ChainID: ctx.ChainID(),
 		Params:  keeper.GetParams(ctx),
@@ -68,6 +66,9 @@ func EndBlock(ctx sdk.Context, req abci.RequestEndBlock, keeper Keeper) ([]abci.
 		panic(err)
 	}
 
+	// Remove expired bundle installs.
+	keeper.PruneExpiredBundleInstalls(ctx)
+
 	// Save our EndBlock status.
 	endBlockHeight = ctx.BlockHeight()
 	endBlockTime = ctx.BlockTime().Unix()

golang/cosmos/x/swingset/keeper/msg_server.go

@@ -203,6 +203,9 @@ func (keeper msgServer) InstallBundle(goCtx context.Context, msg *types.MsgInsta
 	bc.Chunks = make([]*types.ChunkInfo, len(bc.Chunks))
 	for i, chunk := range bc.Chunks {
 		ci := *chunk
+		if ci.State != types.ChunkState_CHUNK_STATE_UNSPECIFIED {
+			return nil, fmt.Errorf("chunk %d state is not unspecified for pending Id %d", i, msg.PendingId)
+		}
 		ci.State = types.ChunkState_CHUNK_STATE_IN_FLIGHT
 		bc.Chunks[i] = &ci
 	}

golang/cosmos/x/swingset/types/msgs.go

@@ -59,12 +59,12 @@ type InboundQueueRecord struct {
 }
 
 const (
-	// bundleUncompressedSizeLimit is the (exclusive) limit on uncompressed bundle size.
+	// BundleUncompressedSizeLimit is the (exclusive) limit on uncompressed bundle size.
 	// We must ensure there is an exclusive int64 limit in order to detect an underflow.
-	bundleUncompressedSizeLimit uint64 = 10 * 1024 * 1024 // 10MB
-	chunkSizeLimit              uint64 = 512 * 1024       // 512KB
-	chunkIndexLimit             uint64 = (bundleUncompressedSizeLimit + chunkSizeLimit - 1) / chunkSizeLimit
-	hashLimit                   int    = 128
+	BundleUncompressedSizeLimit uint64 = 10 * 1024 * 1024 // 10MB
+	ChunkSizeLimit              uint64 = 512 * 1024       // 512KB
+	ChunkIndexLimit             uint64 = (BundleUncompressedSizeLimit + ChunkSizeLimit - 1) / ChunkSizeLimit
+	HashSize                    int    = 256 / 8 * 2
 )
 
 // Charge an account address for the beans associated with given messages and storage.
@@ -441,7 +441,7 @@ func (msg MsgInstallBundle) ValidateBasic() error {
 		return sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, "Uncompressed size must be set with a compressed bundle")
 	case msg.UncompressedSize != 0 && hasBundle:
 		return sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, "Uncompressed size cannot be set with a legacy bundle")
-	case uint64(msg.UncompressedSize) >= bundleUncompressedSizeLimit:
+	case uint64(msg.UncompressedSize) >= BundleUncompressedSizeLimit:
 		// must enforce a limit to avoid overflow when computing its successor in Uncompress()
 		return sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, "Uncompressed size out of range")
 	}
@@ -523,26 +523,26 @@ func (bc BundleChunks) ValidateBasic() error {
 	if len(bc.Chunks) == 0 {
 		return sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, "Bundle chunks cannot be empty")
 	}
-	if uint64(len(bc.Chunks)) >= chunkIndexLimit {
-		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Number of bundle chunks must be less than %d", chunkIndexLimit)
+	if uint64(len(bc.Chunks)) >= ChunkIndexLimit {
+		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Number of bundle chunks must be less than %d", ChunkIndexLimit)
 	}
-	if len(bc.BundleHash) > hashLimit {
-		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Bundle hash must not exceed %d characters", hashLimit)
+	if len(bc.BundleHash) != HashSize {
+		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Bundle hash must be %d characters", HashSize)
 	}
 	if !IsHexBytes(bc.BundleHash) {
 		return sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, "Bundle hash must be a hex byte string")
 	}
-	if bc.BundleSize <= 0 || bc.BundleSize >= bundleUncompressedSizeLimit {
+	if bc.BundleSize <= 0 || bc.BundleSize >= BundleUncompressedSizeLimit {
 		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Bundle size out of range")
 	}
 	totalChunkSize := uint64(0)
 	for i, chunk := range bc.Chunks {
-		if chunk.ChunkSize <= 0 || chunk.ChunkSize >= chunkSizeLimit {
+		if chunk.ChunkSize <= 0 || chunk.ChunkSize >= ChunkSizeLimit {
 			return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk %d size out of range", i)
 		}
 		totalChunkSize += chunk.ChunkSize
-		if len(chunk.Hash) > hashLimit {
-			return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk %d hash must not exceed %d characters", i, hashLimit)
+		if len(chunk.Hash) != HashSize {
+			return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk %d hash must be %d characters", i, HashSize)
 		}
 		if !IsHexBytes(chunk.Hash) {
 			return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk %d hash must be a hex byte string", i)
@@ -610,11 +610,11 @@ func (msg MsgSendChunk) ValidateBasic() error {
 	if len(msg.ChunkData) == 0 {
 		return sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, "Chunk data cannot be empty")
 	}
-	if uint64(len(msg.ChunkData)) >= chunkSizeLimit {
-		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk size must be less than than %d", chunkSizeLimit)
+	if uint64(len(msg.ChunkData)) >= ChunkSizeLimit {
+		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk size must be less than than %d", ChunkSizeLimit)
 	}
-	if msg.ChunkIndex >= chunkIndexLimit {
-		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk index must be less than %d", chunkIndexLimit)
+	if msg.ChunkIndex >= ChunkIndexLimit {
+		return sdkioerrors.Wrapf(sdkerrors.ErrUnknownRequest, "Chunk index must be less than %d", ChunkIndexLimit)
 	}
 	return nil
 }

golang/cosmos/x/swingset/types/msgs_test.go

@@ -151,7 +151,7 @@ func TestInstallBundle_ValidateBasic(t *testing.T) {
 			msg: &MsgInstallBundle{
 				Submitter:        addr,
 				CompressedBundle: []byte{1, 2, 3},
-				UncompressedSize: int64(bundleUncompressedSizeLimit - 1),
+				UncompressedSize: int64(BundleUncompressedSizeLimit - 1),
 			},
 		},
 
@@ -160,7 +160,7 @@ func TestInstallBundle_ValidateBasic(t *testing.T) {
 			msg: &MsgInstallBundle{
 				Submitter:        addr,
 				CompressedBundle: []byte{1, 2, 3},
-				UncompressedSize: int64(bundleUncompressedSizeLimit),
+				UncompressedSize: int64(BundleUncompressedSizeLimit),
 			},
 			shouldErr: true,
 		},