Grcov report - config.cc

1

#include "source/extensions/transport_sockets/tap/config.h"

2

3

#include "envoy/config/tap/v3/common.pb.h"

4

#include "envoy/extensions/transport_sockets/tap/v3/tap.pb.h"

5

#include "envoy/extensions/transport_sockets/tap/v3/tap.pb.validate.h"

6

#include "envoy/registry/registry.h"

7

8

#include "source/common/config/utility.h"

9

#include "source/common/protobuf/utility.h"

10

#include "source/extensions/transport_sockets/tap/tap.h"

11

#include "source/extensions/transport_sockets/tap/tap_config_impl.h"

12

13

namespace Envoy {

14

namespace Extensions {

15

namespace TransportSockets {

16

namespace Tap {

17

18

class SocketTapConfigFactoryImpl : public Extensions::Common::Tap::TapConfigFactory {

19

public:

20

  SocketTapConfigFactoryImpl(TimeSource& time_source,

21

                             Server::Configuration::TransportSocketFactoryContext& context)

22

9

      : time_source_(time_source), factory_context_(context) {}

23

24

  // TapConfigFactory

25

  Extensions::Common::Tap::TapConfigSharedPtr

26

  createConfigFromProto(const envoy::config::tap::v3::TapConfig& proto_config,

27

7

                        Extensions::Common::Tap::Sink* admin_streamer) override {

28

7

    return std::make_shared<SocketTapConfigImpl>(std::move(proto_config), admin_streamer,

29

7

                                                 time_source_, factory_context_);

30

7

31

32

private:

33

  TimeSource& time_source_;

34

  Server::Configuration::TransportSocketFactoryContext& factory_context_;

35

};

36

37

absl::StatusOr<Network::UpstreamTransportSocketFactoryPtr>

38

UpstreamTapSocketConfigFactory::createTransportSocketFactory(

39

    const Protobuf::Message& message,

40

4

    Server::Configuration::TransportSocketFactoryContext& context) {

41

4

  const auto& outer_config =

42

4

      MessageUtil::downcastAndValidate<const envoy::extensions::transport_sockets::tap::v3::Tap&>(

43

4

          message, context.messageValidationVisitor());

44

4

  auto& inner_config_factory = Config::Utility::getAndCheckFactory<

45

4

      Server::Configuration::UpstreamTransportSocketConfigFactory>(outer_config.transport_socket());

46

4

  ProtobufTypes::MessagePtr inner_factory_config = Config::Utility::translateToFactoryConfig(

47

4

      outer_config.transport_socket(), context.messageValidationVisitor(), inner_config_factory);

48

4

  auto factory_or_error =

49

4

      inner_config_factory.createTransportSocketFactory(*inner_factory_config, context);

50

4

  RETURN_IF_NOT_OK_REF(factory_or_error.status());

51

52

4

  auto& server_context = context.serverFactoryContext();

53

4

  return std::make_unique<TapSocketFactory>(

54

4

      outer_config,

55

4

      std::make_unique<SocketTapConfigFactoryImpl>(

56

4

          server_context.mainThreadDispatcher().timeSource(), context),

57

4

      server_context.admin(), server_context.singletonManager(), server_context.threadLocal(),

58

4

      server_context.mainThreadDispatcher(), server_context.scope(),

59

4

      std::move(factory_or_error.value()));

60

4

61

62

absl::StatusOr<Network::DownstreamTransportSocketFactoryPtr>

63

DownstreamTapSocketConfigFactory::createTransportSocketFactory(

64

    const Protobuf::Message& message, Server::Configuration::TransportSocketFactoryContext& context,

65

5

    const std::vector<std::string>& server_names) {

66

5

  const auto& outer_config =

67

5

      MessageUtil::downcastAndValidate<const envoy::extensions::transport_sockets::tap::v3::Tap&>(

68

5

          message, context.messageValidationVisitor());

69

5

  auto& inner_config_factory = Config::Utility::getAndCheckFactory<

70

5

      Server::Configuration::DownstreamTransportSocketConfigFactory>(

71

5

      outer_config.transport_socket());

72

5

  ProtobufTypes::MessagePtr inner_factory_config = Config::Utility::translateToFactoryConfig(

73

5

      outer_config.transport_socket(), context.messageValidationVisitor(), inner_config_factory);

74

5

  auto factory_or_error = inner_config_factory.createTransportSocketFactory(*inner_factory_config,

75

5

                                                                            context, server_names);

76

5

  RETURN_IF_NOT_OK_REF(factory_or_error.status());

77

5

  auto& server_context = context.serverFactoryContext();

78

5

  return std::make_unique<DownstreamTapSocketFactory>(

79

5

      outer_config,

80

5

      std::make_unique<SocketTapConfigFactoryImpl>(

81

5

          server_context.mainThreadDispatcher().timeSource(), context),

82

5

      server_context.admin(), server_context.singletonManager(), server_context.threadLocal(),

83

5

      server_context.mainThreadDispatcher(), server_context.scope(),

84

5

      std::move(factory_or_error.value()));

85

5

86

87

15

ProtobufTypes::MessagePtr TapSocketConfigFactory::createEmptyConfigProto() {

88

15

  return std::make_unique<envoy::extensions::transport_sockets::tap::v3::Tap>();

89

15

90

91

REGISTER_FACTORY(UpstreamTapSocketConfigFactory,

92

                 Server::Configuration::UpstreamTransportSocketConfigFactory);

93

94

REGISTER_FACTORY(DownstreamTapSocketConfigFactory,

95

                 Server::Configuration::DownstreamTransportSocketConfigFactory);

96

97

} // namespace Tap

98

} // namespace TransportSockets

99

} // namespace Extensions

100

} // namespace Envoy