def __createDuplexLink(self, side1, side2, bandwidth, delay):
"""Creates a link between hosts/routers (sides 1 and 2).
Also configures the link's bandwidth (in Mbps) and
delay (in ms)."""
# print("{Link} %s <=> %s [%g Mbps, %g ms]" %
# (side1, side2, bandwidth, delay))
if '.' in side1 and '.' in side2:
port1 = int(side1.split('.')[1])
port2 = int(side2.split('.')[1])
queue1 = self.routers[side1.split('.')[0]].getBufferQueue(port1)
queue2 = self.routers[side2.split('.')[0]].getBufferQueue(port2)
self.routers[side1.split('.')[0]].addLink(
port1, Link(queue2, bandwidth, delay))
self.routers[side2.split('.')[0]].addLink(
port2, Link(queue1, bandwidth, delay))
else:
if not '.' in side1:
aux = side1
side1 = side2
side2 = aux
# 1 is router, 2 is host
port1 = int(side1.split('.')[1])
queue1 = self.routers[side1.split('.')[0]].getBufferQueue(port1)
queue2 = self.hosts[side2].getNetQueue()
self.routers[side1.split('.')[0]].addLink(
port1, Link(queue2, bandwidth, delay))
self.hosts[side2].addLink(Link(queue1, bandwidth, delay))
def inchworm(seg_lens, q0, base=None):
"""Creates a complex arm with 10 segments
:param seg_lens: 1x10 vector of lengths of each sement
:type seg_lens: numpy.ndarray
:param q0: 1xN vector of the starting joint configuration
:type q0: numpy.ndarray
:param base: (Optional) optional (x, y, z) base location of arm
:type base: numpy.ndarray or None
:returns: "Noodle" arm
:rtype: maddux.robot.Arm
"""
# L1 = Link(0, seg_lens[0], 0, 1.571)
# L2 = Link(0, 0, seg_lens[1], 0)
# L3 = Link(0, 0, seg_lens[2], 0)
# L4 = Link(1.571, 0, seg_lens[3], 1.571)
L1 = Link(0, seg_lens[0], 0, 1.571)
L2 = Link(0, 0, seg_lens[1], 0)
L3 = Link(0, 0, seg_lens[2], 0)
L4 = Link(0, 0, 0, 1.571)
L4 = Link(0, 0, seg_lens[3], 0)
links = np.array([L1, L2, L3, L4])
robot = Arm(links, q0, 'inchworm', 10, base)
return robot
def do_test(n_data_packets, cc, add_events):
"""
The test has 2 hosts connected by a link, and one flow.
"""
em = EventManager(logging=False)
host_1 = Host(em, 'H1', debug=False)
host_2 = Host(em, 'H2', debug=False)
sr = SeqNumberRecorder('S', host_2)
l1_a = Link(em, 'L1_a', host_1, sr, DATA_PACKET_SIZE * 1000, 0.01,
5 * DATA_PACKET_SIZE, debug=False)
l1_b = Link(em, 'L1_b', host_2, host_1, DATA_PACKET_SIZE * 1000, 0.01,
5 * DATA_PACKET_SIZE, debug=False)
host_1.link = l1_a
host_2.link = l1_b
flow = Flow(em, 'F1', host_1, host_2, n_data_packets * DATA_PACKET_SIZE, 1,
cc, debug=False)
add_events(em, host_1, host_2, sr, l1_a, l1_b, flow)
em.run()
assert sr.seqs == set(range(n_data_packets + 1))
# print('Src send first unacked', flow.src.send_first_unacked, 'Src send next', flow.src.send_next, 'Dst receive next', flow.dst.receive_next)
assert flow.src.last_seq_number == n_data_packets
assert flow.src.send_first_unacked == n_data_packets + 1
assert flow.src.send_next == n_data_packets + 1
assert flow.dst.receive_next == n_data_packets + 1
def test_navigation(self):
LoginPage(self.browser).open()
Link(self.browser, 'Accessories').hover()
Link(self.browser, 'Shoes').click()
self.assertTrue(
Product(self.browser, 'Ann Ankle Boot').is_visible)
def calcWorker(self, worker_id):
while (self.go.value):
# Take ORDER
if self.workers_query_result_q.qsize() > 3:
print "Warning: the queue is containing %d elements" % (
self.workers_query_result_q.qsize())
order = self.workers_query_result_q.get()
profile = order["profile"]
profile_srtm = order["profile_srtm"]
id1 = order["id1"]
id2 = order["id2"]
# Normal profile
try:
link = Link(profile)
loss, status = link.loss_calculator()
except (ZeroDivisionError, ProfileException), e:
loss = 0
status = -1
# Downscaled profile
try:
link_ds = Link(profile)
loss_ds, status_ds = link_ds.loss_calculator(downscale=3)
except (ZeroDivisionError, ProfileException), e:
loss_ds = 0
status_ds = -1
def noodle_arm(seg_lens, q0, base=None):
"""Creates a complex arm with 10 segments
:param seg_lens: 1x10 vector of lengths of each sement
:type seg_lens: numpy.ndarray
:param q0: 1xN vector of the starting joint configuration
:type q0: numpy.ndarray
:param base: (Optional) optional (x, y, z) base location of arm
:type base: numpy.ndarray or None
:returns: "Noodle" arm
:rtype: maddux.robot.Arm
"""
L1 = Link(0, seg_lens[0], 0, 1.571)
L2 = Link(0, seg_lens[1], 0, -1.571)
L3 = Link(0, seg_lens[2], 0, -1.571)
L4 = Link(0, seg_lens[3], 0, 1.571)
L5 = Link(0, seg_lens[4], 0, 1.571)
L6 = Link(0, seg_lens[5], 0, -1.571)
L7 = Link(0, seg_lens[6], 0, 1.571)
L8 = Link(0, seg_lens[7], 0, 1.571)
L9 = Link(0, seg_lens[8], 0, -1.571)
L10 = Link(0, seg_lens[9], 0, 1.571)
links = np.array([L1, L2, L3, L4, L5, L6, L7, L8, L9, L10])
robot = Arm(links, q0, 'noodle_arm', 10, base)
return robot
def test_create_link_bad_lenght():
"""Attempt to create a link whose length is not greater than zero."""
network = Network()
alice = Router(network, "alice")
bob = Router(network, "bob")
with pytest.raises(AssertionError):
_link = Link(alice, bob, -100)
with pytest.raises(AssertionError):
_link = Link(alice, bob, 0)
def create_links(self):
link1 = Link(self.core1, self.core2)
self.links.append(link1)
link2 = Link(self.core2, self.core1)
self.links.append(link2)
if link1.get_link_id() is link2.get_link_id():
self.link_id = link1.get_link_id()
self.core1.add_link_id(self.link_id)
self.core2.add_link_id(self.link_id)
class TestAircraft(unittest.TestCase):
Config.params["simulator"]["test_mode"] = True
# Generates a itinerary_template
n1 = Node("N1", {"lat": 37.611526, "lng": -122.390443})
n2 = Node("N2", {"lat": 37.611375, "lng": -122.390443})
n3 = Node("N3", {"lat": 37.611224, "lng": -122.390443})
# n1 = Node("N1", {"lat": 47.722000, "lng": -122.079057})
# n2 = Node("N2", {"lat": 47.822000, "lng": -122.079057})
# n3 = Node("N3", {"lat": 47.922000, "lng": -122.079057})
# m1 = Node("M1", {"lat": 47.772000, "lng": -122.079057})
# m2 = Node("M2", {"lat": 47.872000, "lng": -122.079057})
#
# m = Node("M", {"lat": 47.755333, "lng": -122.079057})
links = []
links.append(Link("test1", [n1, n2]))
links.append(Link("test2", [n2, n3]))
itinerary_template = Itinerary(links)
for link in links:
print(link.length)
def test_init(self):
aircraft = Aircraft("F1", "M1", self.n1, State.unknown)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.location, self.n1)
def test_tick(self):
itinerary = deepcopy(self.itinerary_template)
aircraft = Aircraft("F1", "M1", self.n1, State.stop)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.state, State.stop)
# Stop state
aircraft.tick()
self.assertEqual(aircraft.itinerary, None)
# Moving state
aircraft.set_itinerary(itinerary)
self.assertTrue(aircraft.itinerary)
self.assertEqual(aircraft.state, State.moving)
self.assertEqual(aircraft.itinerary.current_target.nodes[0], self.n1)
aircraft.tick() # pass hold link, current_target node not changed
self.assertEqual(aircraft.itinerary.current_target.nodes[0], self.n1)
aircraft.tick()
self.assertEqual(aircraft.itinerary.current_target.nodes[0], self.n2)
aircraft.tick()
self.assertTrue(aircraft.itinerary.is_completed)
def linkPads(self, other):
if self.direction() == gst.PAD_SRC:
link = Link(self, other, self.selection)
else:
link = Link(other, self, self.selection)
self.links.append(link)
other.links.append(link)
self.get_canvas().get_root_item().add_child(link)
self.updateLinks()
other.updateLinks()
def link_ptp(self, other, method=""):
"""
Create p-t-p link with other interface
Raise ValueError if either of interface already connected.
:type other: Interface
:returns: Link instance
"""
# Try to check existing LAG
el = Link.objects.filter(interfaces=self.id).first()
if el and other not in el.interfaces:
el = None
if (self.is_linked or other.is_linked) and not el:
raise ValueError("Already linked")
if self.id == other.id:
raise ValueError("Cannot link with self")
if self.type in ("physical", "management"):
if other.type in ("physical", "management"):
# Refine LAG
if el:
left_ifaces = [i for i in el.interfaces if i not in (self, other)]
if left_ifaces:
el.interfaces = left_ifaces
el.save()
else:
el.delete()
#
link = Link(interfaces=[self, other],
discovery_method=method)
link.save()
return link
else:
raise ValueError("Cannot connect %s interface to %s" % (
self.type, other.type))
elif self.type == "aggregated":
# LAG
if other.type == "aggregated":
# Check LAG size match
# Skip already linked members
l_members = [i for i in self.lag_members if not i.is_linked]
r_members = [i for i in other.lag_members if not i.is_linked]
if len(l_members) != len(r_members):
raise ValueError("LAG size mismatch")
# Create link
if l_members:
link = Link(interfaces=l_members + r_members,
discovery_method=method)
link.save()
return link
else:
return
else:
raise ValueError("Cannot connect %s interface to %s" % (
self.type, other.type))
raise ValueError("Cannot link")
def test_len(self):
print("test_len")
# graph = Graph()
node_a = Node("A")
node_b = Node("B")
node_c = Node("C")
link_ab = Link(node_a, node_b)
link_ac = Link(node_a, node_c)
self.assertEqual(len(node_a), 2)
def simple_3dof_arm(seg1_len, seg2_len, seg3_len, q0, base=None):
"""Creates a simple human-like robotic arm with 7 links and 2 segments
with the desired lengths and starting joint configuration
:param seg1_len: The length of the first segment of the arm
:type seg1_len: int
:param seg2_len: The length of the second segment of the arm
:type seg2_len: int
:param q0: 1xN vector of the starting joint configuration
:type q0: numpy.ndarray
:param base: (Optional) (x, y, z) location of arm base
:type base: numpy.ndarray or None
:returns: 7 link, 2 segment "human" arm.
:rtype: maddux.robot.Arm
"""
L1 = Link(0, 0, 0, 1.571)
L2 = Link(0, 0, 0, -1.571)
L3 = Link(0, seg1_len, 0, -1.571)
L4 = Link(0, seg2_len, 0, -1.571)
L5 = Link(0, 0, seg3_len, -1.571)
L6 = Link(0, 0, 0, 1.571)
L7 = Link(0, 0, 0, 1.571)
L8 = Link(0, 0, 0, 0)
links = np.array([L1, L2, L3, L4, L5, L6, L7, L8])
robot = Arm(links, q0, 'simple_3dof_arm', 4, base)
return robot
def test_footer_links(self):
links = (
# MEN
'New Arrivals',
'Shirts',
'Blazers'
# WOMEN
)
LoginPage(self.browser).open()
for link in links:
Link(self.browser, 'Men').hover()
Link(self.browser, link).click()
self.assertTrue(Header(self.browser, link).is_visible)
self.assertIn(link, self.browser.title)
def handle_message(self, msg):
if msg['msg'] == "entanglement swapping done":
# update connections table
self.handle_swap_success(..., ...)
# retitle the message and forward it.
# Note that the msg contains two measurement results.
msg['msg'] = "entanglement swapping corrections"
self.send_message(remote_repeater, msg)
elif msg['msg'] == "entanglement swapping corrections":
measurement_result1 = msg['measurement_result1']
measurement_result2 = msg['measurement_result2']
# assume we have received the qubit already.
# ask the repeaterHardware to apply corrections.
self.hardware.apply_swap_corrections(qubitId,
measurement_result1,
measurement_result2)
elif msg['msg'] == "entanglement swapping corrections applied":
# update connections table
# self.handle_swap_success(..., ...)
return
elif msg['msg'] == "received qubit":
return
elif msg['msg'] == "received link qubit":
sender = msg['sender'].parent_repeater # sender is a node hardware
side = "left" if sender in (self.left_cable.node1, self.left_cable.node2) else "right"
if side == "left":
self.left_link = sender.right_link
self.left_link.node2 = self
else:
self.right_link = sender.left_link
self.right_link.node2 = self
# notify the parent repeater chain
if self.parent_repeater_chain:
msg = {'msg' : "link created",
'link': self.left_link if side == "left" else self.right_link,
'side': side}
self.send_message(self.parent_repeater_chain)
elif msg['msg'] == "sent link qubit":
receiver = msg['receiver'].parent_repeater # change this to parent node throughout
side = "left" if receiver in (self.left_cable.node1, self.left_cable.node2) else "right"
if side == "left":
self.left_link = Link()
self.left_link.node1 = self
else:
self.right_link = Link()
self.right_link.node1 = self
else:
print("received unknown message")
def post(self):
user = users.get_current_user()
if user:
containers = Container.query(Container.user == user)
cont = None
if not containers.iter().has_next():
cont = Container(user = user)
cont.put()
else:
cont = containers.iter().next()
check = True
for link in cont.links:
if link.name == self.request.get("name"):
check = False
break
if check:
url = self.request.get("url")
url = url if url.startswith("http://") or url.startswith("https://") else "http://" + url
cont.links.append(Link(name = self.request.get("name"), url = url, tags = self.request.get("tags")))
cont.put()
time.sleep(1)
else:
self.set_flash("danger", "duplicated-name")
self.redirect("/")
else:
self.set_flash("danger", "not-logged-in")
self.redirect("/")
def handleChanges(self):
"""Handle changes to links. Run this method in a separate thread.
Uses a priority queue to track time of next change"""
startTime = time.time()*1000
while not self.changes.empty():
changeTime, target, change = self.changes.get()
currentTime = time.time()*1000
waitTime = (changeTime*self.latencyMultiplier + startTime) - currentTime
if waitTime > 0:
time.sleep(waitTime/float(1000))
# link changes
if change == "up":
addr1, addr2, p1, p2, c12, c21 = target
link = Link(addr1, addr2, c12, c21, self.latencyMultiplier)
self.links[(addr1,addr2)] = (p1, p2, c12, c21, link)
self.routers[addr1].changeLink(("add", p1, addr2, link, c12))
self.routers[addr2].changeLink(("add", p2, addr1, link, c21))
elif change == "down":
addr1, addr2, = target
p1, p2, _, _, link = self.links[(addr1, addr2)]
self.routers[addr1].changeLink(("remove", p1))
self.routers[addr2].changeLink(("remove", p2))
# update visualization
if hasattr(Network, "visualizeChangesCallback"):
Network.visualizeChangesCallback(change, target)
def handleChanges(self):
"""Handle changes to links. Run this method in a separate thread.
Uses a priority queue to track time of next change"""
startTime = time.time()*1000
while not self.changes.empty():
changeTime, target, change = self.changes.get()
currentTime = time.time()*1000
waitTime = (changeTime*self.latencyMultiplier + startTime) - currentTime
if waitTime > 0:
time.sleep(waitTime/float(1000))
# link changes
if change == "up":
addr1, addr2, p1, p2, c12, c21 = target
link = Link(addr1, addr2, c12, c21, self.latencyMultiplier)
# since we have change,so we need to add link to links
self.links[(addr1,addr2)] = (p1, p2, c12, c21, link)
# samething happens, routers need to change(add) link
self.routers[addr1].changeLink(("add", p1, addr2, link, c12))
self.routers[addr2].changeLink(("add", p2, addr1, link, c21))
elif change == "down":
addr1, addr2, = target
# samething happens, we need to get the ports of the original link
p1, p2, _, _, link = self.links[(addr1, addr2)]
# then we remove the link from these ports
self.routers[addr1].changeLink(("remove", p1))
self.routers[addr2].changeLink(("remove", p2))
# update visualization
if hasattr(Network, "visualizeChangesCallback"):
Network.visualizeChangesCallback(change, target)
def _handleResource(self):
while (not (self.__queue.isEnd())):
currentURL = self.__queue.pop()
if (self.__rsrc in currentURL.getByteRef()):
links = currentURL.getAllLinks()
for i in links:
self.__queue.push(Link(i))
def readLinkFile(netname):
nodesByID={}
linksByID={}
minSpeedLimit=10000 #km/hr
with open(inputsDirectory+'/'+netname+'/Links.txt','r') as f:
# with open('/Users/vpandey/Box Sync/UT Acads/PhD Dissertation/Modeling/MEME_DRL/gym-meme/gym_meme/envs/inputs/'+netname+'/Links.txt','r') as f:
next(f) # skip headings
reader=csv.reader(f,delimiter='\t')
for fID, tID, l,c,jD,ffs,bws,cl,ini in reader:
fID=int(fID); tID=int(tID)
l= float(l); c=float(c); jD=float(jD)
ffs=float(ffs); bws=float(bws)
if fID not in nodesByID:
n= Node(fID)
nodesByID[fID]=n
if tID not in nodesByID:
n=Node(tID)
nodesByID[tID]=n
fromNode = nodesByID[fID]
toNode = nodesByID[tID]
linkID = fID*100+tID
l= Link(linkID, fromNode, toNode, l, c, jD, ffs, bws, cl)
if ffs<minSpeedLimit:
minSpeedLimit=ffs
linksByID[linkID]=l
return nodesByID,linksByID, minSpeedLimit
def load_topology(p_file_path, p_link_list, p_scale=0):
"""
:param p_file_path:
:type p_file_path: str
:param p_link_list:
:type p_link_list: dict
:return:
"""
f = open(p_file_path, 'r')
line = f.readline() # 1行を文字列として読み込む(改行文字も含まれる)
node_count = int(line)
# ノード集合
nodes = range(1, node_count + 1)
line = f.readline()
while line:
data = line[:-1].split(' ')
if len(data) == 3 and data[0].isdigit() and data[1].isdigit(
) and data[2].isdigit():
if p_scale == 0:
p_scale = get_scale_rand()
p_link_list[(int(data[0]),
int(data[1]))] = Link(distance=int(data[2]),
bandwidth=100,
failure_rate=0,
shape=get_shape(),
scale=p_scale,
age=get_initial_age(p_scale))
line = f.readline()
f.close()
return (node_count, p_link_list)
def export(self):
l = Link(self.url, self.source_url)
self.url_id = l.url_id
return {
"url": l.url,
"url_id": self.url_id,
"link_id": l.subdomain + "_" + l.domain,
"domain": l.domain,
"subdomain": l.subdomain,
"extension": l.extension,
"filetype": l.filetype,
"date": [dt.now()],
"source_url": self.source_url,
"title": self.title,
"cited_links": self.links,
"cited_links_ids": self.domain_ids,
"cited_domains": self.domains,
"html": self.html,
"text": self.text,
"depth": self.depth,
#"keywords": self.keywords,
#"description": self.description,
"meta": self.meta,
"crawl_nb": 0,
"status": [True],
"msg": ["Ok"]
#"lang": self.metalang,
}
def fetch_domains_id(self):
self.domain_ids = []
for n in self.links:
url = Link(n, self.url)
if url.is_valid():
self.domain_ids.append(url.netloc)
return self.domain_ids
def fetch_domains(self):
self.domains = []
for n in self.links:
url = Link(n, self.url)
if url.is_valid():
self.domains.append(url.domain)
return self.domains
def fetch_links(self):
''' extract raw_links and domains '''
self.domains = []
self.links = []
self.domain_ids = []
#self.urls_ids = []
links = [n.get('href') for n in self.doc.find_all("a")]
links = [
n for n in links
if n is not None and n != "" and n != "/" and n[0] != "#"
]
for url in links:
if url.startswith('mailto'):
pass
if url.startswith('javascript'):
pass
else:
l = Link(url)
url, domain, domain_id = l.clean_url(url, self.url)
self.domains.append(domain)
self.links.append(url)
self.domain_ids.append(domain_id)
return (self.links, self.domains, self.domain_ids)
def test_node_from(self):
print("test_node_from")
node_a = Node("A")
node_b = Node("B")
link = Link(node_a, node_b)
self.assertEqual(link.node_from(node_a), node_b)
self.assertEqual(link.node_from(node_b), node_a)
def test_name(self):
print("test_name")
node_a = Node("A")
node_b = Node("B")
link = Link(node_a, node_b)
self.assertEqual(link.name(node_a), "A-B")
self.assertEqual(link.name(node_b), "B-A")
def __get_links(self, link):
try:
response = self.downloader.getContent(link)
if response.status_code == 200:
self.lookup[link].crawled = True
links = self.parser.parseLinks(response.text)
logging.debug(link + ' crawled' + str(len(links)))
self.lookup[link].extracted_links_count = len(links)
for link in links:
self.q.put(link)
if not link in self.lookup:
self.links_count += 1
self.file.write(link + '\n')
self.lookup[link] = Link()
else:
logging.error(link + ' failed to get response with code ' +
str(response.status_code))
self.lookup[link].res_code = response.status_code
self.lookup[link].attempts += 1
if self.lookup[link].attempts < Crawler.MAT_RETREIS:
self.q.put(link)
else:
logging.error(link + ' MAX_RETRIES Exceeded')
except Exception as err:
logging.error(err)
def get_link_board_vertical(suffix):
return [[
Link("r%ic%i-%s" % (r, c, suffix),
link_length,
free_flow_velocity=random.choice(velocities_kmh) * 0.277)
for c in range(edge_length)
] for r in range(edge_length - 1)]
def add_link(self, v, w, element):
if not v in self._structure or not w in self._structure:
return None
e = Link(v, w, element)
self._structure[v][w] = e
self._structure[w][v] = e
return e
