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 MemcachedSessionStore(SessionStore):
"""A session store that saves sessions with memcache.
:param session_class: The session class to use. Defaults to
:model:`Session`.
:param servers: a list or tuple of server addresses or a compatible client.
Defaults to `['127.0.0.1:11211']`.
:param default_timeout: the default timeout that is used if no timeout is specified.
A timeout of 0 indicates that the cache never expires.
:param key_prefix: a prefix that is added before all keys. This makes it
possible to use the same memcached server for different
applications.
"""
def __init__(self,
session_class=None,
servers=None,
default_timeout=600,
key_prefix=None):
SessionStore.__init__(self, session_class)
self.mc = MemcachedCache(servers, default_timeout, key_prefix)
def get(self, key):
return self.mc.get(key)
def set(self, key, value, timeout=None):
self.mc.set(key, value, timeout)
def get_session(self, sid):
data = self.get(sid)
if data is None:
data = {}
return self.session_class(dict(data), sid, False)
class MemcachedSessionStore(SessionStore):
"""A session store that saves sessions with memcache.
:param session_class: The session class to use. Defaults to
:model:`Session`.
:param servers: a list or tuple of server addresses or a compatible client.
Defaults to `['127.0.0.1:11211']`.
:param default_timeout: the default timeout that is used if no timeout is specified.
A timeout of 0 indicates that the cache never expires.
:param key_prefix: a prefix that is added before all keys. This makes it
possible to use the same memcached server for different
applications.
"""
def __init__(self, session_class=None, servers=None, default_timeout=600, key_prefix=None):
SessionStore.__init__(self, session_class)
self.mc = MemcachedCache(servers, default_timeout, key_prefix)
def get(self, key):
return self.mc.get(key)
def set(self, key, value, timeout=None):
self.mc.set(key, value, timeout)
def get_session(self, sid):
data = self.get(sid)
if data is None:
data = {}
return self.session_class(dict(data), sid, False)
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()
def decorated_function(*args, **kwargs):
cache = MemcachedCache(['127.0.0.1:11211'])
key = '{url}{data}'.format(url=args[0], data=pickle.dumps(args))
hash_ = hashlib.md5(key.encode()).hexdigest()
if not cache.has(hash_):
status_code, cached_data = f(*args, **kwargs)
if not kwargs.get('nocache', False) and status_code == 200:
cache.set(hash_, (status_code, cached_data), timeout=5 * 60)
else:
status_code, cached_data = cache.get(hash_)
return status_code, cached_data
def get_sfc_uuid():
"""Retrieves a unique identifier in order to compose a SFC
Retrieves a uuid4 identifier to compose a SFC and get a copy of the vnffg template.
:return: a unique identifier str.
"""
vnffgd = deepcopy(vnffgd_template)
sfc_uuid = str(uuid.uuid4())
cache = MemcachedCache()
cache.set(sfc_uuid, vnffgd)
return jsonify({'sfc_uuid': sfc_uuid})
class Cache():
def __init__(self):
if webapp.config['APP_ENV'] == 'dev':
from werkzeug.contrib.cache import SimpleCache
self.cache = SimpleCache()
else:
from werkzeug.contrib.cache import MemcachedCache
self.cache = MemcachedCache(['127.0.0.1:11211'])
def get(self, cache_key=''):
if 'cache' in request.args and request.args.get('cache') == 'clear':
user_data = session.get('_user', None)
if user_data and user_data['is_admin']:
return None
return self.cache.get(cache_key)
def set(self, cache_key='', data=None, timeout=1000):
self.cache.set(cache_key, data, timeout)
return True
def include_sfc_acl():
"""Includes ACL criteria in VNFFGD
JSON arguments are:
- sfc_uuid: the unique identifier of the SFC being composed
- acl: a dict containing the acl criteria to be added into the vnffgd template
:return: OK if success, or ERROR and its reason if not
"""
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!'})
acl = request.json['acl']
topology_template = vnffgd['vnffgd']['template']['vnffgd']['topology_template']
criteria = topology_template['node_templates']['Forwarding_path1'] \
['properties']['policy']['criteria']
res, acl = acl_criteria_parser(acl)
if res != OK:
return jsonify({'status': ERROR, 'reason': acl})
for rule in acl:
criteria.append(rule)
#debug
logger.debug('VNFFGD Template UUID: %s\n%s', request.json['sfc_uuid'], json.dumps(vnffgd, indent=4, sort_keys=True))
cache.set(request.json['sfc_uuid'], vnffgd)
return jsonify({'status': OK})
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)
from werkzeug.contrib.cache import MemcachedCache
cache = MemcachedCache(['127.0.0.1:11211'])
data_path = r'/var/www/nba/api/data/'
# codes index
codes = {}
resource_file = os.path.join(data_path, 'teams.json')
data = json.load(open(resource_file, 'r', encoding='utf-8'))
for team in sum(data.values(), []):
codes[team['code']] = team['name']
cache.set('codes', codes, timeout=2592000)
# news
resource_file = os.path.join(data_path, 'news.json')
data = json.load(open(resource_file, 'r', encoding='utf-8'))
index = data['index']
teams = data['teams']
news = data['news']
cache.set('index', index, timeout=2592000)
cache.set('teams', teams, timeout=2592000)
cache.set('news_l', len(news), timeout=2592000)
cache.set('news', news, timeout=2592000)
# speed up by dividing into smaller chunks
chunk = 100
print section
start = time.time()
series_list = [p[1] for p in series[0]["points"]]
from sys import getsizeof
print "size of series data", getsizeof(series)
print "size of series list", getsizeof(series_list)
duration(section, start)
section = "cache:: store series_list"
print section
start = time.time()
cache.set("influxdb_list_series", series_list, 60 * 20)
duration(section, start)
if cfg.get("cheat_times"):
print "cheating on start/end time. no further influx queries needed..."
continue
section = "influxdb:: select * from // order asc limit 1"
print section
start = time.time()
series = client.query("select * from // order asc limit 1")
duration(section, start)
section = "cache:: store first-point for all series"
print section
start = time.time()
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
def include_sfc_traffic_origin():
"""Includes ACL criteria according to INTERNAL or EXTERNAL traffic source
INTERNAL traffic is sourced from VNFs managed by NFVO, while EXTERNAL traffic is sourced from everything
out from NFVO networks.
This function also includes specific requirements to select the source port for any NFVO.
Currently, it just supports Tacker NFVO.
Tacker has the requirement for 'network_source_port_id' in ACL criteria, which is included in VNFFGD
by this function.
One important rule is applied:
1. Tacker's network_name from the origin VNF CP must be the same as the input CP of the first VNF in the chain.
If there are more CPs than 1, then a message with status OPTIONS and a cp_list is replied in order to the
user inform a desirable connection point.
JSON input arguments are:
- sfc_uuid: the unique identifier to the SFC being composed
- origin: if the SFC traffic source is INTERNAL or EXTERNAL
- vnf_id: the VNF unique identifier from the NFVO
- resource: optional when using INTERNAL origin. Identifies the user manually input of the cp_out
:return: OK if success, or ERROR and its reason if not, or OPTIONS and a cp_list dict
"""
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()
origin = request.json['origin']
topology_template = vnffgd['vnffgd']['template']['vnffgd']['topology_template']
# sfp = service function path
sfp_cps = topology_template['groups']['VNFFG1']['properties']['connection_point']
sfp_vnfs = topology_template['groups']['VNFFG1']['properties']['constituent_vnfs']
# network_src_port_id is a requirement for Tacker NFVO
criteria = topology_template['node_templates']['Forwarding_path1'] \
['properties']['policy']['criteria']
_, catalog = database.list_catalog(vnfd_name=sfp_vnfs[0])
sfp_first_pkg_id = catalog[0]['_id']
sfp_first_vnf_cps = list_vnf_pkg_cps(sfp_first_pkg_id, internal=True)
if origin == INTERNAL:
vnf_id = request.json['vnf_id']
resp, data = database.list_vnf_instances(vnf_id=vnf_id)
if resp != OK:
return jsonify({'status': resp, 'reason': data})
# Only VNFs instantiated by this framework can be used as origin,
# as we need get information of its CP on VNF Packages
if not data:
return jsonify({'status': ERROR, 'reason': 'The chosen VNF was not instantiated by Holistic-Composer!'})
vnf_pkg_id = data[0]['vnf_pkg_id']
vnf_pkg_cps = list_vnf_pkg_cps(vnf_pkg_id, internal=True)
# Leave just the CPs that are in the same subnet of the first VNF CP_in of the SFC
cps = vnf_pkg_cps.keys()
cps = list(cps)
for cp in cps:
if vnf_pkg_cps[cp]['network_name'] != sfp_first_vnf_cps[sfp_cps[0]]['network_name']:
vnf_pkg_cps.pop(cp)
# resource means the CP_out
if 'resource' not in request.json:
# Selects the suitable CP_out automatically
if not vnf_pkg_cps:
return jsonify({'status': ERROR, 'reason': 'No suitable CP on this VNF!'})
if len(vnf_pkg_cps) == 1:
cp_name = list(vnf_pkg_cps.keys())[0]
else:
return jsonify({
'status': OPTIONS,
'cp_list': vnf_pkg_cps
})
else:
cp_name = request.json['resource']
if cp_name not in vnf_pkg_cps:
return jsonify({'status': ERROR, 'reason': 'Invalid CP!'})
response = get_vnf_nfvo_resource_id(vnf_id, cp_name)
if response['status'] != OK:
return jsonify(response)
criteria.append({'network_src_port_id': response['resource_id']})
elif origin == EXTERNAL:
resp, data = tacker_agent.get_fip_router_interface_id(
sfp_first_vnf_cps[sfp_cps[0]]['network_name'])
if resp == OK:
criteria.append({'network_src_port_id': data})
else:
return jsonify({
'status': resp,
'reason': data
})
else:
return jsonify({
'status': ERROR,
'reason': 'Error 500: Network traffic source to SFP should be INTERNAL or EXTERNAL.'
})
# debug
logger.debug('VNFFGD Template UUID: %s\n%s', request.json['sfc_uuid'], json.dumps(vnffgd, indent=4, sort_keys=True))
cache.set(request.json['sfc_uuid'], vnffgd)
return jsonify({'status': OK})
class Query(object):
default_configuration = RecursiveDict({
'query_directories': [],
'cached': False,
'execute_queries': True,
})
def __init__(self, query, params=None, from_file=True, model_class=None,
database='default', sessions=sessions, cached=False,
replace=None, config=None, cache_timeout=3600*12):
self.config = self.default_configuration
self.config.update_recursive(configs.get('mysql', {}))
if config:
self.config.update_recursive(config)
# add project path queries directory if not already configured
project_queries = os.path.join(get_project_path(), 'queries')
if not project_queries in self.config['query_directories']:
self.config['query_directories'].append(project_queries)
if from_file:
if query in file_queries:
logger.debug('Getting query file from query files cache %s' %
query)
self.query = file_queries[query]
else:
logger.debug('Getting query file %s' % query)
file_queries[query] = self._get_from_file(query)
self.query = file_queries[query]
else:
self.query = query
if replace:
self.query = self.query % replace
self.params = params
self.session = sessions.get(database)
self.result = None
self.model_class = model_class
self.cached = cached
self.query_cache = MemcachedCache(['127.0.0.1:11211'])
self.cache_timeout = cache_timeout
self.database = database
def _gen_mem_key(self):
params_string=''
if self.params:
ordered_values = OrderedDict(sorted(self.params.items(),
key=lambda t: t[0]))
for value in ordered_values:
params_string = params_string +'_'+ value
return str(hash(self.database+'_'+self.query+params_string))
def _get_from_file(self, query):
for query_directory in self.config.get('query_directories'):
for dirpath, dirnames, filenames in os.walk(query_directory,
followlinks=True):
for name in filenames:
if '%s.sql' % query in os.path.join(dirpath, name):
f = file(os.path.join(dirpath, name))
query = f.read()
f.close()
return query
raise QueryFileNotFound('%s.sql not found in any of %s' %
(query, self.config.get('query_directories')))
def _raw_query(self):
if self.config.get('execute_queries'):
self.result = self.session.execute(self.query, self.params)
else:
self.result = None
def _raw_query_with_model(self):
if self.config.get('execute_queries'):
self.result = self.session.query(self.model_class).from_statement(self.query).params(**self.params)
else:
self.result = None
def _query(self):
if self.model_class:
self._raw_query_with_model()
else:
self._raw_query()
def execute(self):
self._query()
return self.result
def one(self):
cache_key = ''
if self.cached:
cache_key = self._gen_mem_key()
cached_query = self.query_cache.get(cache_key)
if cached_query:
return cached_query
self._query()
if self.result:
if self.model_class:
_one = self.result.one()
if self.cached:
self.query_cache.set(cache_key,
_one,self.cache_timeout)
return _one
else:
fetch_one = self.result.fetchone()
if self.cached:
self.query_cache.set(cache_key,
fetch_one, self.cache_timeout)
return fetch_one
if self.cached:
self.query_cache.set(cache_key, self.result, self.cache_timeout)
return self.result
def all(self):
cache_key = ''
if self.cached:
cache_key = self._gen_mem_key()
cached_query = self.query_cache.get(cache_key)
if cached_query:
return cached_query
self._query()
if self.result:
if self.model_class:
_all = self.result.all()
if self.cached:
query_cache.set(cache_key, _all, self.cache_timeout)
return _all
else:
fetch_all = self.result.fetchall()
if self.cached:
self.query_cache.set(cache_key, fetch_all,
self.cache_timeout)
return fetch_all
if self.cached:
self.query_cache.set(cache_key, self.result, self.cache_timeout)
return self.result
@staticmethod
def last_insert_id():
return Query('last_insert_id').one()[0]
print section
start = time.time()
series_list = [p[1] for p in series[0]['points']]
from sys import getsizeof
print "size of series data", getsizeof(series)
print "size of series list", getsizeof(series_list)
duration(section, start)
section = "cache:: store series_list"
print section
start = time.time()
cache.set("influxdb_list_series", series_list, 60 * 20)
duration(section, start)
if cfg.get('cheat_times'):
print "cheating on start/end time. no further influx queries needed..."
else:
section = "influxdb:: select * from // order asc limit 1"
print section
start = time.time()
series = client.query("select * from // order asc limit 1")
duration(section, start)
section = "cache:: store first-point for all series"
print section
start = time.time()
from werkzeug.contrib.cache import MemcachedCache
#def get_my_item():
# rv = cache.get('my-item')
# print(rv)
# if rv is None:
# rv = calculate_value()
# cache.set('my-item', rv, timeout=5*60)
# return rv
if __name__ == "__main__":
cache = MemcachedCache(['127.0.0.0:11211'])
rv = cache.get('key')
if rv is None:
cache.set('key', 'value')
print(cache)
rv = cache.get('key')
print(rv)
citydetails.name = statedetails.cities[cityid]
cache.set('city:' + statedetails.abbr + ':' + statedetails.cities[cityid] + ':details', citydetails, )
allstates.append(statedetails)
cache.set('states:' + str(id) + ':details', statedetails, )
cache.set('allstates', allstates, 0)
def allCategories():
res = db_session.query(Category).all();
allcats = list()
for cat in res:
mycat = Objects.Cat(cat.id, cat.name)
allcats.append(mycat)
cache.set('allcats', allcats, )
def loadCache():
#Warm up our cache.
stateCache()
mystateIds = cache.get('states:ids')
for id in mystateIds:
cityCache(id)
allStatesIndex()
allCategories()
loadCache()
cache.set('iswarm', 1, timeout=0)
#passhash = Objects.UserPassword('testing').pw_hash
#myUser = User(password=passhash,fname='Mike',lname='Gugino', email='*****@*****.**',phone='555-555')
#db_session.add(myUser)
#db_session.commit()
def compose_sfp():
"""Performs VNF Chaining in the VNFFG Template.
This function stands for VNF Chaining and its requirements for CPs and VLs using the VNFFG Template.
The first interface is reserved for the VNF management interface, and thus it is not used for VNF chaining.
The following rules are taken into account:
- cp_in: chooses the cp_in according to the same network of the prior cp_out. If the VNF is the first one, then
the first CP is chosen (disregarding the management interface)
- cp_out: if the given VNF has just one CP for VNF chaining, then cp_out = cp_in. Otherwise,
cp_out is chosen taking into account NFVO requirements implemented in the related agents.
If cp_out can not be selected automatically, a message with OPTIONS status is returned
in order to the user inform the desirable and suitable connection point.
Input params must be in JSON format, which are:
- sfc_uuid: the unique identifier for the SFC being composed
- vnf_pkg_id: always required
- cp_out: not required, but can be used as a manually user input
:return: OK if success, or ERROR and its reason if not, or OPTIONS and an cp_list dict
"""
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_pkg_id = request.json['vnf_pkg_id']
vnf_pkg_cps = list_vnf_pkg_cps(vnf_pkg_id, internal=True)
_, catalog = database.list_catalog(vnf_pkg_id)
vnfd_name = catalog[0]['vnfd_name']
topology_template = vnffgd['vnffgd']['template']['vnffgd']['topology_template']
# verifying if this vnf package was already added to this VNFFG (no duplicate)
if vnfd_name in topology_template['groups']['VNFFG1']['properties']['constituent_vnfs']:
return jsonify({'status': ERROR, 'reason': 'The selected VNF Package was already added on this SFC!'})
cp_list = sorted(vnf_pkg_cps)
# we are considering that the first CP is always reserved for the VNF management interface
# Thus, it is not used for VNF chaining
cp_list.pop(0)
# gets all virtual links in VNFFGD
vnffgd_vls = topology_template['groups']['VNFFG1']['properties']['dependent_virtual_link']
# getting the previous network_name for correct VNF chaining
previous_net_name = ''
if vnffgd_vls:
previous_vl = vnffgd_vls[-1] # gets the current last VL in VNFFG
# gets the current last VNF Name in VNFFGD
previous_vnfd_name = topology_template['groups']['VNFFG1']['properties']['constituent_vnfs'][-1]
_, previous_vnf_pkg_id = database.list_catalog(vnfd_name=previous_vnfd_name)
previous_vnf_pkg_id = previous_vnf_pkg_id[0]['_id']
# gets all connection points data from previous VNFD
previous_vnfd_cps = list_vnf_pkg_cps(previous_vnf_pkg_id, internal=True)
for cp in previous_vnfd_cps:
if previous_vnfd_cps[cp]['virtual_link'] == previous_vl:
previous_net_name = previous_vnfd_cps[cp]['network_name']
break
cp_in, cp_out = "", ""
# including cp_input
for cp in cp_list:
if vnffgd_vls: # if there are previous Virtual Links included in VNFFGD
# cp_in is valid just if it is connected to the same network_name from previous VNF output
if vnf_pkg_cps[cp]['network_name'] == previous_net_name:
cp_in = cp
break
else: # if this VNF is the first one being included in VNFFGD
cp_in = cp
break
if not cp_in:
return jsonify({'status': ERROR, 'reason': 'There is no suitable CP to chaining with previous VNF!'})
# including cp_output
num_cps = len(cp_list)
if num_cps == 1:
cp_out = cp_in
else: # num_cps surely will be > 1, because previous return
# output CP requirements are dependent of NFVO capabilities, thus it was implemented in the related agent
result, data = tacker_agent.select_and_validate_cp_out(request.json, vnf_pkg_cps, cp_in)
if result != OK:
return jsonify(data)
cp_out = data
if cp_in == cp_out:
capability = [cp_in]
else:
capability = [cp_in, cp_out]
for cp in capability:
# including connection points
topology_template['groups']['VNFFG1']['properties']['connection_point'].append(cp)
# including dependent virtual links
virtual_link = vnf_pkg_cps[cp]['virtual_link']
# if virtual_link not in topology_template['groups']['VNFFG1']['properties']['dependent_virtual_link']:
topology_template['groups']['VNFFG1']['properties']['dependent_virtual_link'].append(virtual_link)
# including constituent VNFs
topology_template['groups']['VNFFG1']['properties']['constituent_vnfs'].append(vnfd_name)
vnf_end_points = len(capability)
if vnf_end_points == 1:
capability = capability[0]
else:
capability = ','.join(capability)
# including number of endpoints
topology_template['groups']['VNFFG1']['properties']['number_of_endpoints'] += vnf_end_points
path = {"forwarder": vnfd_name, "capability": capability}
# including VNF forwarding path
topology_template['node_templates']['Forwarding_path1']['properties']['path'].append(path)
# debug
logger.debug('VNFFGD Template UUID: %s\n%s', request.json['sfc_uuid'], json.dumps(vnffgd, indent=4, sort_keys=True))
cache.set(request.json['sfc_uuid'], vnffgd)
return jsonify({'status': OK})
class Query(object):
default_configuration = RecursiveDict({
'query_directories': [],
'cached': False,
'execute_queries': True,
})
def __init__(self,
query,
params=None,
from_file=True,
model_class=None,
database='default',
sessions=sessions,
cached=False,
replace=None,
config=None,
cache_timeout=3600 * 12):
self.config = self.default_configuration
self.config.update_recursive(configs.get('mysql', {}))
if config:
self.config.update_recursive(config)
# add project path queries directory if not already configured
project_queries = os.path.join(get_project_path(), 'queries')
if not project_queries in self.config['query_directories']:
self.config['query_directories'].append(project_queries)
if from_file:
if query in file_queries:
logger.debug('Getting query file from query files cache %s' %
query)
self.query = file_queries[query]
else:
logger.debug('Getting query file %s' % query)
file_queries[query] = self._get_from_file(query)
self.query = file_queries[query]
else:
self.query = query
if replace:
self.query = self.query % replace
self.params = params
self.session = sessions.get(database)
self.result = None
self.model_class = model_class
self.cached = cached
self.query_cache = MemcachedCache(['127.0.0.1:11211'])
self.cache_timeout = cache_timeout
self.database = database
def _gen_mem_key(self):
params_string = ''
if self.params:
ordered_values = OrderedDict(
sorted(self.params.items(), key=lambda t: t[0]))
for value in ordered_values:
params_string = params_string + '_' + value
return str(hash(self.database + '_' + self.query + params_string))
def _get_from_file(self, query):
for query_directory in self.config.get('query_directories'):
for dirpath, dirnames, filenames in os.walk(query_directory,
followlinks=True):
for name in filenames:
if '%s.sql' % query in os.path.join(dirpath, name):
f = file(os.path.join(dirpath, name))
query = f.read()
f.close()
return query
raise QueryFileNotFound('%s.sql not found in any of %s' %
(query, self.config.get('query_directories')))
def _raw_query(self):
if self.config.get('execute_queries'):
self.result = self.session.execute(self.query, self.params)
else:
self.result = None
def _raw_query_with_model(self):
if self.config.get('execute_queries'):
self.result = self.session.query(self.model_class).from_statement(
self.query).params(**self.params)
else:
self.result = None
def _query(self):
if self.model_class:
self._raw_query_with_model()
else:
self._raw_query()
def execute(self):
self._query()
return self.result
def one(self):
cache_key = ''
if self.cached:
cache_key = self._gen_mem_key()
cached_query = self.query_cache.get(cache_key)
if cached_query:
return cached_query
self._query()
if self.result:
if self.model_class:
_one = self.result.one()
if self.cached:
self.query_cache.set(cache_key, _one, self.cache_timeout)
return _one
else:
fetch_one = self.result.fetchone()
if self.cached:
self.query_cache.set(cache_key, fetch_one,
self.cache_timeout)
return fetch_one
if self.cached:
self.query_cache.set(cache_key, self.result, self.cache_timeout)
return self.result
def all(self):
cache_key = ''
if self.cached:
cache_key = self._gen_mem_key()
cached_query = self.query_cache.get(cache_key)
if cached_query:
return cached_query
self._query()
if self.result:
if self.model_class:
_all = self.result.all()
if self.cached:
query_cache.set(cache_key, _all, self.cache_timeout)
return _all
else:
fetch_all = self.result.fetchall()
if self.cached:
self.query_cache.set(cache_key, fetch_all,
self.cache_timeout)
return fetch_all
if self.cached:
self.query_cache.set(cache_key, self.result, self.cache_timeout)
return self.result
@staticmethod
def last_insert_id():
return Query('last_insert_id').one()[0]
