def __init__(self, host, login,password):
self.__jslocation__="j.sal.ciscoswitch"
R1 = Router(hostname=host, logfile='cisco.log')
login_cmd = 'telnet ' + host
login_expect = '#'#.format(hostname) #@TODO NEEDS TO BE ADJUSTED
out = R1.login(login_cmd, login, password, login_expect)
# if out != R1._LOGIN_USERNAME_PROMPTS:
# R1.logout()
# time.sleep(60)
# R1 = Router(hostname, logfile='cisco.log')
# password = Localhost1.get_rsa_token()
# out = R1.login(login_cmd, login, password, login_expect)
self.cisco=R1
self.host=host
self.login=login
self.password=password
# if res != True: #adjust to check @TODO
# raise j.exceptions.RuntimeError("Could not login into cisco switch: %s"%host)
# inputsentence = []
cmd="terminal length 0"
self.do(cmd)
self.do("configure terminal","#")
self.do("hostname %s"%host,"#")
self.do("exit")
def __init__(self, request, client_address, server):
get_routes = [
{'url': '/api/?$', 'controller': 'HomeController', 'action': 'getApi'},
{'url': '/api/books/?$', 'controller': 'BooksController', 'action': 'getBooks'},
{'url': '/api/books/([1-9]+d*)$', 'controller': 'BooksController', 'action': 'getBook'}
]
post_routes = [
{'url': '/api/books/([1-9]+d*)$', 'controller': 'BooksController', 'action': 'postBook'}
]
put_routes = [
{'url': '/api/books/?$', 'controller': 'BooksController', 'action': 'putBook'}
]
delete_routes = [
{'url': '/api/books/([1-9]+d*)$', 'controller': 'BooksController', 'action': 'deleteBook'}
]
self.router = Router(self)
for route in get_routes:
self.router.addGetRoute(route['url'], route['controller'], route['action'])
for route in post_routes:
self.router.addPostRoute(route['url'], route['controller'], route['action'])
for route in put_routes:
self.router.addPutRoute(route['url'], route['controller'], route['action'])
for route in delete_routes:
self.router.addDeleteRoute(route['url'], route['controller'], route['action'])
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self,channel,startThread=False,portNumber=POLLING_SERVER_DEFAULT_PORT,hostname='localhost') :
Router.__init__(self,channel)
if (SocketRouter.acceptIncomingConnections) :
from comm import Comm
self.myComm = Comm()
self.incomingTCP = Queue()
# Variables for the state of the polling process
self.setRunning(startThread)
self.socketServer = None
# Variables used to keep track of the data.
self.incomingDataList = Queue()
self.dataLock = threading.Lock()
# Initialize the port number to use
self.setPort(portNumber);
self.setHostname(hostname) #socket.gethostname())
if(startThread) :
if(SocketRouter.DEBUG) :
print("Starting socket server")
self.createAndInitializeSocket()
def setUp(self):
self.autoseed = random.randint(0, 9999999999)
self.seed = self.RAND_SEED
if not self.seed:
self.seed = self.autoseed
self.myRandom = random.Random(self.seed)
self.peer_controller = None
self.peers = [
self.create_peer("P%d" % i, "127.0.0.1", 8500 + i)
for i in range(self.NO_OF_PEERS)
]
self.peer_controller = PeerController(self.peers,
self.WORLD_SIZE,
self.TOP_SPEED,
self.MAX_SPEED_CHANGE,
self.RADIO_RANGE,
rand_seed=self.seed)
#Start router
self.router = Router("127.0.0.1", 8300, self.peers,
self.peer_controller, self.USE_TICKS)
self.router.start()
self.ensure_peers_ready(self.peers)
self.router.activate_queue()
if self.VISUALIZE:
self.visualizer = Visualizer(self.peers, self.peer_controller)
self.visualizer.visualize()
def __init__(self, host, login,password):
R1 = Router(hostname=host, logfile='cisco.log')
login_cmd = 'telnet ' + host
login_expect = '#'#.format(hostname) #@TODO NEEDS TO BE ADJUSTED
out = R1.login(login_cmd, login, password, login_expect)
# if out != R1._LOGIN_USERNAME_PROMPTS:
# R1.logout()
# time.sleep(60)
# R1 = Router(hostname, logfile='cisco.log')
# password = Localhost1.get_rsa_token()
# out = R1.login(login_cmd, login, password, login_expect)
self.cisco=R1
self.host=host
self.login=login
self.password=password
# if res != True: #adjust to check @TODO
# raise j.exceptions.RuntimeError("Could not login into cisco switch: %s"%host)
# inputsentence = []
cmd="terminal length 0"
self.do(cmd)
self.do("configure terminal","#")
self.do("hostname %s"%host,"#")
self.do("exit")
def mkDevice(screen, x, y, id):
if id.isdigit():
subnet = Subnet(screen, x, y)
subnet.IP = IP(int(id))
return subnet
elif id == "N":
dns = DNS(screen, x, y)
dns.IP = str(ord(list(id)[0]))
return dns
elif id.isupper():
router = Router(screen, x, y)
router.IP = str(ord(list(id)[0]))
router.selected = router.IP == "66"
return router
elif id.islower():
if id == "h":
host = Client(screen, x, y)
host.name = "Alice"
host.corespondent = "Bob"
elif id == "x":
host = Client(screen, x, y)
host.name = "Bob"
host.corespondent = "Alice"
else:
host = Host(screen, x ,y)
host.IP = str(ord(list(id)[0]))
return host
else:
print "Unrecognized unique identifier in sprite map"
return None
def application(environ, start_response):
router = Router(environ)
status, response_headers, content = router.routing()
start_response(status, response_headers)
return [content]
def __init__ (self, screen, x, y):
Router.__init__(self, screen, x, y)
self.color = (191, 96, 96)
self.packetColor = (191, 128, 128)
self.font = pygame.font.Font(None, 24)
self.names = {}
def dataPengurus():
print("====AKSES DATA PENGURUS====")
fitur = template()
view1 = Router(fitur)
if 1 <= fitur <= 5:
view1.pengurus()
dataPengurus()
else:
print("Akses data tidak ditemukan!!!")
def dataUstadz():
print("====AKSES DATA USTADZ====")
fitur = template()
view1 = Router(fitur)
if 1 <= fitur <= 5:
view1.ustadz()
dataUstadz()
else:
print("Akses data Tidak Ditemukan!!!")
def dataPengumuan():
print("====AKSES DATA ABSEN====")
fitur = template()
view1 = Router(fitur)
if 1 <= fitur <= 5:
view1.pengumuman()
dataPengumuan()
else:
print("Akses data tidak ditemukan!!!")
def dataJagaPos():
print("====AKSES DATA JAGA POS====")
fitur = template()
view1 = Router(fitur)
if 1 <= fitur <= 5:
view1.jagapost()
dataJagaPos()
else:
print("Akses data Tidak Ditemukan!!!")
def dataTransaksi():
print("""====AKSES DATA TRANSAKSI====""")
fitur = template()
view1 = Router(fitur)
if 1 <= fitur <= 5:
view1.transaksi()
dataTransaksi()
else:
print("Akses data Tidak Ditemukan!!!")
def dataSantri():
print("====AKSES DATA SANTRI====")
fitur = template()
view1 = Router(fitur)
if 1 <= fitur <= 5:
view1.santri()
dataSantri()
else:
print("Akses data Tidak Ditemukan!!!")
def test_route_for_address(self):
routes = [Route(Network(IPv4Address('0.0.0.0'), 0), '192.168.0.1', 'en0', 10)]
routes.append(Route(Network(IPv4Address('192.168.0.0'), 24), None, 'en0', 10))
routes.append(Route(Network(IPv4Address('10.0.0.0'), 8), '10.123.0.1', 'en1', 10))
routes.append(Route(Network(IPv4Address('10.123.0.0'), 20), None, 'en1', 100))
routes.append(Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en2', 101))
routes.append(Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en3', 102))
routes.append(Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en4', 103))
router = Router(routes)
self.assertEqual(str(router.route_for_address(IPv4Address('10.123.1.1'))),
'net: 10.123.1.0/24, interface: en2, metric: 101')
def init(loop):
#去掉：logger_factory
app = web.Application(loop=loop, middlewares=[
response_factory
])
router=Router()
init_jinja2(app, filters=dict(datetime=datetime_filter))
app.router.add_static('/Content/',path='../Content/',name='Content')
app.router.add_static('/Scripts/',path='../Scripts/',name='Scripts')
router.add_routes(app, 'Controller')
srv = yield from loop.create_server(app.make_handler(), '127.0.0.1', 9000)
logging.info('server started at http://127.0.0.1:9000...')
return srv
def simpleTest():
radix = 4
M = (2, 2, 4)
algo = "Optimal"
numL2Failure = 0
numL1Failure = 0
numLinkFailure = 1
router = Router(radix)
wiring = load_Wiring(M, algo)
etms = load_ETM(M)
l2fp = set(["c" + str(ci) for ci in range(numL2Failure)])
print("L2 FPS:", l2fp)
l1fps = getL1FP(wiring, numL1Failure)
print("L1 FPS:", l1fps)
linkfps = load_RepLinkFP(M, numLinkFailure, algo)
print("Link FPS:", linkfps)
for l1fp in l1fps:
for linkfp in linkfps:
router.setL2Failure(l2fp)
router.setL1Failure(l1fp)
router.setLinkFailure(linkfp)
scenario = {"router": router, "wiring": wiring, "M": M}
beta = verificationRouter(scenario)
print("Beta =", beta, ": L2-FP =", l2fp, ", L1-FP =", l1fp,
", LK-FP =", linkfp)
def test_showinterfaces2(self):
r2 = Router('Cisco', '3745', 'R2')
r2.add_inf('Gigabit 0/1')
r2.add_inf('Gigabit 0/2')
r2.add_inf('Gigabit 0/3')
self.assertIn('Gigabit 0/1', r2.show_infs())
self.assertIn('Gigabit 0/2', r2.show_infs())
self.assertIn('Gigabit 0/3', r2.show_infs())
self.assertEqual(len(r2.interfaces), 3)
self.assertEqual(
'Show interfaces of R2\nR2 has 3 Interfaces\nGigabit 0/1\nGigabit 0/2\nGigabit 0/3\n',
r2.show_infs())
def createCase5(self):
self.element1=Host(300,200,0,0)
self.element2=Host(1000,200,0,0)
self.element3=Router(650,200,0,0)
self.element4=Host(650,400,0,0)
self.Bus1=Bus(300,205,1000,205)
self.Bus2=Bus(660,200,660,400)
def test_remove_route(self):
routes = [Route(Network(IPv4Address('10.123.1.0'), 24), '192.168.0.1', 'en0', 10),
Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en0', 10),
Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en0', 100)]
router = Router(routes)
router.routes.remove(Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en0', 100))
self.assertEqual(len(router.routes), 2)
def test_connect(self):
r1 = Router('Cisco', 'IOSv', 'R1')
r2 = Router('Cisco', '3745', 'R2')
r3 = Router('Juniper', 'MX5', 'R3')
r1.add_inf('Gigabit 0/1')
r1.add_inf('Gigabit 0/2')
r1.connect('Gigabit 0/1', r2, 'Gigabit 0/2')
r1.connect('Gigabit 0/2', r3, 'Gigabit 0/1')
self.assertEqual(
r1.show_cdp(), r1.hostname + ' interface Gigabit 0/1 connect to ' +
r2.hostname + ' on interface Gigabit 0/2\n' + r1.hostname +
' interface Gigabit 0/2 connect to ' + r3.hostname +
' on interface Gigabit 0/1\n')
def test_add_route(self):
routes = [Route(Network(IPv4Address('10.123.1.0'), 24), '192.168.0.1', 'en0', 10),
Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en0', 10)]
router = Router(routes)
routes_quantity = len(router.routes)
router.routes.append(Route(Network(IPv4Address('10.123.1.0'), 24), None, 'en0', 10))
routes_quantity2 = len(router.routes)
self.assertEqual(routes_quantity2, routes_quantity+1)
def get_reply_message(sender_id, user_message):
from Router import Router
router = Router()
reply = 'Try one of those:\n ' + '\n'.join(router.get_available_plugins())
try:
message = user_message["message"]["text"].lower()
plugin, initiated = router.get_plugin(message, sender_id)
if plugin:
if not initiated:
reply = plugin.get_help_message()
else:
reply = plugin.get_response(message)
elif message == 'exit':
reply = 'See you later!'
except KeyError:
log(user_message)
return reply
def __init__(self, hw_config):
self.router_array = []
self.rt_h = hw_config.Router_num_y
self.rt_w = hw_config.Router_num_x
for h in range(self.rt_h):
self.router_array.append([])
for w in range(self.rt_w):
self.router_array[h].append(Router(h, w))
self.busy_router = set()
def MenuUstadz():
print("""
1. Absen mengajar
2. Lihat Pengumuman
3. Lihat Jadwal Sendiri
4. Lihat Jadwal Semua
5. Logout
""")
inputFitur = int(
input("Masukkan angka untuk menggunakna fitur yang ada: "))
router = Router(inputFitur)
if 1 <= inputFitur <= 4:
router.viewUstadz()
elif inputFitur == 5:
main()
else:
print("Akses Data Tidak Ditemukan!!!")
exit()
def redoc(self, path):
"""
Customize the redoc-ui path. Defaults is <code>/redoc</code>.
@param path Redoc path.
@return This module.
"""
self.__redocPath = Router.normalizePath(path)
return self
def swaggerUI(self, path):
"""
Customize the swagger-ui path. Defaults is <code>/swagger</code>.
@param path Swagger-ui path.
@return This module.
"""
self.__swaggerUIPath = Router.normalizePath(path)
return self
def test_showinterfaces(self):
r1 = r1 = Router('Cisco', 'IOSv', 'R1')
r1.add_inf('Gigabit 0/1')
r1.add_inf('Gigabit 0/2')
self.assertIn('Gigabit 0/1', r1.show_infs())
self.assertIn('Gigabit 0/2', r1.show_infs())
self.assertEqual(len(r1.interfaces), 2)
self.assertEqual(
'Show interfaces of R1\nR1 has 2 Interfaces\nGigabit 0/1\nGigabit 0/2\n',
r1.show_infs())
def add_router(self):
'''
@param: name, string
@param: interfaces, set of Interface objects
'''
_name = self.router_name_entry.get()
_interfaces = self.interfaces_list
_router = Router(_name, _interfaces)
self.devices.append(_router)
self.router_window.destroy()
def build_routers(self):
with open(self.config) as config:
topo = json.load(config)
for router in topo:
r = Router(router)
self.routers[r.id] = r
r_name = r.name
child = pexpect.spawn('sudo ../connect_to.sh ' + self.topo +
' ' + r_name)
child.expect('bash-4.3#')
child.sendline('ifconfig lo')
child.expect('bash-4.3#')
output = child.before.decode('utf-8')
child.sendline('exit')
# Split the result to filter the loopback address
splited = output.split()
for s in splited:
if 'fde4:8' in s:
r.set_loopback(s.replace('/128', ''))
break
def __init__(self, config_file, topo_folder):
self.routers = {}
self.topo = topo_folder
with open(config_file) as config:
topo = json.load(config)
for router in topo:
r = Router(router)
self.routers[r.id] = r
r_name = r.name
child = pexpect.spawn('sudo ../connect_to.sh ' + self.topo + ' ' + r_name)
child.expect("bash-4.3#")
child.sendline('ifconfig lo')
child.expect("bash-4.3#")
output = child.before.decode("utf-8")
# Split the result to filter the loopback address
splited = output.split()
for s in splited:
if "fde4:8" in s:
r.set_loopback(s.replace('/128', ''))
break
def viewSantri():
while (True):
print("""
1. Bayar SPP
2. Absen Jaga Pos
3. Absen Ngaji
4. Lihat password
5. Ganti Password
6. Lihat jadwal mengaji
7. lihat pengumuman
8. Logout
""")
inputFitur = int(input("Masukkan Angka Akses Data Pilihan: "))
router = Router(inputFitur)
if 1 <= inputFitur <= 7:
router.viewSantri()
elif inputFitur == 8:
main()
else:
print("Akses Data Tidak Ditemukan!!!")
exit()
def test_showinterfaces3(self):
r3 = Router('Juniper', 'MX5', 'R3')
r3.add_inf('Gigabit 0/1')
self.assertIn('Gigabit 0/1', r3.show_infs())
self.assertEqual(
'Show interfaces of R3\nR3 has 1 Interfaces\nGigabit 0/1\n',
r3.show_infs())
def __init__(self):
# Basic setup
self.__basepath = os.path.dirname( os.path.realpath(os.path.realpath( __file__ ) + '/../../' ) )
self.__router = Router()
# Load container
self.__container = self._create_container()
# Setup logging
if self.__container.has_service('log.handler'):
self.__log_handler = self.__container.get_service('log.handler')
else:
self.__log_handler = NullHandler()
self.__log_handler.push_thread()
self.__logger = Logger('MiniMVC')
self.__container.set_param('sys.log', self.__logger)
# Import application
sys.path.append(self.__basepath)
import app
self.__logger.info('Kernel started')
def _handle_request(self, user_message_text, type_user_message, user):
answer_maker = Router.get_answer_maker(
user_message_text=user_message_text,
session_with_db=self.session,
user=user,
type_user_message=type_user_message)
logging.info('Answer maker is: %s', answer_maker)
data_for_answer = answer_maker.get_answer()
logging.info('Data for answer from answer maker: %s', data_for_answer)
text_answer = TelegramView.make_text_answer_from_data(data_for_answer)
logging.debug('Text for answer: %s', text_answer)
buttons_answer = TelegramView.get_buttons_for_message(data_for_answer)
message_buttons = TelegramView.make_message_buttons(data_for_answer)
image_preview = TelegramView.is_not_allowed_images_preview(
data_for_answer)
return text_answer, buttons_answer, message_buttons, image_preview
def setUp(self):
self.autoseed = random.randint(0, 9999999999)
self.seed = self.RAND_SEED
if not self.seed:
self.seed = self.autoseed
self.myRandom = random.Random(self.seed)
self.peer_controller = None
self.peers = [self.create_peer("P%d" % i, "127.0.0.1", 8500 + i) for i in range(self.NO_OF_PEERS)]
self.peer_controller = PeerController(
self.peers, self.WORLD_SIZE, self.TOP_SPEED, self.MAX_SPEED_CHANGE, self.RADIO_RANGE, rand_seed=self.seed
)
# Start router
self.router = Router("127.0.0.1", 8300, self.peers, self.peer_controller, self.USE_TICKS)
self.router.start()
self.ensure_peers_ready(self.peers)
self.router.activate_queue()
if self.VISUALIZE:
self.visualizer = Visualizer(self.peers, self.peer_controller)
self.visualizer.visualize()
class P2PTestCase(unittest.TestCase):
NO_OF_PEERS = 1
VISUALIZE = False
# Simulation params
TOP_SPEED = 140
MAX_SPEED_CHANGE = 50
RADIO_RANGE = 500
WORLD_SIZE = {"width": 2000, "height": 2000} # in centimeters
USE_TICKS = False
CLOCK_SYNC = False
MANUAL_OVERRIDE = True
RAND_SEED = None
def setUp(self):
self.autoseed = random.randint(0, 9999999999)
self.seed = self.RAND_SEED
if not self.seed:
self.seed = self.autoseed
self.myRandom = random.Random(self.seed)
self.peer_controller = None
self.peers = [self.create_peer("P%d" % i, "127.0.0.1", 8500 + i) for i in range(self.NO_OF_PEERS)]
self.peer_controller = PeerController(
self.peers, self.WORLD_SIZE, self.TOP_SPEED, self.MAX_SPEED_CHANGE, self.RADIO_RANGE, rand_seed=self.seed
)
# Start router
self.router = Router("127.0.0.1", 8300, self.peers, self.peer_controller, self.USE_TICKS)
self.router.start()
self.ensure_peers_ready(self.peers)
self.router.activate_queue()
if self.VISUALIZE:
self.visualizer = Visualizer(self.peers, self.peer_controller)
self.visualizer.visualize()
def tearDown(self):
for peer in self.peers:
peer.kill()
self.router.shutdown()
# print("SEED: " + str(self.seed))
def tick(self, num_msgs=1):
self.router.tick(num_msgs)
def wait_nw_idle(self):
self.router.wait_queue_empty()
def assertContains(self, msg, msg_part):
try:
self.assertTrue(msg_part in msg)
except AssertionError:
raise AssertionError("Msg: %s does not contain %s" % (msg, msg_part))
def assertNotContains(self, msg, msg_part):
try:
self.assertFalse(msg_part in msg)
except AssertionError:
raise AssertionError("Msg: %s does contain %s" % (msg, msg_part))
def create_peer(self, name, host, port):
peer = PeerHandler(name, host, port, self.MANUAL_OVERRIDE, self.CLOCK_SYNC)
if self.peer_controller: # Not set on first setup
peer.setLocation(self.peer_controller.generateNewPeerLocation())
peer.setPeerController(self.peer_controller)
if peer.process.returncode is not None:
raise Exception("Peer " + peer.name + " quit immediately ")
return peer
def ensure_peers_ready(self, peers):
for peer in peers:
peer.expect_ready(20)
def has_song_with_votes_in_playlist(self, playlist, song):
for playlistitem in playlist:
if playlistitem["song_name"] == song:
if len(playlistitem["votes"]) > 0:
return True
return False
return False
def assert_song_in_playlist(self, playlist, song):
self.assertTrue(
self.has_song_with_votes_in_playlist(playlist, song), "Song " + song + " was expected in playlist"
)
def __init__ (self, screen, x, y):
Router.__init__(self, screen, x, y)
self.selectable = False
# coding=utf-8
from Router import Router
import time
import logging
import commands
logging.basicConfig(
level=logging.WARNING,
format='%(asctime)s\t%(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename='ipchange.log',
filemode='w'
)
router = Router('TPLINK_WR842N', passwd="WaQ7x7448oefbwK")
ip4nginx = now_valid_ip = None
while True:
if router.is_private_ip():
logging.error('ip(%s) is private ip, now to reconnect.' % router.get_ip())
router.reconnect()
else:
now_valid_ip = router.get_ip()
if now_valid_ip != ip4nginx:
logging.warning('update nginx(%s) to new valid ip(%s)' % (ip4nginx, now_valid_ip))
status, info = commands.getstatusoutput("ssh [email protected] 'cd /home/env; python reload_nginx.py %s'" % now_valid_ip)
if status == 0:
logging.warning('nginx proxy ip now changed')
ip4nginx = now_valid_ip
else:
logging.error('nginx proxy ip change failed')
class Kernel(object):
def __init__(self):
# Basic setup
self.__basepath = os.path.dirname( os.path.realpath(os.path.realpath( __file__ ) + '/../../' ) )
self.__router = Router()
# Load container
self.__container = self._create_container()
# Setup logging
if self.__container.has_service('log.handler'):
self.__log_handler = self.__container.get_service('log.handler')
else:
self.__log_handler = NullHandler()
self.__log_handler.push_thread()
self.__logger = Logger('MiniMVC')
self.__container.set_param('sys.log', self.__logger)
# Import application
sys.path.append(self.__basepath)
import app
self.__logger.info('Kernel started')
def run(self, request):
query_string = request.unparsed_uri
self.__logger.info('Request: ' + query_string)
route = self.__router.route(query_string)
if route:
self.__logger.info('Route matched: %s.%s(%s)' % (route['controller'], route['action'], route['params']))
self.__container.set_param('sys.matched_route', route)
request.parameters = route['params']
res = ObjectFactory.instantiate_and_call(route['controller'], [self.__container], route['action'], request)
else:
self.__logger.warn('No matching route found for: ' + query_string)
res = False
# Shutdown logger and return
self.__log_handler.pop_thread()
# Return the local request log
self.request_log = self.__container.get_service('log.test_handler').records
return res
def _create_container(self):
container = ServiceContainer()
container.set_param('sys.kernel', self)
container.set_param('sys.container', container)
container.set_param('sys.basepath', self.__basepath)
container.set_param('sys.router', self.__router)
#container.set_param('sys.log', self.__logger)
loader = ServiceContainerLoader()
loader.register_section_loader(DatabaseSectionLoader())
loader.register_section_loader(ServicesSectionLoader())
loader.register_section_loader(RoutesSectionLoader())
loader.load(container, self.__basepath + '/app/config/config.yml')
return container
def __str__(self):
return "MiniMVC.Kernel"
@property
def container(self):
return self.__container
class Palette():
def __init__(self):
self.case1=None
self.case2=None
self.case3=None
self.case4=None
self.case5=None
self.element1=None
self.element2=None
self.element3=None
self.element4=None
self.button_exit=None
self.button_next=None
self.Bus1=None
self.Bus2=None
self.case11=pygame.image.load("Images/Case1.1.jpg")
self.case12=pygame.image.load("Images/Case1.2.jpg")
self.case21=pygame.image.load("Images/Case2.1.jpg")
self.case22=pygame.image.load("Images/Case2.2.jpg")
self.case31=pygame.image.load("Images/Case3.1.jpg")
self.case32=pygame.image.load("Images/Case3.2.jpg")
self.case41=pygame.image.load("Images/Case4.1.jpg")
self.case42=pygame.image.load("Images/Case4.2.jpg")
self.case51=pygame.image.load("Images/Case5.1.jpg")
self.case52=pygame.image.load("Images/Case5.2.jpg")
self.exit1=pygame.image.load("Images/button_exit1.jpg")
self.exit2=pygame.image.load("Images/button_exit2.jpg")
self.next1=pygame.image.load("Images/button_next1.jpg")
self.next2=pygame.image.load("Images/button_next2.jpg")
self.createPalette()
self.display=pygame.display.get_surface()
def updatePalette(self):
x,y=pygame.mouse.get_pos()
if(self.case1.rect.collidepoint(x,y)):
self.case1.image=self.case12
else:
self.case1.image=self.case11
if(self.case2.rect.collidepoint(x,y)):
self.case2.image=self.case22
else:
self.case2.image=self.case21
if(self.case3.rect.collidepoint(x,y)):
self.case3.image=self.case32
else:
self.case3.image=self.case31
if(self.case4.rect.collidepoint(x,y)):
self.case4.image=self.case42
else:
self.case4.image=self.case41
if(self.case5.rect.collidepoint(x,y)):
self.case5.image=self.case52
else:
self.case5.image=self.case51
if(self.button_exit.rect.collidepoint(x,y)):
self.button_exit.image=self.exit2
else:
self.button_exit.image=self.exit1
if(self.button_next.rect.collidepoint(x,y)):
self.button_next.image=self.next2
else:
self.button_next.image=self.next1
self.display.blit(self.case1.image,self.case1.rect)
self.display.blit(self.case2.image,self.case2.rect)
self.display.blit(self.case3.image,self.case3.rect)
self.display.blit(self.case4.image,self.case4.rect)
self.display.blit(self.case5.image,self.case5.rect)
self.display.blit(self.button_exit.image,self.button_exit.rect)
self.display.blit(self.button_next.image,self.button_next.rect)
rect=pygame.Rect(160, 0, 10,1000)
pygame.draw.rect(self.display,(220,0,0),rect,0)
myfont = pygame.font.SysFont("LCD", 75)
label = myfont.render("ARP SIMULATOR", 1,(220,0,0))
self.display.blit(label, (500, 15))
def createCase1(self):
self.element1=Host(300,200,0,0)
self.element2=Host(900,200,0,0)
self.Bus1=Bus(300,205,900,205)
#self.arp_request.rect.left,self.arp_request.rect.top=300,200
def createCase2(self):
self.element1=Host(300,200,0,0)
self.element2=Router(900,200,0,0)
self.Bus1=Bus(300,205,900,205)
def createCase3(self):
self.element1=Router(300,200,0,0)
self.element2=Router(900,200,0,0)
self.Bus1=Bus(300,205,900,205)
def createCase4(self):
self.element1=Router(300,200,0,0)
self.element2=Host(900,200,0,0)
self.Bus1=Bus(300,205,900,205)
def createCase5(self):
self.element1=Host(300,200,0,0)
self.element2=Host(1000,200,0,0)
self.element3=Router(650,200,0,0)
self.element4=Host(650,400,0,0)
self.Bus1=Bus(300,205,1000,205)
self.Bus2=Bus(660,200,660,400)
def update(self,screen):
self.Bus1.drawpoint(screen)
self.element1.update(screen,1)
self.element2.update(screen,1)
def update5(self,screen):
self.Bus1.drawpoint(screen)
self.Bus2.drawpoint(screen)
self.element1.update(screen,1)
self.element2.update(screen,1)
self.element3.update(screen,1)
self.element4.update(screen,1)
def createSprite(self,x,y,adr):
s1 = pygame.sprite.Sprite()
s1.image = pygame.image.load(adr).convert_alpha()
s1.rect = s1.image.get_rect()
(s1.rect.left, s1.rect.top) = (x,y)
return s1
def createPalette(self):
self.case1=self.createSprite(10,40,"Images/Case1.1.jpg")
self.case2=self.createSprite(self.case1.rect.left,self.case1.rect.bottom+20,"Images/Case2.1.jpg")
self.case3=self.createSprite(self.case2.rect.left,self.case2.rect.bottom+20,"Images/Case3.1.jpg")
self.case4=self.createSprite(self.case3.rect.left,self.case3.rect.bottom+20,"Images/Case4.1.jpg")
self.case5=self.createSprite(self.case4.rect.left,self.case4.rect.bottom+20,"Images/Case5.1.jpg")
self.button_exit=self.createSprite(1200, 5,"Images/button_exit1.jpg")
self.button_next=self.createSprite(1200, 670,"Images/button_next1.jpg")
def ARPDesign(self,screen):
c1 = pygame.time.Clock()
Case1Pressed=False
Case2Pressed=False
Case3Pressed=False
Case4Pressed=False
Case5Pressed=False
flag=True
while True and flag:
for events in pygame.event.get():
if events.type == pygame.QUIT:
quit()
if events.type == pygame.MOUSEBUTTONDOWN:
x,y=pygame.mouse.get_pos()
if(self.case1.rect.collidepoint(x,y) and not(Case1Pressed)):
Case1Pressed=True
Case2Pressed=False
Case3Pressed=False
Case4Pressed=False
Case5Pressed=False
self.createCase1()
if(self.case2.rect.collidepoint(x,y)):
Case1Pressed=False
Case2Pressed=True
Case3Pressed=False
Case4Pressed=False
Case5Pressed=False
self.createCase2()
if(self.case3.rect.collidepoint(x,y)):
Case1Pressed=False
Case2Pressed=False
Case3Pressed=True
Case4Pressed=False
Case5Pressed=False
self.createCase3()
if(self.case4.rect.collidepoint(x,y)):
Case1Pressed=False
Case2Pressed=False
Case3Pressed=False
Case4Pressed=True
Case5Pressed=False
self.createCase4()
if(self.case5.rect.collidepoint(x,y)):
Case1Pressed=False
Case2Pressed=False
Case3Pressed=False
Case4Pressed=False
Case5Pressed=True
self.createCase5()
if(self.button_next.rect.collidepoint(x,y)):
flag=False
if(self.button_exit.rect.collidepoint(x,y)):
flag=False
return 0
c1.tick(100)
screen.fill((255,255,255))
self.updatePalette()
if(Case1Pressed or Case2Pressed or Case3Pressed or Case4Pressed):
self.update(screen)
if(Case5Pressed):
self.update5(screen)
pygame.display.update()
if(Case1Pressed):
return 1
if(Case2Pressed):
return 2
if(Case3Pressed):
return 3
if(Case4Pressed):
return 4
if(Case5Pressed):
return 5
