Coverage for /Users/buh/.pyenv/versions/3.12.9/envs/es-testbed/lib/python3.12/site-packages/es_testbed/mgrs/index.py: 97%

70 statements  

« prev     ^ index     » next       coverage.py v7.6.12, created at 2025-03-17 19:30 -0600

1"""Index Entity Manager Class""" 

2 

3import typing as t 

4import logging 

5from importlib import import_module 

6from es_testbed.entities import Alias, Index 

7from es_testbed.helpers.es_api import create_index, fill_index 

8from es_testbed.helpers.utils import prettystr 

9from es_testbed.mgrs.entity import EntityMgr 

10from es_testbed.mgrs.snapshot import SnapshotMgr 

11 

12if t.TYPE_CHECKING: 

13 from elasticsearch8 import Elasticsearch 

14 from dotmap import DotMap 

15 

16logger = logging.getLogger(__name__) 

17 

18 

19class IndexMgr(EntityMgr): 

20 """Index Entity Manager Class""" 

21 

22 kind = 'index' 

23 listname = 'indices' 

24 

25 def __init__( 

26 self, 

27 client: t.Optional['Elasticsearch'] = None, 

28 plan: t.Optional['DotMap'] = None, 

29 snapmgr: t.Optional[SnapshotMgr] = None, 

30 ): 

31 self.snapmgr = snapmgr 

32 self.alias = None # Only used for tracking the rollover alias 

33 super().__init__(client=client, plan=plan) 

34 

35 @property 

36 def indexlist(self) -> t.Sequence[str]: 

37 """Return a list of index names currently being managed""" 

38 return [x.name for x in self.entity_list] 

39 

40 @property 

41 def policy_name(self) -> t.Union[str, None]: 

42 """Return the name of the ILM policy, if it exists""" 

43 if len(self.plan.ilm_policies) > 0: 

44 return self.plan.ilm_policies[-1] 

45 return None 

46 

47 def _rollover_path(self) -> None: 

48 """This is the execution path for rollover indices""" 

49 if not self.entity_list: 

50 acfg = {self.plan.rollover_alias: {'is_write_index': True}} 

51 create_index(self.client, self.name, aliases=acfg) 

52 self.track_alias() 

53 else: 

54 self.alias.rollover() 

55 if self.policy_name: # We have an ILM policy 

56 kw = {'phase': 'hot', 'action': 'complete', 'name': 'complete'} 

57 self.last.ilm_tracker.advance(**kw) 

58 

59 def add(self, value) -> None: 

60 """Create a single index""" 

61 logger.debug(f'Creating index: "{value}"') 

62 create_index(self.client, value) 

63 

64 def add_indices(self) -> None: 

65 """Add indices according to plan""" 

66 mod = import_module(f'{self.plan.modpath}.functions') 

67 func = getattr(mod, 'doc_generator') 

68 for scheme in self.plan.index_buildlist: 

69 if self.plan.rollover_alias: 

70 self._rollover_path() 

71 else: 

72 self.add(self.name) 

73 # self.filler(scheme) 

74 fill_index( 

75 self.client, 

76 name=self.name, 

77 doc_generator=func, 

78 options=scheme['options'], 

79 ) 

80 self.track_index(self.name) 

81 logger.debug(f'Created indices: {prettystr(self.indexlist)}') 

82 if self.plan.rollover_alias: 

83 if not self.alias.verify(self.indexlist): 

84 logger.error( 

85 f'Unable to confirm rollover of alias ' 

86 f'"{self.plan.rollover_alias}" was successful' 

87 ) 

88 

89 def searchable(self) -> None: 

90 """If the indices were marked as searchable snapshots, we do that now""" 

91 for idx, scheme in enumerate(self.plan.index_buildlist): 

92 if scheme['target_tier'] in ['cold', 'frozen']: 

93 self.entity_list[idx].mount_ss(scheme) 

94 

95 def setup(self) -> None: 

96 """Setup the entity manager""" 

97 logger.debug('Beginning setup...') 

98 logger.debug(f'PLAN: {prettystr(self.plan.toDict())}') 

99 if self.plan.rollover_alias: 

100 logger.debug('rollover_alias is True...') 

101 self.add_indices() 

102 self.searchable() 

103 logger.info(f'Successfully created indices: {prettystr(self.indexlist)}') 

104 

105 def track_alias(self) -> None: 

106 """Track a rollover alias""" 

107 logger.debug(f'Tracking alias: {self.plan.rollover_alias}') 

108 self.alias = Alias(client=self.client, name=self.plan.rollover_alias) 

109 

110 def track_index(self, name: str) -> None: 

111 """Track an index and append that tracking entity to entity_list""" 

112 logger.debug(f'Tracking index: {name}') 

113 entity = Index( 

114 client=self.client, 

115 name=name, 

116 snapmgr=self.snapmgr, 

117 policy_name=self.policy_name, 

118 ) 

119 entity.track_ilm(self.name) 

120 self.entity_list.append(entity)