Method WaveFileReadStreamCommand

pkg/wshrpc/wshserver/wshserver.go:1035–1086

(ctx context.Context, data wshrpc.CommandWaveFileReadStreamData)

}

func (ws *WshServer) WaveFileReadStreamCommand(ctx context.Context, data wshrpc.CommandWaveFileReadStreamData) (*wshrpc.WaveFileInfo, error) {
	const maxStreamFileSize = 5 * 1024 * 1024

	waveFile, err := filestore.WFS.Stat(ctx, data.ZoneId, data.Name)
	if err != nil {
		return nil, fmt.Errorf("error statting wavefile: %w", err)
	}

	dataLength := waveFile.DataLength()
	if dataLength > maxStreamFileSize {
		return nil, fmt.Errorf("file size %d exceeds maximum streaming size of %d bytes", dataLength, maxStreamFileSize)
	}

	wshRpc := wshutil.GetWshRpcFromContext(ctx)
	if wshRpc == nil || wshRpc.StreamBroker == nil {
		return nil, fmt.Errorf("no stream broker available")
	}

	writer, err := wshRpc.StreamBroker.CreateStreamWriter(&data.StreamMeta)
	if err != nil {
		return nil, fmt.Errorf("error creating stream writer: %w", err)
	}

	_, fileData, err := filestore.WFS.ReadFile(ctx, data.ZoneId, data.Name)
	if err != nil {
		writer.Close()
		return nil, fmt.Errorf("error reading wavefile: %w", err)
	}

	go func() {
		defer func() {
			panichandler.PanicHandler("WaveFileReadStreamCommand", recover())
		}()
		defer writer.Close()

		_, err := writer.Write(fileData)
		if err != nil {
			log.Printf("error writing to stream for wavefile %s:%s: %v\n", data.ZoneId, data.Name, err)
		}
	}()

	rtnInfo := &wshrpc.WaveFileInfo{
		ZoneId:    waveFile.ZoneId,
		Name:      waveFile.Name,
		Opts:      waveFile.Opts,
		CreatedTs: waveFile.CreatedTs,
		Size:      waveFile.Size,
		ModTs:     waveFile.ModTs,
		Meta:      waveFile.Meta,
	}
	return rtnInfo, nil
}

func (ws *WshServer) WriteAppGoFileCommand(ctx context.Context, data wshrpc.CommandWriteAppGoFileData) (*wshrpc.CommandWriteAppGoFileRtnData, error) {
	if data.AppId == "" {