rwlaunchpad/plugins/rwnsm/rift/tasklets/rwnsmtasklet/config_value_pool.py

   1
   2 #
   3 #   Copyright 2016 RIFT.IO Inc
   4 #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");
   6 #   you may not use this file except in compliance with the License.
   7 #   You may obtain a copy of the License at
   8 #
   9 #       http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 #   Unless required by applicable law or agreed to in writing, software
  12 #   distributed under the License is distributed on an "AS IS" BASIS,
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 #   See the License for the specific language governing permissions and
  15 #   limitations under the License.
  16 #
  17
  18 import os
  19 import pickle
  20 import uuid
  21
  22
  23 class ParameterValueError(Exception):
  24     pass
  25
  26
  27 class ParameterValuePool(object):
  28     def __init__(self, log, name, value_iter):
  29         self._log = log
  30         self._name = name
  31
  32         self._used_pool_values = []
  33         self._available_pool_values = list(value_iter)
  34
  35         self._backing_filepath = os.path.join(
  36                 os.environ["RIFT_ARTIFACTS"],
  37                 "parameter_pools",
  38                 self._name
  39                 )
  40
  41         self._read_used_pool_values()
  42
  43     def _save_used_pool_values(self):
  44         dir_path = os.path.dirname(self._backing_filepath)
  45         if not os.path.exists(dir_path):
  46             try:
  47                 os.makedirs(dir_path, exist_ok=True)
  48             except OSError as e:
  49                 self._log.error("Could not create directory for save used pool: %s", str(e))
  50
  51         try:
  52             with open(self._backing_filepath, "wb") as hdl:
  53                 pickle.dump(self._used_pool_values, hdl)
  54         except OSError as e:
  55             self._log.error(
  56                     "Could not open the parameter value pool file: %s",
  57                     str(e))
  58         except pickle.PickleError as e:
  59             self._log.error(
  60                     "Could not pickle the used parameter value pool: %s",
  61                     str(e))
  62
  63     def _read_used_pool_values(self):
  64         try:
  65             with open(self._backing_filepath, 'rb') as hdl:
  66                 self._used_pool_values = pickle.load(hdl)
  67
  68         except (OSError, EOFError):
  69             self._log.warning("Could not read from backing file: %s",
  70                               self._backing_filepath)
  71             self._used_pool_values = []
  72
  73         except pickle.PickleError as e:
  74             self._log.warning("Could not unpickle the used parameter value pool from %s: %s",
  75                               self._backing_filepath, str(e))
  76             self._used_pool_values = []
  77
  78         for value in self._used_pool_values:
  79             self._available_pool_values.remove(value)
  80
  81     def get_next_unused_value(self):
  82         if len(self._available_pool_values) == 0:
  83             raise ParameterValueError("Not more parameter values to to allocate")
  84
  85         next_value = self._available_pool_values[0]
  86         self._log.debug("Got next value for parameter pool %s: %s", self._name, next_value)
  87
  88         return next_value
  89
  90     def add_used_value(self, value):
  91         value = int(value)
  92
  93         if len(self._available_pool_values) == 0:
  94             raise ParameterValueError("Not more parameter values to to allocate")
  95
  96         if value in self._used_pool_values:
  97             raise ParameterValueError(
  98                     "Primitive value of {} was already used for pool name: {}".format(
  99                         value,
 100                         self._name,
 101                         )
 102                     )
 103
 104         if value != self._available_pool_values[0]:
 105             raise ParameterValueError("Parameter value not the next in the available list: %s", value)
 106
 107         self._available_pool_values.pop(0)
 108         self._used_pool_values.append(value)
 109         self._save_used_pool_values()
 110
 111     def remove_used_value(self, value):
 112         if value not in self._used_pool_values:
 113             self._log.warning("Primitive value of %s was never allocated for pool name: %s",
 114                     value, self._name
 115                     )
 116             return
 117
 118         self._used_pool_values.remove(value)
 119         self._available_pool_values.insert(0, value)
 120         self._save_used_pool_values()
 121
 122
 123 if __name__ == "__main__":
 124     import logging
 125     logging.basicConfig(level=logging.DEBUG)
 126     logger = logging.getLogger("config_value_pool.py")
 127     name = str(uuid.uuid4())
 128     param_pool = ParameterValuePool(logger, name, range(1000, 2000))
 129
 130     a = param_pool.get_next_unused_value()
 131     assert a == 1000
 132
 133     param_pool.add_used_value(a)
 134
 135     a = param_pool.get_next_unused_value()
 136     assert a == 1001
 137     param_pool.add_used_value(a)
 138
 139     param_pool = ParameterValuePool(logger, name, range(1000, 2000))
 140     a = param_pool.get_next_unused_value()
 141     assert a == 1002
 142
 143     try:
 144         param_pool.add_used_value(1004)
 145     except ParameterValueError:
 146         pass
 147     else:
 148         assert False
 149
 150     a = param_pool.get_next_unused_value()
 151     assert a == 1002
 152     param_pool.add_used_value(1002)
 153
 154     param_pool = ParameterValuePool(logger, name, range(1005, 2000))