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 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
