Grcov report - secret_provider

1

#pragma once

2

3

#include <functional>

4

5

#include "envoy/extensions/transport_sockets/tls/v3/cert.pb.h"

6

#include "envoy/secret/secret_provider.h"

7

#include "envoy/ssl/certificate_validation_context_config.h"

8

#include "envoy/ssl/tls_certificate_config.h"

9

#include "envoy/thread_local/thread_local.h"

10

#include "envoy/thread_local/thread_local_object.h"

11

12

namespace Envoy {

13

namespace Secret {

14

15

template <typename SecretType> class StaticProvider : public SecretProvider<SecretType> {

16

public:

17

  explicit StaticProvider(const SecretType& secret)

18

19942

      : secret_(std::make_unique<SecretType>(secret)) {}

19

20

22359

  const SecretType* secret() const override { return secret_.get(); }

21

22

  ABSL_MUST_USE_RESULT Common::CallbackHandlePtr

23

63

  addValidationCallback(std::function<absl::Status(const SecretType&)>) override {

24

63

    return nullptr;

25

63

26

27

  ABSL_MUST_USE_RESULT Common::CallbackHandlePtr

28

11002

  addUpdateCallback(std::function<absl::Status()>) override {

29

11002

    return nullptr;

30

11002

31

32

  ABSL_MUST_USE_RESULT Common::CallbackHandlePtr

33

1

  addRemoveCallback(std::function<absl::Status()>) override {

34

1

    return nullptr;

35

1

36

37

1

  void start() override {}

38

39

private:

40

  const std::unique_ptr<SecretType> secret_;

41

};

42

43

using TlsCertificateConfigProviderImpl =

44

    StaticProvider<envoy::extensions::transport_sockets::tls::v3::TlsCertificate>;

45

using CertificateValidationContextConfigProviderImpl =

46

    StaticProvider<envoy::extensions::transport_sockets::tls::v3::CertificateValidationContext>;

47

using TlsSessionTicketKeysConfigProviderImpl =

48

    StaticProvider<envoy::extensions::transport_sockets::tls::v3::TlsSessionTicketKeys>;

49

using GenericSecretConfigProviderImpl =

50

    StaticProvider<envoy::extensions::transport_sockets::tls::v3::GenericSecret>;

51

52

/**

53

 * A utility secret provider that uses thread local values to share the updates to the secrets from

54

 * the main to the workers.

55

**/

56

class ThreadLocalGenericSecretProvider {

57

public:

58

  static absl::StatusOr<std::unique_ptr<ThreadLocalGenericSecretProvider>>

59

  create(GenericSecretConfigProviderSharedPtr&& provider, ThreadLocal::SlotAllocator& tls,

60

         Api::Api& api);

61

  const std::string& secret() const;

62

63

protected:

64

  ThreadLocalGenericSecretProvider(GenericSecretConfigProviderSharedPtr&& provider,

65

                                   ThreadLocal::SlotAllocator& tls, Api::Api& api,

66

                                   absl::Status& creation_status);

67

68

private:

69

  struct ThreadLocalSecret : public ThreadLocal::ThreadLocalObject {

70

216

    explicit ThreadLocalSecret(const std::string& value) : value_(value) {}

71

    std::string value_;

72

};

73

  absl::Status update();

74

  GenericSecretConfigProviderSharedPtr provider_;

75

  Api::Api& api_;

76

  ThreadLocal::TypedSlotPtr<ThreadLocalSecret> tls_;

77

  // Must be last since it has a non-trivial de-registering destructor.

78

  Common::CallbackHandlePtr cb_;

79

};

80

81

} // namespace Secret

82

} // namespace Envoy