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

74 statements  

« prev     ^ index     » next       coverage.py v7.4.4, created at 2024-08-30 19:06 -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.Union['Elasticsearch', None] = None, 

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

29 snapmgr: t.Union[SnapshotMgr, None] = 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 msg = 'No indices created yet. Starting with a rollover alias index...' 

52 logger.debug(msg) 

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

54 msg = f'Created {self.name} with rollover alias {self.plan.rollover_alias}' 

55 logger.debug(msg) 

56 self.track_alias() 

57 else: 

58 self.alias.rollover() 

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

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

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

62 

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

64 """Create a single index""" 

65 logger.debug('Creating index: "%s"', value) 

66 create_index(self.client, value) 

67 

68 def add_indices(self) -> None: 

69 """Add indices according to plan""" 

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

71 func = getattr(mod, 'doc_generator') 

72 for scheme in self.plan.index_buildlist: 

73 if self.plan.rollover_alias: 

74 self._rollover_path() 

75 else: 

76 self.add(self.name) 

77 # self.filler(scheme) 

78 fill_index( 

79 self.client, 

80 name=self.name, 

81 doc_generator=func, 

82 options=scheme['options'], 

83 ) 

84 self.track_index(self.name) 

85 logger.debug('Created indices: %s', prettystr(self.indexlist)) 

86 if self.plan.rollover_alias: 

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

88 logger.error( 

89 'Unable to confirm rollover of alias "%s" was successful', 

90 self.plan.rollover_alias, 

91 ) 

92 

93 def searchable(self) -> None: 

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

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

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

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

98 

99 def setup(self) -> None: 

100 """Setup the entity manager""" 

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

102 logger.debug('PLAN: %s', prettystr(self.plan.toDict())) 

103 if self.plan.rollover_alias: 

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

105 self.add_indices() 

106 self.searchable() 

107 logger.info('Successfully created indices: %s', prettystr(self.indexlist)) 

108 

109 def track_alias(self) -> None: 

110 """Track a rollover alias""" 

111 logger.debug('Tracking alias: %s', self.plan.rollover_alias) 

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

113 

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

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

116 logger.debug('Tracking index: %s', name) 

117 entity = Index( 

118 client=self.client, 

119 name=name, 

120 snapmgr=self.snapmgr, 

121 policy_name=self.policy_name, 

122 ) 

123 entity.track_ilm(self.name) 

124 self.entity_list.append(entity)