class Store(SessionStore): def __init__(self, session_class=None): super(Store, self).__init__(session_class) if settings.DATABASE_ENGINE == 'gae': self.cache = GAEMemcachedCache(default_timeout=0) else: server = settings.SESSION_OPTIONS.get('memcached_servers', []) self.cache = MemcachedCache(servers, default_timeout=0) def save(self, session): self.cache.set(session.sid, dict(session)) def delete(self, session): self.cache.delete(session.sid) def get(self, sid): if not self.is_valid_key(sid): return self.session_class.new() try: data = self.cache.get(sid) except: data = {} return self.session_class(data, sid, False) def list(self): return self.cache.get_dict().keys()
class RepoCache: def __init__(self, timeout=18000, version=None): cache_host = os.environ.get('CACHE_HOST') cache_port = os.environ.get('CACHE_PORT') # cache_username = os.environ.get('CACHE_USERNAME') # cache_password = os.environ.get('CACHE_PASSWORD') self._cache = MemcachedCache(['{}:{}'.format(cache_host, cache_port)]) # self._cache = bmemcached.Client( # [cache_host], username=cache_username, password=cache_password) self._timeout = timeout self._version = version def get_cache(self, key): return self._cache.get(key) def set_cache(self, key, value): return self._cache.set(key, value, self._timeout) def delete_cache(self, key): return self._cache.delete(key, self._version)
def create_vnffg_v2(): """Sends and instantiates all VNFDs and VNFFGDs to the NFVO communication agent If an error occurs it also calls rollback actions JSON input parameters are: - sfc_uuid: the unique identifier of the composed SFC to be started :return: OK if all succeed, or ERROR and its reason """ vnffgd = None cache = MemcachedCache() if 'sfc_uuid' in request.json: vnffgd = cache.get(request.json['sfc_uuid']) if not vnffgd: return jsonify({'status': ERROR, 'reason': 'SFC UUID not found!'}) database = DatabaseConnection() vnf_instance_list = [] vnf_mapping = {} constituent_vnfs = vnffgd['vnffgd']['template']['vnffgd']['topology_template'] \ ['groups']['VNFFG1']['properties']['constituent_vnfs'] # configuring VNFFGD unique name vnffgd['vnffgd']['name'] = unique_id() # instantiating all VNFDs in VNFFGD for vnfd_name in constituent_vnfs: result, data = database.list_catalog(vnfd_name=vnfd_name) if result != OK: return jsonify({'status': result, 'reason': data}) vnf_data = instantiate_vnf(data[0]['_id']) # returns a flask.Response object # vnf_data = json.loads(vnf_data.response[0]) # parsing from string do json vnf_data = vnf_data.json # Rollback action if a given VNF fails on instantiating if vnf_data['status'] != OK: message = sfc_rollback_actions(vnf_instance_list) vnf_data['reason'] = ' '.join([vnf_data['reason'], message]) return jsonify(vnf_data) vnf_instance_list.append(vnf_data['vnf_id']) vnf_mapping[vnfd_name] = vnf_data['vnf_id'] # incrementing SFP path_id number in VNFFGD # TODO: consider put the set_next_vnffgd_path_id() in a critical region to avoid condition racing result, data = set_next_vnffgd_path_id(vnffgd) if result != OK: message = sfc_rollback_actions(vnf_instance_list) data = ' '.join([data, message]) return jsonify({'status': result, 'reason': data}) # create VNFFGD in NFVO resp, data = tacker_agent.vnffgd_create(vnffgd) # TODO: critical region until here # show the ultimate created VNFFGD logger.info('VNFFGD Template UUID: %s\n%s', request.json['sfc_uuid'], json.dumps(vnffgd, indent=4, sort_keys=True)) if resp != OK: # Rollback actions message = sfc_rollback_actions(vnf_instance_list) data = ' '.join([data, message]) logger.error(data) return jsonify({'status': resp, 'reason': data}) vnffgd_id = data logger.info("VNFFG descriptor created with id %s", vnffgd_id) # instantiate VNFFG resp, data = tacker_agent.vnffg_create(vnffgd_id, vnf_mapping, unique_id()) if resp != OK: # Rollback actions message = sfc_rollback_actions(vnf_instance_list, vnffgd_id) message = ' '.join([data, message]) return jsonify({'status': resp, 'reason': message}) vnffg_id = data logger.info("VNFFG %s instantiated successfully!", vnffg_id) resp, data = database.insert_sfc_instance(vnf_instance_list, vnffgd_id, vnffg_id) if resp != OK: # Rollback actions vnffg_resp, vnffg_data = tacker_agent.vnffg_delete(vnffg_id) if vnffg_resp != OK: return jsonify({'status': vnffg_resp, 'reason': ': '.join(['VNFFG', vnffg_data])}) message = sfc_rollback_actions(vnf_instance_list, vnffgd_id) message = ' '.join([data, message]) return jsonify({'status': resp, 'reason': message}) cache.delete(request.json['sfc_uuid']) return jsonify({'status': OK})
class Memcache: WAIT_ASK = 1 WAIT_ANSWER = 2 def __init__(self): self.cache = MemcachedCache(['127.0.0.1:11211']) def get(self, key): ret = self.cache.get(key) try: ret = ret.decode('utf-8') except: pass return ret def set(self, key, value): try: value = value.encode('utf-8') except: pass return self.cache.set(key, value, timeout=600) def delete(self, key): return self.cache.delete(key) def check_history(self, qid, gid=0): r = self.get(u'H' + str(qid) + u'G' + str(gid)) if r is None: return r, r if r == self.WAIT_ANSWER: return self.WAIT_ANSWER, self.get(u'A' + str(qid) + u'G' + str(gid)) if r == self.WAIT_ASK: return self.WAIT_ASK, None return None def set_before_ask(self, qid, gid=0): self.set(u'H' + str(qid) + u'G' + str(gid), self.WAIT_ASK) def set_before_answer(self, qid, ask, gid=0): self.set(u'A' + str(qid) + u'G' + str(gid), ask) self.set(u'H' + str(qid) + u'G' + str(gid), self.WAIT_ANSWER) def clear_state(self, qid, gid=0): self.delete(u'A' + str(qid) + u'G' + str(gid)) self.delete(u'H' + str(qid) + u'G' + str(gid)) def last_warn_time(self, qid): self.set(u'W' + str(qid), time.time()) def check_last_chat_same(self, qid, msg): if self.get(u'LC' + str(qid)) and self.get(u'LC' + str(qid)) == msg: return self.last_chat_count(qid, add=True) self.set(u'LC' + str(qid), msg) self.set(u'LCC' + str(qid), 1) return True def last_chat_count(self, qid, add=False): lcc = self.get(u'LCC' + str(qid)) if not lcc: self.set(u'LCC' + str(qid), 1) return True if add and lcc <= AdvancedSettings.same_response_limit: self.cache.inc(u'LCC' + str(qid)) lcc += 1 return lcc < AdvancedSettings.same_response_limit def check_block_user(self, qid): x = self.get(u'BU' + str(qid)) if x is not None: return x db = MyDB() is_blocked = db.check_blocked(qid, 'user') logging.info("is_blocked") logging.info(is_blocked) self.set(u'BU' + str(qid), is_blocked) return is_blocked def check_block_group(self, gid): x = self.get(u'BG' + str(gid)) if x is not None: return x db = MyDB() is_blocked = db.check_blocked(gid, 'group') self.set(u'BG' + str(gid), is_blocked) return is_blocked def check_disable_group(self, gid): x = self.get(u'BD' + str(gid)) if x is not None: return x db = MyDB() is_disabled = db.check_disabled(gid) self.set(u'BD' + str(gid), is_disabled) return is_disabled