Coverage for watcher/decision_engine/goal/efficacy/specs.py: 98%

1# -*- encoding: utf-8 -*- 

2# Copyright (c) 2016 b<>com 

3# 

4# Licensed under the Apache License, Version 2.0 (the "License"); 

5# you may not use this file except in compliance with the License. 

6# You may obtain a copy of the License at 

7# 

8# http://www.apache.org/licenses/LICENSE-2.0 

9# 

10# Unless required by applicable law or agreed to in writing, software 

11# distributed under the License is distributed on an "AS IS" BASIS, 

12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 

13# implied. 

14# See the License for the specific language governing permissions and 

15# limitations under the License. 

16 

17from watcher._i18n import _ 

18from watcher.decision_engine.goal.efficacy import base 

19from watcher.decision_engine.goal.efficacy import indicators 

20from watcher.decision_engine.solution import efficacy 

21 

22 

23class Unclassified(base.EfficacySpecification): 

24 

25 def get_indicators_specifications(self): 

26 return () 

27 

28 def get_global_efficacy_indicator(self, indicators_map): 

29 return None 

30 

31 

32class ServerConsolidation(base.EfficacySpecification): 

33 

34 def get_indicators_specifications(self): 

35 return [ 

36 indicators.ComputeNodesCount(), 

37 indicators.ReleasedComputeNodesCount(), 

38 indicators.InstanceMigrationsCount(), 

39 ] 

40 

41 def get_global_efficacy_indicator(self, indicators_map=None): 

42 value = 0 

43 global_efficacy = [] 

44 if indicators_map and indicators_map.compute_nodes_count > 0: 44 ↛ 47line 44 didn't jump to line 47 because the condition on line 44 was always true

45 value = (float(indicators_map.released_compute_nodes_count) / 

46 float(indicators_map.compute_nodes_count)) * 100 

47 global_efficacy.append(efficacy.Indicator( 

48 name="released_nodes_ratio", 

49 description=_("Ratio of released compute nodes divided by the " 

50 "total number of enabled compute nodes."), 

51 unit='%', 

52 value=value, 

53 )) 

54 

55 return global_efficacy 

56 

57 

58class WorkloadBalancing(base.EfficacySpecification): 

59 

60 def get_indicators_specifications(self): 

61 return [ 

62 indicators.InstanceMigrationsCount(), 

63 indicators.InstancesCount(), 

64 indicators.StandardDeviationValue(), 

65 indicators.OriginalStandardDeviationValue() 

66 ] 

67 

68 def get_global_efficacy_indicator(self, indicators_map=None): 

69 gl_indicators = [] 

70 mig_value = 0 

71 if indicators_map and indicators_map.instance_migrations_count > 0: 

72 mig_value = ( 

73 indicators_map.instance_migrations_count / 

74 float(indicators_map.instances_count) * 100) 

75 gl_indicators.append(efficacy.Indicator( 

76 name="live_migrations_count", 

77 description=_("Ratio of migrated virtual machines to audited " 

78 "virtual machines"), 

79 unit='%', 

80 value=mig_value)) 

81 return gl_indicators 

82 

83 

84class HardwareMaintenance(base.EfficacySpecification): 

85 

86 def get_indicators_specifications(self): 

87 return [ 

88 indicators.LiveInstanceMigrateCount(), 

89 indicators.PlannedLiveInstanceMigrateCount(), 

90 indicators.ColdInstanceMigrateCount(), 

91 indicators.PlannedColdInstanceMigrateCount(), 

92 indicators.VolumeMigrateCount(), 

93 indicators.PlannedVolumeMigrateCount(), 

94 indicators.VolumeUpdateCount(), 

95 indicators.PlannedVolumeUpdateCount() 

96 ] 

97 

98 def get_global_efficacy_indicator(self, indicators_map=None): 

99 li_value = 0 

100 if (indicators_map and 

101 indicators_map.planned_live_migrate_instance_count > 0): 

102 li_value = ( 

103 float(indicators_map.planned_live_migrate_instance_count) / 

104 float(indicators_map.live_migrate_instance_count) * 

105 100 

106 ) 

107 

108 li_indicator = efficacy.Indicator( 

109 name="live_instance_migrate_ratio", 

110 description=_("Ratio of actual live migrated instances " 

111 "to planned live migrate instances."), 

112 unit='%', 

113 value=li_value) 

114 

115 ci_value = 0 

116 if (indicators_map and 

117 indicators_map.planned_cold_migrate_instance_count > 0): 

118 ci_value = ( 

119 float(indicators_map.planned_cold_migrate_instance_count) / 

120 float(indicators_map.cold_migrate_instance_count) * 

121 100 

122 ) 

123 

124 ci_indicator = efficacy.Indicator( 

125 name="cold_instance_migrate_ratio", 

126 description=_("Ratio of actual cold migrated instances " 

127 "to planned cold migrate instances."), 

128 unit='%', 

129 value=ci_value) 

130 

131 dv_value = 0 

132 if (indicators_map and 

133 indicators_map.planned_volume_migrate_count > 0): 

134 dv_value = (float(indicators_map.planned_volume_migrate_count) / 

135 float(indicators_map. 

136 volume_migrate_count) * 

137 100) 

138 

139 dv_indicator = efficacy.Indicator( 

140 name="volume_migrate_ratio", 

141 description=_("Ratio of actual detached volumes migrated to" 

142 " planned detached volumes migrate."), 

143 unit='%', 

144 value=dv_value) 

145 

146 av_value = 0 

147 if (indicators_map and 

148 indicators_map.planned_volume_update_count > 0): 

149 av_value = (float(indicators_map.planned_volume_update_count) / 

150 float(indicators_map. 

151 volume_update_count) * 

152 100) 

153 

154 av_indicator = efficacy.Indicator( 

155 name="volume_update_ratio", 

156 description=_("Ratio of actual attached volumes migrated to" 

157 " planned attached volumes migrate."), 

158 unit='%', 

159 value=av_value) 

160 

161 return [li_indicator, 

162 ci_indicator, 

163 dv_indicator, 

164 av_indicator]