added to OSN new handler for update config of channel

Signed-off-by: Fedor Partanskiy <fredprtnsk@gmail.com>

Author: pfi79

cmd/osnadmin/main.go

@@ -58,6 +58,10 @@ func executeForArgs(args []string) (output string, exit int, err error) {
 	remove := channel.Command("remove", "Remove a channel from an Ordering Service Node (OSN).")
 	removeChannelID := remove.Flag("channelID", "Channel ID").Short('c').Required().String()
 
+	update := channel.Command("update", "Update an Ordering Service Node (OSN) to a channel.")
+	updateChannelID := update.Flag("channelID", "Channel ID").Short('c').Required().String()
+	configUpdateEnvelopePath := update.Flag("config-update-envelope", "Path to the file containing an up-to-date config update envelope for the channel").Short('e').Required().String()
+
 	command, err := app.Parse(args)
 	if err != nil {
 		return "", 1, err
@@ -105,6 +109,19 @@ func executeForArgs(args []string) (output string, exit int, err error) {
 		}
 	}
 
+	var marshaledConfigEnvelope []byte
+	if *configUpdateEnvelopePath != "" {
+		marshaledConfigEnvelope, err = os.ReadFile(*configUpdateEnvelopePath)
+		if err != nil {
+			return "", 1, fmt.Errorf("reading config updte envelope: %s", err)
+		}
+
+		err = validateEnvelopeChannelID(marshaledConfigEnvelope, *updateChannelID)
+		if err != nil {
+			return "", 1, err
+		}
+	}
+
 	//
 	// call the underlying implementations
 	//
@@ -121,6 +138,8 @@ func executeForArgs(args []string) (output string, exit int, err error) {
 		resp, err = osnadmin.ListAllChannels(osnURL, caCertPool, tlsClientCert)
 	case remove.FullCommand():
 		resp, err = osnadmin.Remove(osnURL, *removeChannelID, caCertPool, tlsClientCert)
+	case update.FullCommand():
+		resp, err = osnadmin.Update(osnURL, marshaledConfigEnvelope, caCertPool, tlsClientCert)
 	}
 	if err != nil {
 		return errorOutput(err), 1, nil
@@ -186,3 +205,24 @@ func validateBlockChannelID(blockBytes []byte, channelID string) error {
 
 	return nil
 }
+
+func validateEnvelopeChannelID(envelopeBytes []byte, channelID string) error {
+	envelope := &common.Envelope{}
+	err := proto.Unmarshal(envelopeBytes, envelope)
+	if err != nil {
+		return fmt.Errorf("unmarshalling envelope: %s", err)
+	}
+
+	envelopeChannelID, err := protoutil.GetChannelIDFromEnvelope(envelope)
+	if err != nil {
+		return err
+	}
+
+	// quick sanity check that the orderer admin is joining
+	// the channel they think they're joining.
+	if channelID != envelopeChannelID {
+		return fmt.Errorf("specified --channelID %s does not match channel ID %s in config update envelope", channelID, envelopeChannelID)
+	}
+
+	return nil
+}

cmd/osnadmin/main_test.go

@@ -532,134 +532,188 @@ var _ = Describe("osnadmin", func() {
 		})
 	})
 
