def reserve(self, resv):
# logger.info("ovsgre:OvsManager:reserve: enter")
# This just only reserve vlans for source/destination/tunnel interfaces
if resv is None:
raise ManagerException("OvsManager:reserve",
"The reservation parameter is null.")
self.check_stp(resv)
resv_id = uuid.uuid4()
logger.info("ovsManager:reserve: new resv_id=%s." % resv_id)
if dict_resvParameter.has_key(resv_id):
logger.error("Never here. Reservation id is duplicated(%s)." %
(resv_id))
raise ManagerException("OvsManager:reserve",
"The reservation id is already used.")
resvp = resvParameter(self.ovs_id, resv)
(s_vlan, d_vlan, t_vlan) = resvp.allocate()
resv.trans_vlan = t_vlan
dict_resvParameter[resv_id] = resvp
self.dict_isSetRule[resv_id] = False
logger.info("ovsManager:reserve: done. resv_id=%s" % (resv_id))
return resv_id
def get_port(urlbase, dpid, tnrmp, name):
# url = "http://localhost:8080/ovsdb/0000000000000010/ports"
# tnrmp["ovsdb"] = address pvsdb
params = {}
url = "%s/ovsdb/%s/%s" % (urlbase, dpid, "ports")
logger.info("get_port: url=%s" % url)
params["tnrm"] = tnrmp
logger.info("get_port: request url=%s, dict=%s" % (url, params))
rc = None
try:
req = urllib2.Request(url, "%s" % json.dumps(params))
rs = urllib2.urlopen(req)
rc = json.load(rs)
logger.info("get_port: reply dict=%s" % rc)
except Exception as ex:
raise ManagerException(
"ovsif:get_port",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
try:
port = rc["tnrm"]["ports"][name]
logger.info("get_port: ovs ofport=%s" % port)
return port
except:
raise ManagerException(
"ovsif:get_port",
"This port (%s) dose not exist in Open vSwitch(%s)." %
(name, dpid))
def status (self, resv):
if resv is None or not dict_resvParameter.has_key(resv.resv_id):
logger.info("ovsManager:status: resv_id=%s" % (resv.resv_id))
for key in dict_resvParameter:
logger.info("ovsManager:status: resvp=%s" % (key))
raise ManagerException("OvsManager:status", "The reservation is null.")
resvp = dict_resvParameter[resv.resv_id]
if resvp is None:
raise ManagerException("OvsManager:status", "The ResvParameter is null.")
rc = self.check_rule(self.src_if, resvp.s_vlan, resvp.t_vlan)
if not rc:
### This operation is caused we can not remove flow rules
### and teardown gre tunnel in a normal island.
# self.dict_isSetRule[resv.resv_id] = False
return False
rc = self.check_rule(self.dst_if, resvp.d_vlan, resvp.t_vlan)
if not rc:
### This operation is caused we can not remove flow rules
### and teardown gre tunnel in a normal island.
# self.dict_isSetRule[resv.resv_id] = False
return False
return True
def find_dev(self, src_if, dst_if):
urlbase = src_if.ryu_url
dpid = src_if.dpid
params = {}
params["ovsdb"] = src_if.ovsdb
if (src_if.gtype == "ovsgre"):
params["type"] = "gre"
else:
raise ManagerException("OvsManager:find_dev",
"Type (%s) is unknown, must be \"ovsgre\"." % (src_if.gtype))
params["local_ip"] = src_if.address
params["remote_ip"] = dst_if.address
logger.info("search gre link. url=%s, dpid=%s, ovsdb=%s, type=%s, local=%s, remote=%s" % (urlbase, dpid, params["ovsdb"], params["type"], params["local_ip"], params["remote_ip"]));
finds = ovsif.get_tunnel_info(urlbase, dpid, params)
if len(finds) == 0:
return (None, None)
elif len(finds) == 1:
for p in finds.keys():
logger.info("find gre link. dev=%s, ofport=%s" % (p, finds[p]))
return (p, finds[p])
else:
raise ManagerException("OvsManager:init", "Duplicate path is exist. %s" % finds)
def allocate(self, vlan=None):
logger.info("ovsgre:vlanManager:allocate: vlan=%s" % (vlan))
ivlan = 0
if vlan is not None:
try:
ivlan = int(vlan)
except Exception:
raise ManagerException(
"ovsgre:allocate",
"This vlan (%s) can not convert to integer." % vlan)
# if (ivlan < self.vlan_min or ivlan > self.vlan_max):
# raise ManagerException("ovsgre:allocate", "This vlan (%s) is outof vlan range." % vlan)
if vlan is None:
if self.isTunnel:
vlan = self.search()
logger.info("VlanManagter: new allocate vlan is %s." % (vlan))
else:
raise ManagerException("ovsgre:allocate",
"Vlan is unset for STP.")
if self.dict_vlans.has_key(vlan):
raise ManagerException("ovsgre:allocate",
"This vlan (%s) is already used." % vlan)
self.dict_vlans[vlan] = vlan
return vlan
def provision (self, resv):
# provison:nsiv2, poa geni_start
if resv is None or not dict_resvParameter.has_key(resv.resv_id):
logger.info("ovsManager:provision: resv_id=%s" % (resv.resv_id))
for key in dict_resvParameter:
logger.info("ovsManager:provision: resvp=%s" % (key))
raise ManagerException("OvsManager:provision", "The reservation is null.")
resvp = dict_resvParameter[resv.resv_id]
if resvp is None:
raise ManagerException("OvsManager:privision", "The ResvParameter is null.")
if self.isSetup:
# already setup
pass
else:
try:
### setup src->dst
self.setup_tunnel(self.src_if, self.dst_if)
except:
raise
try:
### setup dst->src
self.setup_tunnel(self.dst_if, self.src_if)
except:
### teardown tunnel by setup_tunnel(self.src_if, self.dst_if)
self.teardown_tunnel(self.src_if, self.dst_if)
raise
self.isSetup = True
self.dict_used[resv.resv_id] = resv.resv_id
if self.dict_isSetRule[resv.resv_id]:
# already set flow rule
pass
else:
#### add code for set rule
logger.info("set flow rule. %s?vlan=%s:%s?vlan=%s, gre?vlan=%s." %
(resvp.s_stp, resvp.s_vlan, resvp.d_stp, resvp.d_vlan, resvp.t_vlan))
try:
### add src
self.add_rule(self.src_if, resvp.s_vlan, resvp.t_vlan)
except Exception as ex:
logger.error("provision: error in add rule: src_if=%s sevlan=%s, ofvlan=%s, ex=%s" % (self.src_if, resvp.s_vlan, resvp.t_vlan, ex))
raise ex
try:
### add dst
self.add_rule(self.dst_if, resvp.d_vlan, resvp.t_vlan)
except Exception as ex:
logger.error("provision: error in add rule: dst_if=%s sevlan=%s, ofvlan=%s, ex=%s" % (self.dst_if, resvp.s_vlan, resvp.t_vlan, ex))
self.del_rule(self.src_if, resvp.s_vlan, resvp.t_vlan)
raise ex
self.dict_isSetRule[resv.resv_id] = True
return resv.resv_id
def check_stp (self, resv):
if resv.src_if == self.src_if and resv.dst_if == self.dst_if:
return True
if resv.src_if == self.dst_if and resv.dst_if == self.src_if:
return True
raise ManagerException("ovs manager:check_stp", "Mismatch interface between OvsManager and Reservation. %s:%s, %s:%s" % (self.src_if, self.dst_if, resv.src_if, resv.dst_if))
def get_port(self, dev):
if self.dict_dev.has_key(dev):
port = self.dict_dev[dev]
logger.info("swManager: get_port: dev=%s, ofport=%s" % (dev, port))
return self.dict_dev[dev]
raise ManagerException("ovsgre:swManager:get_port", "This dev(%s) does not exist." % dev)
def add_tunnel(urlbase, dpid, tnrmp):
# url = "http://localhost:8080/ovsdb/0000000000000010/tunnel/create"
# tnrmp["ovsdb"] = address pvsdb
# tnrmp["name"] = name of gre tunnel
# tnrmp["type"] = "gre"
# tnrmp["local_ip"] = local ip address
# tnrmp["remote_ip"] = remote ip address
params = {}
url = "%s/ovsdb/%s/%s" % (urlbase, dpid, "tunnel/create")
logger.info("add_tunnel: url=%s" % url)
params["tnrm"] = tnrmp
logger.info("add_tunnel: request url=%s, dict=%s" % (url, params))
rc = None
try:
req = urllib2.Request(url, "%s" % json.dumps(params))
rs = urllib2.urlopen(req)
rc = json.load(rs)
logger.info("add_tunnel: reply dict=%s" % rc)
except Exception as ex:
raise ManagerException(
"ovsif:add_tunnel",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
port = rc["tnrm"]["tunnel"]["ofport"]
logger.info("add_tunnel: ovs ofport=%s" % port)
return port
def swap_id (self, resv, new_id, old_id):
if resv is None:
raise ManagerException("OvsManager:swap_id", "The reservation is null.")
if not dict_resvParameter.has_key(resv.resv_id):
resvp = dict_resvParameter[new_id]
del dict_resvParameter[new_id]
dict_resvParameter[old_id] = resvp
return resv.resv_id
def terminate (self, resv):
if resv is None or not dict_resvParameter.has_key(resv.resv_id):
raise ManagerException("OvsManager:terminate", "The reservation is null.")
resvp = dict_resvParameter[resv.resv_id]
if resvp is None:
raise ManagerException("OvsManager:terminate", "The ResvParameter is null.")
self.release(resv)
resvp.free()
del dict_resvParameter[resv.resv_id]
if self.dict_used.has_key(resv.resv_id):
del self.dict_used[resv.resv_id]
if self.dict_isSetRule.has_key(resv.resv_id):
del self.dict_isSetRule[resv.resv_id]
return resv.resv_id
def re_provision (self, resv):
# provison:nsiv2, poa geni_start
logger.info("ovsManager:re_provision has_key(%s)=%s" %
(resv.resv_id, dict_resvParameter.has_key(resv.resv_id)))
if resv is None or not dict_resvParameter.has_key(resv.resv_id):
logger.info("ovsManager:re_provision: resv_id=%s" % (resv.resv_id))
for key in dict_resvParameter:
logger.info("ovsManager:re_provision: resvp=%s" % (key))
raise ManagerException("OvsManager:re_provision", "The reservation is null.")
resvp = dict_resvParameter[resv.resv_id]
if resvp is None:
raise ManagerException("OvsManager:re_privision", "The ResvParameter is null.")
self.isSetup = True
self.dict_used[resv.resv_id] = resv.resv_id
self.dict_isSetRule[resv.resv_id] = True
logger.info("ovsManager:re_provision: done. resv_id=%s" % (resv.resv_id))
return resv.resv_id
def get_vlanManager (s_stp, d_stp):
if s_stp is None:
raise ManagerException("ovsgre:get_vlanMamager", "The source stp is None.")
if d_stp is None:
raise ManagerException("ovsgre:get_vlanMamager", "The destination stp is None.")
key = getKey(s_stp, d_stp)
if dict_vlanManager.has_key(key):
if not dict_vlanManager.has_key(s_stp):
raise ManagerException("Never here. This is a fatal error to manage vlanManager. stp=%s" % (s_stp))
if not dict_vlanManager.has_key(d_stp):
raise ManagerException("Never here. This is a fatal error to manage vlanManager. stp=%s" % (d_stp))
return (dict_vlanManager[s_stp], dict_vlanManager[d_stp], dict_vlanManager[key])
key = getKey(d_stp, s_stp)
if dict_vlanManager.has_key(key):
if not dict_vlanManager.has_key(d_stp):
raise ManagerException("Never here. This is a fatal error to manage vlanManager. stp=%s" % (d_stp))
if not dict_vlanManager.has_key(s_stp):
raise ManagerException("Never here. This is a fatal error to manage vlanManager. stp=%s" % (s_stp))
return (dict_vlanManager[d_stp], dict_vlanManager[s_stp], dict_vlanManager[key])
key = getKey(s_stp, d_stp)
dict_vlanManager[key] = vlanManager(key, True)
if not dict_vlanManager.has_key(s_stp):
dict_vlanManager[s_stp] = vlanManager(s_stp)
if not dict_vlanManager.has_key(d_stp):
dict_vlanManager[d_stp] = vlanManager(d_stp)
return (dict_vlanManager[s_stp], dict_vlanManager[d_stp], dict_vlanManager[key])
def list_flows(urlbase, params):
url = "%s/stats/flow/%d" % (urlbase, params['dpid'])
rc = None
try:
rs = urllib2.urlopen(url)
rc = json.load(rs)
logger.info("flow entry: reply dict=%s" % rc)
except Exception as ex:
raise ManagerException(
"ovsif:list_flow",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
return rc
def setup_tunnel(self, src_if, dst_if):
logger.info("setup src_if=%s" % src_if)
logger.info("setup dst_if=%s" % dst_if)
sw = get_swManager(src_if)
ofport = None
try:
# ofport = sw.get_port(src_if.ofdev)
ofdev, ofport = src_if.get_of(self.ovs_id)
ofport2 = sw.get_port(ofdev)
if ofport != ofport2:
logger.error(
"setup_tunnel:ofdev=%s: mismatch ofport=%s, ofport2=%s" %
(ofdev, ofport, ofport2))
ofport = ofport2
except Exception as ex:
logger.info("setup_tunnel:gre port is None")
if ofport is None:
urlbase = src_if.ryu_url
dpid = src_if.dpid
logger.info(
"setup gre link here. url=%s, dpid=%s, ovsdb=%s, dev=%s, type=%s, local=%s, remote=%s"
% (urlbase, dpid, src_if.ovsdb, ofdev, src_if.gtype,
src_if.address, dst_if.address))
params = {}
params["ovsdb"] = src_if.ovsdb
params["name"] = ofdev
if (src_if.gtype == "ovsgre"):
params["type"] = "gre"
else:
raise ManagerException(
"OvsManager:setup_tunnel",
"Type (%s) is unknown, must be \"ovsgre\"." %
(src_if.gtype))
params["local_ip"] = src_if.address
params["remote_ip"] = dst_if.address
ofport = ovsif.add_tunnel(urlbase, dpid, params)
# src_if.ofport = ofport
src_if.set_of(self.ovs_id, ofdev, ofport)
sw.set_used(ofdev, ofport)
def del_flow(urlbase, params):
url = "%s/stats/flowentry/delete" % (urlbase)
logger.info("del_flow: url=%s" % url)
logger.info("del_flow: request url=%s, dict=%s" % (url, params))
rc = None
try:
req = urllib2.Request(url, "%s" % json.dumps(params))
rs = urllib2.urlopen(req)
url = "%s/stats/flow/%d" % (urlbase, params['dpid'])
rs = urllib2.urlopen(url)
rc = json.load(rs)
logger.info("flow entry: reply dict=%s" % rc)
except Exception as ex:
raise ManagerException(
"ovsif:del_flow",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
return rc
def search (self):
for v in xrange(self.vlan_pos, self.vlan_max):
logger.info("ovsgre:vlanManager:search: vlan=%d" % (v))
if self.dict_vlans.has_key(str(v)):
continue
else:
self.vlan_pos = v + 1
if self.vlan_pos == self.vlan_max:
self.vlan_pos = self.vlan_min
return str(v)
for v in xrange(self.vlan_min, self.vlan_pos):
logger.info("ovsgre:vlanManager:search: vlan=%d" % (v))
if self.dict_vlans.has_key(str(v)):
continue
else:
self.vlan_pos = v + 1
if self.vlan_pos == self.vlan_max:
self.vlan_pos = self.vlan_min
return str(v)
raise ManagerException("proxy:allocate_vlan", "New vlan is not allocated.")
def allocate_dev(self, dst_if):
lkey = self.key + ":" + dst_if.ryu_url + "/" + dst_if.dpid
logger.info("swManager:allocate_dev: lkey=%s." % lkey)
if self.dict_path.has_key(lkey):
dev = self.dict_key[lkey]
logger.info("swManager:allocate_dev: old device is %s." % dev)
# return self.dict_dev[lkey]
return dev
for v in xrange(dev_min, dev_max):
dev = "%s%03d" % (ovsif.PREFIX_DEV, v)
if dev in self.dict_dev:
continue
else:
logger.info("swManager:allocate_dev: new device is %s." % dev)
self.dict_path[lkey] = dev
self.set_used(dev, None)
return dev
raise ManagerException("OvsManager:swManager:allocate_dev",
"There is no resources for device in openvSwitch.")
def add_flow(urlbase, params):
# url = "http://localhost:8080/stats/flowentry/add
# params["dpid"] = int dpid of open vSwitch
# params["match"] = {"in_port":1, "dl_vlan":1795}
# params["action"] = [{"type":"SET_VLAN_VID", "vlan_vid":795}, {"type":"OUTPUT", "port":2}]'
#
# params["priority"] = priority: matching precedence of the ow entry. int
# params["idel_timeout"] = 0 not expired
# params["hard_timeout"] = 0 not expired
# params["cookie"] = 1 : opaque data value chosen by the controller.
# May be used by the controller to lter owstatistics,
# ow modication and ow deletion. Not used when processing packets. int 0
# params["cookie_mask"] = 0
# params["table_id"] = 0 , Table 0 signies the rst table in the pipeline.
# params["flags"] = 1, Send flow removed message when flow expires or is deleted.
url = "%s/stats/flowentry/add" % (urlbase)
logger.info("add_flow: url=%s" % url)
logger.info("add_flow: request url=%s, dict=%s" % (url, params))
rc = None
try:
req = urllib2.Request(url, "%s" % json.dumps(params))
rs = urllib2.urlopen(req)
logger.info("flow entry: return=%s" % rs)
url = "%s/stats/flow/%d" % (urlbase, params['dpid'])
rs = urllib2.urlopen(url)
rc = json.load(rs)
logger.info("flow entry: reply dict=%s" % rc)
except Exception as ex:
raise ManagerException(
"ovsif:add_flow",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
return rc
def del_tunnel(urlbase, dpid, tnrmp):
# url = "http://localhost:8080/ovsdb/0000000000000010/tunnel/delete"
# tnrmp["ovsdb"] = address pvsdb
# tnrmp["remote_ip"] = remote ip address
params = {}
url = "%s/ovsdb/%s/%s" % (urlbase, dpid, "tunnel/delete")
logger.info("delete_tunnel: url=%s" % url)
params["tnrm"] = tnrmp
logger.info("delete_tunnel: request url=%s, dict=%s" % (url, params))
rc = None
try:
req = urllib2.Request(url, "%s" % json.dumps(params))
rs = urllib2.urlopen(req)
rc = json.load(rs)
logger.info("delete_tunnel: reply dict=%s" % rc)
except Exception as ex:
raise ManagerException(
"ovsif:del_tunnel",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
def allocate(self,
slice_urn,
client_cert,
credentials,
rspec,
end_time=None):
"""Documentation see [geniv3rpc] GENIv3DelegateBase."""
# logger.info("slice_urn=%s" % (slice_urn))
# logger.info("client_cert=%s" % (client_cert))
# logger.info("credentials=%s" % (credentials))
# logger.info("request rspec=%s" % (rspec))
# logger.info("end_time=%s" % (end_time))
self.restart_from_db()
logger.info(">>>>> allocate <<<<< urn=%s" % slice_urn)
# start_time = datetime.now()
start_time = get_time_now()
start_time += timedelta(minutes=2)
if (isinstance(end_time, type(None)) == True):
end_time = start_time + timedelta(minutes=10)
end_time = start_time + timedelta(hours=3)
else:
delta = end_time - start_time
logger.debug("delta days=%s, seconds=%s" %
(delta.days, delta.seconds))
if (delta.days * 24 * 3600 + delta.seconds < 60):
end_time = start_time + timedelta(seconds=60)
logger.debug("re-set end_time=%s" % (end_time))
if slice_urn in dict_slice_urn:
req = dict_slice_urn[slice_urn]
for urn in req.urns:
resv = req.get_reservation(urn)
logger.info(
"delete service=%s: urn=%s, reservation=%s, status=%s" %
(resv.service, urn, resv, resv.astatus))
raise geni_ex.GENIv3GeneralError("slice_urn(%s) is already exit." %
(slice_urn))
logger.info("allocate: add dict_slice_urn[%s]." % slice_urn)
start_time_sec = unix_time_sec(start_time)
end_time_sec = unix_time_sec(end_time)
req = Request(slice_urn, rspec, start_time, end_time)
req, error = req.parse_reservations()
if error is not None:
raise geni_ex.GENIv3GeneralError(error)
logger.info("slice=%s, urns=%s" % (slice_urn, str(req.urns)))
dict_slice_urn[slice_urn] = req
isError = False
manifest_body = ""
for urn in req.urns:
logger.info("allocate:loop: urn=%s" % urn)
resv = req.get_reservation(urn)
resv.ostatus = self.OPERATIONAL_STATE_NOTREADY
resv.astatus = self.ALLOCATION_STATE_UNALLOCATED
resv.action = self.OPERATIONAL_ACTION_STOP
if resv.error is not None:
isError = True
manifest_body += resv.get_manifest()
slice_status = req.get_status()
req.set_manifest(manifest_body)
manifest = req.get_manifest()
# logger.info("manifest=%s" % manifest)
if isError:
self.__slice_delete_status(req, get_time_now())
return (manifest, slice_status)
for urn in req.urns:
resv = req.get_reservation(urn)
logger.info("call reserve %s" % (resv))
#
# VLAN range check in Reservation
#
try:
if resv.service == "NSI":
rid = nsi_proxy.reserve(
resv.gid,
resv.path.sep.stp,
resv.path.dep.stp,
# int(resv.path.sep.vlantag),
int(resv.src_vlan),
# int(resv.path.dep.vlantag),
int(resv.dst_vlan),
int(resv.path.sd_bw),
unix_time_sec(start_time),
unix_time_sec(end_time))
elif resv.service == "GRE":
rid = gre_proxy.reserve(resv)
else:
emes = "Unknown service=%s: urn=%s, reservation=%s" % (
resv.service, slice_urn, resv)
logger.error(emes)
raise ManagerException("tn_rm_delegate:allocate", emes)
logger.info("urns=%s, rid=%s" % (slice_urn, rid))
resv.resv_id = rid
resv.astatus = self.ALLOCATION_STATE_ALLOCATED
resv.ostatus = self.OPERATIONAL_STATE_READY
resv.action = self.OPERATIONAL_ACTION_STOP
except Exception as e:
logger.error("ex=%s" % (e))
resv.error = "%s" % (e)
#resv.src_if.vman.putVlanYellow(resv.path.sep.vlantag)
#resv.dst_if.vman.putVlanYellow(resv.path.dep.vlantag)
resv.src_if.vman.putVlanYellow(resv.src_vlan)
resv.dst_if.vman.putVlanYellow(resv.dst_vlan)
isError = True
slice_status = req.get_status()
manifest = req.get_manifest()
if isError:
self.__slice_delete_status(req, get_time_now())
else:
for urn in req.urns:
resv = req.get_reservation(urn)
self.db.insert(resv)
return (manifest, slice_status)
def get_tunnel_info(urlbase, dpid, tnrmp):
# url = "http://localhost:8080/ovsdb/0000000000000010/info"
# tnrmp["ovsdb"] = address ovsdb
# tnrmp["remote_ip"] = tunnel remote address
# tnrmp["local_ip"] = tunnel local address
params = {}
url = "%s/ovsdb/%s/%s" % (urlbase, dpid, "ports")
logger.info("get_tunnel_info: url=%s" % url)
tnrmp["name"] = PREFIX_DEV
params["tnrm"] = tnrmp
logger.info("get_tunnel_info: request url=%s, dict=%s" % (url, params))
rc = None
try:
req = urllib2.Request(url, "%s" % json.dumps(params))
rs = urllib2.urlopen(req)
rc = json.load(rs)
logger.info("get_tunnel_info: reply dict=%s" % rc)
except Exception as ex:
raise ManagerException(
"ovsif:get_tunnel_info",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
ports = {}
try:
for p in rc["tnrm"]["ports"].keys():
if tnrmp["name"] in p:
logger.info("get_tunnel_info: dev=%s, port=%s" %
(p, rc["tnrm"]["ports"][p]))
ports[p] = rc["tnrm"]["ports"][p]
except:
# raise ManagerException("ovsif:get_tunnel_port",
# "This port (%s) dose not exist in Open vSwitch(%s)." % (name, dpid))
logger.info(
"get_tunnel_info: This port (%s) dose not exist in Open vSwitch(%s)."
% (tnrmp["name"], dpid))
return ports
find = {}
for p in ports:
url = "%s/ovsdb/%s/%s" % (urlbase, dpid, "tunnel/info")
logger.info("get_tunnel_info: url=%s" % url)
param = {}
tnrmp["name"] = p
param["tnrm"] = tnrmp
logger.info("get_tunnel_info: request url=%s, dict=%s" % (url, params))
rc = None
try:
req = urllib2.Request(url, "%s" % json.dumps(params))
rs = urllib2.urlopen(req)
rc = json.load(rs)
except Exception as ex:
raise ManagerException(
"ovsif:get_tunnel_info",
"error in call ryu-manager. url=%s, ex=%s" % (url, ex))
tp = rc["tnrm"]["tunnel"]
logger.info("get_tunnel_info: reply dict=%s" % tp)
if tnrmp.has_key(
"remote_ip") and tnrmp["remote_ip"] != tp["remote_ip"]:
pass
elif tnrmp.has_key("type") and tnrmp["type"] != tp["type"]:
pass
else:
logger.info(
"get_tunnel_info: find name=%s, remote_ip=%s, type=%s, port=%s"
% (p, tp["remote_ip"], tp["type"], ports[p]))
find[p] = ports[p]
return find
def modify (self, resv, end_time_sec):
# This do nothing here.
if resv is None or not dict_resvParameter.has_key(resv.resv_id):
raise ManagerException("OvsManager:modify", "The reservation is null.")
return resv.resv_id
def release (self, resv):
e = None
### release:nsiv2, poa geni_stop
if resv is None or not dict_resvParameter.has_key(resv.resv_id):
raise ManagerException("OvsManager:release", "The reservation is null.")
resvp = dict_resvParameter[resv.resv_id]
if resvp is None:
raise ManagerException("OvsManager:release", "The ResvParameter is null.")
if self.dict_isSetRule.has_key(resv.resv_id):
if self.dict_isSetRule[resv.resv_id]:
logger.info("delete flow rule here. %s?vlan=%s:%s?vlan=%s, gre?vlan=%s." %
(resvp.s_stp, resvp.s_vlan, resvp.d_stp, resvp.d_vlan, resvp.t_vlan))
try:
### delete src
self.del_rule(self.src_if, resvp.s_vlan, resvp.t_vlan)
except Exception as ex:
e = ex
logger.error("release: error in delete rule: src_if=%s sevlan=%s, ofvlan=%s, ex=%s" % (self.src_if, resvp.s_vlan, resvp.t_vlan, ex))
try:
### delete dst
self.del_rule(self.dst_if, resvp.d_vlan, resvp.t_vlan)
except Exception as ex:
e = ex
logger.error("release: error in delete rule: dst_if=%s sevlan=%s, ofvlan=%s, ex=%s" % (self.dst_if, resvp.d_vlan, resvp.t_vlan, ex))
self.dict_isSetRule[resv.resv_id] = False
else:
# already delete flow rule
pass
else:
logger.info("OvsManager:release: This reservation (%s) does not have isSetRule." %
(resv.resv_id))
if self.dict_used.has_key(resv.resv_id):
del self.dict_used[resv.resv_id]
else:
logger.info("OvsManager:release: This reservation (%s) does not used this gre link." %
(resv.resv_id))
if self.isSetup:
if len(self.dict_used) > 0:
logger.info("This gre link is shared other reservtion. Do not teardown now.")
else:
e = None
### teardown src->dst
try:
self.teardown_tunnel(self.src_if, self.dst_if)
except Exception as ex:
e = ex
logger.error("release: error in teardown: src_if=%s, dst_if=%s ex=%s" % (self.src_if, self.dst_if, ex))
### teardown dst->src
try:
self.teardown_tunnel(self.dst_if, self.src_if)
except Exception as ex:
e = ex
logger.error("release: error in teardown: src_if=%s, dst_if=%s ex=%s" % (self.dst_if, self.src_if, ex))
self.isSetup = False
self.isSetup = False
else:
logger.info("This link is already teardown.");
if e is not None:
raise e
return resv.resv_id