-	Describe("Flags", func() {
-		It("accepts short versions of the --orderer-address, --channelID, and --config-block flags", func() {
-			configBlock := blockWithGroups(
+	Describe("Update", func() {
+		var envelopePath string
+
+		BeforeEach(func() {
+			configEnvelope := envelopeUpdateConfigWithGroups(
 				map[string]*cb.ConfigGroup{
 					"Application": {},
 				},
 				"testing123",
 			)
-			blockPath := createBlockFile(tempDir, configBlock)
-			mockChannelManagement.JoinChannelReturns(types.ChannelInfo{
-				Name:              "apple",
-				ConsensusRelation: "banana",
-				Status:            "orange",
-				Height:            123,
+			envelopePath = createEnvelopeFile(tempDir, configEnvelope)
+
+			mockChannelManagement.UpdateChannelReturns(types.ChannelInfo{
+				Name:   "apple",
+				Height: 123,
 			}, nil)
+		})
 
+		It("uses the channel participation API to join a channel", func() {
 			args := []string{
 				"channel",
-				"join",
-				"-o", ordererURL,
-				"-c", channelID,
-				"-b", blockPath,
+				"update",
+				"--orderer-address", ordererURL,
+				"--channelID", channelID,
+				"--config-update-envelope", envelopePath,
 				"--ca-file", ordererCACert,
 				"--client-cert", clientCert,
 				"--client-key", clientKey,
 			}
 			output, exit, err := executeForArgs(args)
 			expectedOutput := types.ChannelInfo{
-				Name:              "apple",
-				URL:               "/participation/v1/channels/apple",
-				ConsensusRelation: "banana",
-				Status:            "orange",
-				Height:            123,
+				Name:   "apple",
+				URL:    "/participation/v1/channels/apple",
+				Height: 123,
 			}
 			checkStatusOutput(output, exit, err, 201, expectedOutput)
 		})
 
-		Context("when an unknown flag is used", func() {
-			It("returns an error for long flags", func() {
-				_, _, err := executeForArgs([]string{"channel", "list", "--bad-flag"})
-				Expect(err).To(MatchError("unknown long flag '--bad-flag'"))
+		Context("when the envelope is empty", func() {
+			BeforeEach(func() {
+				envelopePath = createEnvelopeFile(tempDir, &cb.Envelope{})
 			})
 
-			It("returns an error for short flags", func() {
-				_, _, err := executeForArgs([]string{"channel", "list", "-z"})
-				Expect(err).To(MatchError("unknown short flag '-z'"))
+			It("returns with exit code 1 and prints the error", func() {
+				args := []string{
+					"channel",
+					"update",
+					"--orderer-address", ordererURL,
+					"--channelID", channelID,
+					"--config-update-envelope", envelopePath,
+					"--ca-file", ordererCACert,
+					"--client-cert", clientCert,
+					"--client-key", clientKey,
+				}
+				output, exit, err := executeForArgs(args)
+
+				checkFlagError(output, exit, err, "failed to retrieve channel id - payload header is empty")
 			})
 		})
 
-		Context("when the ca cert cannot be read", func() {
+		Context("when the --channelID does not match the channel ID in the envelope", func() {
 			BeforeEach(func() {
-				ordererCACert = "not-the-ca-cert-youre-looking-for"
+				channelID = "not-the-channel-youre-looking-for"
 			})
 
 			It("returns with exit code 1 and prints the error", func() {
 				args := []string{
 					"channel",
-					"list",
+					"update",
 					"--orderer-address", ordererURL,
 					"--channelID", channelID,
+					"--config-update-envelope", envelopePath,
 					"--ca-file", ordererCACert,
 					"--client-cert", clientCert,
 					"--client-key", clientKey,
 				}
 				output, exit, err := executeForArgs(args)
-				checkFlagError(output, exit, err, "reading orderer CA certificate: open not-the-ca-cert-youre-looking-for: no such file or directory")
+
+				checkFlagError(output, exit, err, "specified --channelID not-the-channel-youre-looking-for does not match channel ID testing123 in config update envelope")
 			})
 		})
 
-		Context("when the ca-file contains a private key instead of certificate(s)", func() {
+		Context("when the envelope isn't a valid config update", func() {
 			BeforeEach(func() {
-				ordererCACert = clientKey
+				envelope := &cb.Envelope{
+					Payload: protoutil.MarshalOrPanic(&cb.Payload{
+						Header: &cb.Header{
+							ChannelHeader: protoutil.MarshalOrPanic(&cb.ChannelHeader{
+								Type:      int32(cb.HeaderType_ENDORSER_TRANSACTION),
+								ChannelId: channelID,
+							}),
+						},
+					}),
+				}
+				envelopePath = createEnvelopeFile(tempDir, envelope)
 			})
 
-			It("returns with exit code 1 and prints the error", func() {
+			It("returns 405 bad request", func() {
 				args := []string{
 					"channel",
-					"remove",
+					"update",
 					"--orderer-address", ordererURL,
 					"--channelID", channelID,
+					"--config-update-envelope", envelopePath,
 					"--ca-file", ordererCACert,
 					"--client-cert", clientCert,
 					"--client-key", clientKey,
 				}
 				output, exit, err := executeForArgs(args)
-				checkFlagError(output, exit, err, "failed to add ca-file PEM to cert pool")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(exit).To(Equal(0))
+
+				expectedOutput := types.ErrorResponse{
+					Error: "invalid config update envelope: bad type",
+				}
+				checkStatusOutput(output, exit, err, 400, expectedOutput)
 			})
 		})
 
-		Context("when the client cert/key pair fail to load", func() {
+		Context("when updating the channel fails", func() {
 			BeforeEach(func() {
-				clientKey = "brussel-sprouts"
+				mockChannelManagement.UpdateChannelReturns(types.ChannelInfo{}, types.ErrChannelNotExist)
 			})
 
-			It("returns with exit code 1 and prints the error", func() {
+			It("returns 405 not allowed", func() {
 				args := []string{
 					"channel",
-					"list",
+					"update",
 					"--orderer-address", ordererURL,
+					"--channelID", channelID,
+					"--config-update-envelope", envelopePath,
 					"--ca-file", ordererCACert,
 					"--client-cert", clientCert,
 					"--client-key", clientKey,
 				}
 				output, exit, err := executeForArgs(args)
-				checkFlagError(output, exit, err, "loading client cert/key pair: open brussel-sprouts: no such file or directory")
+				expectedOutput := types.ErrorResponse{
+					Error: "cannot update: channel does not exist",
+				}
+				checkStatusOutput(output, exit, err, 405, expectedOutput)
 			})
-		})
 
-		Context("when the config block cannot be read", func() {
-			var configBlockPath string
+			It("returns 405 not allowed (without status)", func() {
+				args := []string{
+					"channel",
+					"update",
+					"--orderer-address", ordererURL,
+					"--channelID", channelID,
+					"--config-update-envelope", envelopePath,
+					"--ca-file", ordererCACert,
+					"--client-cert", clientCert,
+					"--client-key", clientKey,
+					"--no-status",
+				}
+				output, exit, err := executeForArgs(args)
+				expectedOutput := types.ErrorResponse{
+					Error: "cannot update: channel does not exist",
+				}
+				checkOutput(output, exit, err, expectedOutput)
+			})
+		})
 
+		Context("when TLS is disabled", func() {
 			BeforeEach(func() {
-				configBlockPath = "not-the-config-block-youre-looking-for"
+				tlsConfig = nil
 			})
 
-			It("returns with exit code 1 and prints the error", func() {
+			It("uses the channel participation API to join a channel", func() {
 				args := []string{
 					"channel",
-					"join",
+					"update",
 					"--orderer-address", ordererURL,
 					"--channelID", channelID,
-					"--ca-file", ordererCACert,
-					"--client-cert", clientCert,
-					"--client-key", clientKey,
-					"--config-block", configBlockPath,
+					"--config-update-envelope", envelopePath,
 				}
 				output, exit, err := executeForArgs(args)
-				checkFlagError(output, exit, err, "reading config block: open not-the-config-block-youre-looking-for: no such file or directory")
+				expectedOutput := types.ChannelInfo{
+					Name:   "apple",
+					URL:    "/participation/v1/channels/apple",
+					Height: 123,
+				}
+				checkStatusOutput(output, exit, err, 201, expectedOutput)
 			})
 		})
 	})
@@ -834,3 +888,51 @@ func createBlockFile(tempDir string, configBlock *cb.Block) string {
 	Expect(err).NotTo(HaveOccurred())
 	return blockPath
 }
+
+func envelopeUpdateConfigWithGroups(groups map[string]*cb.ConfigGroup, channelID string) *cb.Envelope {
+	data := &cb.Envelope{
+		Payload: protoutil.MarshalOrPanic(&cb.Payload{
+			Data: protoutil.MarshalOrPanic(&cb.ConfigEnvelope{
+				Config: &cb.Config{
+					ChannelGroup: &cb.ConfigGroup{
+						Groups: groups,
+						Values: map[string]*cb.ConfigValue{
+							"HashingAlgorithm": {
+								Value: protoutil.MarshalOrPanic(&cb.HashingAlgorithm{
+									Name: bccsp.SHA256,
+								}),
+							},
+							"BlockDataHashingStructure": {
+								Value: protoutil.MarshalOrPanic(&cb.BlockDataHashingStructure{
+									Width: math.MaxUint32,
+								}),
+							},
+							"OrdererAddresses": {
+								Value: protoutil.MarshalOrPanic(&cb.OrdererAddresses{
+									Addresses: []string{"localhost"},
+								}),
+							},
+						},
+					},
+				},
+			}),
+			Header: &cb.Header{
+				ChannelHeader: protoutil.MarshalOrPanic(&cb.ChannelHeader{
+					Type:      int32(cb.HeaderType_CONFIG_UPDATE),
+					ChannelId: channelID,
+				}),
+			},
+		}),
+	}
+
+	return data
+}
+
+func createEnvelopeFile(tempDir string, configEnvelope *cb.Envelope) string {
+	envelopeBytes, err := proto.Marshal(configEnvelope)
+	Expect(err).NotTo(HaveOccurred())
+	envelopePath := filepath.Join(tempDir, "envelope.pb")
+	err = os.WriteFile(envelopePath, envelopeBytes, 0o644)
+	Expect(err).NotTo(HaveOccurred())
+	return envelopePath
+}