├── progjar0 ├── test.ber ├── requirements.txt ├── person1.simpan ├── person1.csv ├── orang.yaml ├── person1.json ├── orang.xml ├── test.asn └── serialize.py ├── progjar9 ├── .gitignore ├── requirements.txt ├── images │ ├── cyan.png │ ├── pink.png │ └── red.png ├── client2 │ ├── p1 │ │ ├── tank_up.png │ │ ├── tank_down.png │ │ ├── tank_left.png │ │ └── tank_right.png │ ├── p2 │ │ ├── tank_up.png │ │ ├── tank_down.png │ │ ├── tank_left.png │ │ └── tank_right.png │ ├── tank_nonet.py │ ├── tank_multi_player1.py │ └── tank_multi_player2.py ├── protocol.py ├── logic.py ├── server.py ├── logic_v2.py ├── client1 │ └── play_nonet.py └── client3 │ └── pac.py ├── environment-demo ├── .gitignore ├── app │ ├── server │ │ ├── requirements.txt │ │ ├── server.py │ │ └── chat.py │ ├── client │ │ ├── requirements.txt │ │ ├── chat-flet.py │ │ └── chatcli.py │ └── client-desktop │ │ ├── README.MD │ │ └── run.sh ├── README.MD └── docker-compose.yml ├── environment ├── .gitignore ├── docker-compose.yml └── README.MD ├── progjar5 ├── testing.txt ├── pokijan.jpg ├── rfc2616.pdf ├── donalbebek.jpg ├── research_center.jpg ├── page.html ├── sending.html ├── resources.txt ├── perftest.sh ├── certs │ ├── generate.txt │ ├── domain.crt │ └── domain.key ├── client │ ├── domain.crt │ └── client.py ├── server_asyncio_stream_http.py ├── server_async_http.py ├── socket_proxy.py ├── server_thread_http.py ├── server_process_http.py ├── server_process_pool_http.py ├── server_thread_pool_http.py ├── server_thread_http_secure.py └── http.py ├── progjar1a ├── requirements.txt ├── server_side │ ├── certs │ │ ├── san.conf │ │ ├── generate.txt │ │ ├── domain.crt │ │ └── domain.key │ └── tcp_server.py ├── client_side │ ├── domain.crt │ └── tcp_client.py ├── insecure_proxy.py └── insecure_proxy_2.py ├── .gitignore ├── progjar2 ├── bart.png ├── dns.py ├── udp_simple.py ├── struct.py ├── udp_telemetry_collector.py ├── udpclient.py ├── udpserver.py ├── udp_telemetry_sensor.py ├── udp_time_server.py ├── udp_time_client.py ├── udpfileclient.py ├── udpfileserver.py ├── udpserver_broadcast.py ├── udpclient_broadcast.py └── dns2.py ├── progjar6 ├── pokijan.jpg ├── research_center.jpg ├── page.html ├── runserver.sh ├── async_server.py ├── server_process_pool_http.py ├── lb_async.py ├── lb_process.py └── http.py ├── progjar7 ├── pokijan.jpg ├── research_center.jpg ├── page.html ├── stream_echo_client.py ├── stream_echo_server.py ├── stream_async_http.py └── http.py ├── progjar4a ├── files │ ├── pokijan.jpg │ ├── rfc2616.pdf │ └── donalbebek.jpg ├── file_interface.py ├── PROTOKOL.txt ├── file_protocol.py ├── file_server.py └── file_client_cli.py ├── README.md ├── progjar3 ├── threading_examples │ ├── old │ │ └── test_decorator.py │ ├── async_server.py │ ├── thread1.py │ ├── thread3.py │ ├── thread2.py │ ├── thread22.py │ ├── thread4.py │ ├── client_1.py │ ├── server.py │ ├── server_thread.py │ ├── client_2.py │ ├── thread6.py │ ├── server_thread_echo.py │ ├── thread5.py │ └── server_thread_time.py ├── concurrency │ ├── single_thread.py │ ├── multi_process_pool.py │ ├── multi_thread_pool.py │ ├── multi_process.py │ ├── multi_thread.py │ ├── multi_thread_async.py │ ├── multi_process_async.py │ └── library.py └── concurrency_asyncio │ ├── multi_thread.py │ └── library.py ├── progjar1 ├── socket_info.py ├── client.py └── server.py ├── progjar4b ├── person.py ├── server_thread_person.py └── person_machine.py ├── progjar8 ├── domain.crt └── secure_client.py ├── progjar10 ├── paint_nonet.py ├── protocol.py ├── server.py └── logic.py └── progjar4c ├── chatserver ├── server_thread_chat.py ├── chat-cli.py └── chat.py └── irc-client ├── library.py ├── irc-session-example.test └── ircapp.py /progjar0/test.ber: -------------------------------------------------------------------------------- 1 | 0 Is 1+1=3? -------------------------------------------------------------------------------- /progjar9/.gitignore: -------------------------------------------------------------------------------- 1 | venv/ 2 | 3 | -------------------------------------------------------------------------------- /environment-demo/.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__ 2 | -------------------------------------------------------------------------------- /environment/.gitignore: -------------------------------------------------------------------------------- 1 | work*/* 2 | 3 | -------------------------------------------------------------------------------- /progjar5/testing.txt: -------------------------------------------------------------------------------- 1 | ini testing file 2 | 3 | -------------------------------------------------------------------------------- /progjar1a/requirements.txt: -------------------------------------------------------------------------------- 1 | dicttoxml 2 | xmltodict -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.pyc 2 | venv/ 3 | .idea/ 4 | .ipynb*/ 5 | -------------------------------------------------------------------------------- /progjar9/requirements.txt: -------------------------------------------------------------------------------- 1 | kivy 2 | pygame 3 | pgzero 4 | -------------------------------------------------------------------------------- /environment-demo/app/server/requirements.txt: -------------------------------------------------------------------------------- 1 | requests 2 | uuid 3 | -------------------------------------------------------------------------------- /environment-demo/app/client/requirements.txt: -------------------------------------------------------------------------------- 1 | requests 2 | uuid 3 | flet 4 | -------------------------------------------------------------------------------- /progjar0/requirements.txt: -------------------------------------------------------------------------------- 1 | dicttoxml 2 | xmltodict 3 | pyyaml 4 | asn1tools 5 | -------------------------------------------------------------------------------- /progjar2/bart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar2/bart.png -------------------------------------------------------------------------------- /progjar5/pokijan.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar5/pokijan.jpg -------------------------------------------------------------------------------- /progjar5/rfc2616.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar5/rfc2616.pdf -------------------------------------------------------------------------------- /progjar6/pokijan.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar6/pokijan.jpg -------------------------------------------------------------------------------- /progjar7/pokijan.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar7/pokijan.jpg -------------------------------------------------------------------------------- /progjar0/person1.simpan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar0/person1.simpan -------------------------------------------------------------------------------- /progjar2/dns.py: -------------------------------------------------------------------------------- 1 | import socket 2 | 3 | ip = socket.gethostbyname("www.its.ac.id") 4 | print(ip) -------------------------------------------------------------------------------- /progjar5/donalbebek.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar5/donalbebek.jpg -------------------------------------------------------------------------------- /progjar9/images/cyan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/images/cyan.png -------------------------------------------------------------------------------- /progjar9/images/pink.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/images/pink.png -------------------------------------------------------------------------------- /progjar9/images/red.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/images/red.png -------------------------------------------------------------------------------- /progjar0/person1.csv: -------------------------------------------------------------------------------- 1 | no_ktp,nama,tgl_lahir,tmp_lahir 2 | 4567,joao felix,24/03/2000,Mojokerto 3 | -------------------------------------------------------------------------------- /progjar4a/files/pokijan.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar4a/files/pokijan.jpg -------------------------------------------------------------------------------- /progjar4a/files/rfc2616.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar4a/files/rfc2616.pdf -------------------------------------------------------------------------------- /progjar4a/files/donalbebek.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar4a/files/donalbebek.jpg -------------------------------------------------------------------------------- /progjar5/research_center.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar5/research_center.jpg -------------------------------------------------------------------------------- /progjar6/research_center.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar6/research_center.jpg -------------------------------------------------------------------------------- /progjar7/research_center.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar7/research_center.jpg -------------------------------------------------------------------------------- /progjar0/orang.yaml: -------------------------------------------------------------------------------- 1 | nama: joao felix 2 | no_ktp: '4567' 3 | tgl_lahir: 24/03/2000 4 | tmp_lahir: Mojokerto 5 | -------------------------------------------------------------------------------- /progjar9/client2/p1/tank_up.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p1/tank_up.png -------------------------------------------------------------------------------- /progjar9/client2/p2/tank_up.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p2/tank_up.png -------------------------------------------------------------------------------- /progjar9/client2/p1/tank_down.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p1/tank_down.png -------------------------------------------------------------------------------- /progjar9/client2/p1/tank_left.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p1/tank_left.png -------------------------------------------------------------------------------- /progjar9/client2/p1/tank_right.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p1/tank_right.png -------------------------------------------------------------------------------- /progjar9/client2/p2/tank_down.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p2/tank_down.png -------------------------------------------------------------------------------- /progjar9/client2/p2/tank_left.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p2/tank_left.png -------------------------------------------------------------------------------- /progjar9/client2/p2/tank_right.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rm77/progjar/HEAD/progjar9/client2/p2/tank_right.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # progjar 2 | 3 | 4 | 5 | Untuk instalasi laboratorium, bacalah readme.txt di direktori environment 6 | 7 | -------------------------------------------------------------------------------- /progjar5/page.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /progjar6/page.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /progjar7/page.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /progjar0/person1.json: -------------------------------------------------------------------------------- 1 | { 2 | "no_ktp": "4567", 3 | "nama": "joao felix", 4 | "tgl_lahir": "24/03/2000", 5 | "tmp_lahir": "Mojokerto" 6 | } -------------------------------------------------------------------------------- /progjar5/sending.html: -------------------------------------------------------------------------------- 1 |
2 | 3 | 4 |
-------------------------------------------------------------------------------- /environment-demo/app/client-desktop/README.MD: -------------------------------------------------------------------------------- 1 | 2 | run using virtualenv & python 3 | 4 | virtualenv venv 5 | 6 | source venv/bin/activate 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /progjar0/orang.xml: -------------------------------------------------------------------------------- 1 | 4567joao felix24/03/2000Mojokerto -------------------------------------------------------------------------------- /progjar5/resources.txt: -------------------------------------------------------------------------------- 1 | 2 | HTTP Overview 3 | https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview 4 | 5 | HTTP points 6 | https://www.tutorialspoint.com/http/index.htm 7 | 8 | 9 | -------------------------------------------------------------------------------- /progjar6/runserver.sh: -------------------------------------------------------------------------------- 1 | #jalankan 5 async_server 2 | 3 | python3 async_server.py 9002 & 4 | python3 async_server.py 9003 & 5 | python3 async_server.py 9004 & 6 | python3 async_server.py 9005 & 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /progjar5/perftest.sh: -------------------------------------------------------------------------------- 1 | #ab -n jumlah_request -c jumlah_konkuren http://localhost:8887/testingab -n jumlah_request -c jumlah_konkuren http://localhost:8887/testing.txt 2 | 3 | 4 | ab -n 100 -c 50 http://localhost:8887/testing.txt 5 | 6 | -------------------------------------------------------------------------------- /environment-demo/app/client-desktop/run.sh: -------------------------------------------------------------------------------- 1 | SERVER_IP=127.0.0.1 2 | SERVER_PORT=8889 3 | export SERVER_IP SERVER_PORT 4 | virtualenv venv 5 | . ./venv/bin/activate 6 | pip3 install -r requirements.txt 7 | python3 chat-flet.py 8 | deactivate 9 | -------------------------------------------------------------------------------- /progjar2/udp_simple.py: -------------------------------------------------------------------------------- 1 | 2 | import socket 3 | 4 | TARGET_IP = "10.151.50.50" 5 | TARGET_PORT = 5006 6 | 7 | nama='informatika' 8 | 9 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 10 | sock.sendto(bytes(nama.encode()),(TARGET_IP,TARGET_PORT)) -------------------------------------------------------------------------------- /progjar0/test.asn: -------------------------------------------------------------------------------- 1 | Foo DEFINITIONS ::= BEGIN 2 | 3 | Question ::= SEQUENCE { 4 | id INTEGER, 5 | question IA5String 6 | } 7 | 8 | Answer ::= SEQUENCE { 9 | id INTEGER, 10 | answer BOOLEAN 11 | } 12 | 13 | END 14 | -------------------------------------------------------------------------------- /environment-demo/README.MD: -------------------------------------------------------------------------------- 1 | 2 | server 3 | - berjalan di port 8889 4 | - lokasi program ./app/server/server.py 5 | 6 | client 7 | - berjalan di mode web port 8550 8 | - lokasi program ./app/client/client-flet.py 9 | 10 | client desktop 11 | - cd ./app/client-desktop 12 | - sh run.sh 13 | 14 | 15 | -------------------------------------------------------------------------------- /progjar2/struct.py: -------------------------------------------------------------------------------- 1 | import struct 2 | 3 | magic = b'MAGC' # 4 bytes 4 | version = 1 # 1 byte 5 | length = 128 # 2 bytes (unsigned short) 6 | flags = 0b01010101 # 1 byte 7 | 8 | packet = struct.pack('!4sBHB', magic, version, length, flags) 9 | print(packet) 10 | 11 | -------------------------------------------------------------------------------- /progjar3/threading_examples/old/test_decorator.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | def coba(method): 4 | def coba(*args, **kw): 5 | result = method(*args, **kw) 6 | print(kw) 7 | print(args) 8 | return result 9 | return coba 10 | 11 | 12 | @coba 13 | def haha(x): 14 | return 2*10 15 | 16 | 17 | print(haha(2)) 18 | -------------------------------------------------------------------------------- /progjar3/threading_examples/async_server.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | async def handle_client(reader, writer): 3 | 4 | data = (await reader.read(1024)) 5 | 6 | writer.write(data) 7 | writer.close() 8 | 9 | 10 | loop = asyncio.get_event_loop() 11 | loop.create_task(asyncio.start_server(handle_client, 'localhost', 8001)) 12 | loop.run_forever() -------------------------------------------------------------------------------- /progjar2/udp_telemetry_collector.py: -------------------------------------------------------------------------------- 1 | import socket, struct 2 | 3 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 4 | sock.bind(('0.0.0.0', 50000)) 5 | 6 | while True: 7 | data, addr = sock.recvfrom(1024) 8 | sensor_id, temp, hum = struct.unpack('!Iff', data) 9 | print(f"Sensor {sensor_id} @ {addr} | Temp: {temp:.1f}°C | Humidity: {hum:.1f}%") 10 | 11 | -------------------------------------------------------------------------------- /progjar3/threading_examples/thread1.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import datetime 3 | import logging 4 | 5 | def worker(nomor): 6 | waktu = datetime.datetime.now() 7 | logging.warning(f"saya worker nomor {nomor}") 8 | return 9 | 10 | 11 | threads = [] 12 | for i in range(5): 13 | t = threading.Thread(target=worker,args=(i,)) 14 | t.start() 15 | 16 | 17 | -------------------------------------------------------------------------------- /progjar2/udpclient.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import time 3 | 4 | TARGET_IP = "127.0.0.1" 5 | TARGET_PORT = 5005 6 | 7 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 8 | angka = 0 9 | while True: 10 | angka = angka+1 11 | msg = " ini angka {} " . format(angka) 12 | print(msg) 13 | sock.sendto(msg.encode(), (TARGET_IP, TARGET_PORT)) 14 | time.sleep(1) 15 | 16 | -------------------------------------------------------------------------------- /progjar2/udpserver.py: -------------------------------------------------------------------------------- 1 | import socket 2 | 3 | 4 | SERVER_IP = '0.0.0.0' 5 | SERVER_PORT = 5005 6 | 7 | 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 9 | sock.bind((SERVER_IP, SERVER_PORT)) 10 | 11 | while True: 12 | data, addr = sock.recvfrom(1024) 13 | #buffer size 1024 14 | print("diterima ", data) 15 | print("dikirim oleh " , addr) 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /progjar1a/server_side/certs/san.conf: -------------------------------------------------------------------------------- 1 | [req] 2 | default_bits = 2048 3 | prompt = no 4 | default_md = sha256 5 | distinguished_name = dn 6 | req_extensions = req_ext 7 | 8 | [dn] 9 | CN = localhost 10 | 11 | [req_ext] 12 | subjectAltName = @alt_names 13 | 14 | [alt_names] 15 | DNS.1 = localhost 16 | IP.1 = 127.0.0.1 17 | DNS.2 = mydevhost.local 18 | IP.2 = 172.16.16.101 19 | IP.3 = 172.16.16.102 20 | IP.4 = 172.16.16.103 -------------------------------------------------------------------------------- /progjar2/udp_telemetry_sensor.py: -------------------------------------------------------------------------------- 1 | import socket, struct, random, time 2 | 3 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 4 | server = ('127.0.0.1', 50000) 5 | 6 | sensor_id = 42 7 | 8 | while True: 9 | temp = round(random.uniform(20.0, 35.0), 2) 10 | humidity = round(random.uniform(40.0, 80.0), 2) 11 | packed = struct.pack('!Iff', sensor_id, temp, humidity) 12 | sock.sendto(packed, server) 13 | time.sleep(2) 14 | 15 | -------------------------------------------------------------------------------- /progjar2/udp_time_server.py: -------------------------------------------------------------------------------- 1 | import socket, struct, time 2 | 3 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 4 | sock.bind(('0.0.0.0', 7070)) 5 | 6 | while True: 7 | data, addr = sock.recvfrom(1024) 8 | req_id, client_time = struct.unpack('!Id', data) 9 | print(f"Received from {addr}: ID {req_id}, Client time {client_time}") 10 | response = struct.pack('!Id', req_id, time.time()) 11 | sock.sendto(response, addr) 12 | 13 | -------------------------------------------------------------------------------- /progjar2/udp_time_client.py: -------------------------------------------------------------------------------- 1 | import socket, struct, time 2 | 3 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 4 | server = ('127.0.0.1', 7070) 5 | 6 | req_id = 1 7 | timestamp = time.time() 8 | msg = struct.pack('!Id', req_id, timestamp) 9 | sock.sendto(msg, server) 10 | 11 | data, _ = sock.recvfrom(1024) 12 | resp_id, server_time = struct.unpack('!Id', data) 13 | 14 | print(f"Response ID: {resp_id}, Server time: {server_time}") 15 | 16 | 17 | -------------------------------------------------------------------------------- /progjar2/udpfileclient.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import os 3 | 4 | TARGET_IP = "127.0.0.1" 5 | TARGET_PORT = 5005 6 | 7 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 8 | 9 | namafile="bart.png" 10 | ukuran = os.stat(namafile).st_size 11 | 12 | fp = open('bart.png','rb') 13 | k = fp.read() 14 | terkirim=0 15 | for x in k: 16 | k_bytes = bytes([x]) 17 | sock.sendto(k_bytes, (TARGET_IP, TARGET_PORT)) 18 | terkirim = terkirim + 1 19 | print(k_bytes,f"terkirim {terkirim} of {ukuran} ") 20 | -------------------------------------------------------------------------------- /progjar3/threading_examples/thread3.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | import datetime 4 | 5 | def worker(nomor): 6 | while True: 7 | waktu = datetime.datetime.now() 8 | print("{} Saya worker nomor {} \n".format(waktu, nomor)) 9 | time.sleep(1) 10 | return 11 | 12 | 13 | threads = [] 14 | for i in range(5): 15 | t = threading.Thread(target=worker,args=(i,)) 16 | threads.append(t) 17 | 18 | for thr in threads: 19 | thr.start() 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /progjar5/certs/generate.txt: -------------------------------------------------------------------------------- 1 | create private key and certificate 2 | openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout domain.key -out domain.crt 3 | 4 | -req: x509 CSR management (cert signing request) 5 | x509-> public key infrastructure standard 6 | -x509: self signed certificate 7 | -nodes: for server usage 8 | -days: expire in 365 days 9 | -newkey:2048 generate new certificate and newkey, using RSA 2048 bit 10 | -keyout: key file result 11 | -out: cert file result 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /progjar2/udpfileserver.py: -------------------------------------------------------------------------------- 1 | import socket 2 | 3 | 4 | SERVER_IP = '127.0.0.1' 5 | SERVER_PORT = 5005 6 | NAMAFILE='bart.png' 7 | 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 9 | sock.bind((SERVER_IP, SERVER_PORT)) 10 | 11 | fp = open(NAMAFILE,'wb+') 12 | ditulis=0 13 | 14 | counter=0 15 | while True: 16 | data, addr = sock.recvfrom(1024) 17 | counter=counter+len(data) 18 | print(addr," blok ", counter,"panjang : ",len(data), data) 19 | fp.write(data) 20 | 21 | 22 | fp.close() 23 | -------------------------------------------------------------------------------- /progjar2/udpserver_broadcast.py: -------------------------------------------------------------------------------- 1 | import socket 2 | 3 | 4 | SERVER_IP = '127.0.0.1' 5 | SERVER_PORT = 5005 6 | 7 | 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 9 | sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEPORT, 1) 10 | sock.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST, 1) 11 | 12 | sock.bind(("", SERVER_PORT)) 13 | 14 | 15 | 16 | while True: 17 | data, addr = sock.recvfrom(1024) 18 | #buffer size 1024 19 | print(addr) 20 | print("diterima ", data) 21 | print("dikirim oleh " , addr) -------------------------------------------------------------------------------- /progjar3/threading_examples/thread2.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | import datetime 4 | import logging 5 | 6 | def worker(nomor): 7 | counter = 0 8 | while True: 9 | counter = counter + 1 10 | waktu = datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%s") 11 | logging.warning(f"{waktu} saya adalah worker {nomor} counter {counter}") 12 | time.sleep(1) 13 | return 14 | 15 | 16 | for i in range(5): 17 | t = threading.Thread(target=worker,args=(i,)) 18 | t.start() 19 | 20 | 21 | -------------------------------------------------------------------------------- /progjar1a/server_side/certs/generate.txt: -------------------------------------------------------------------------------- 1 | create private key and certificate 2 | openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout domain.key -out domain.crt -config san.conf 3 | 4 | -req: x509 CSR management (cert signing request) 5 | x509-> public key infrastructure standard 6 | -x509: self signed certificate 7 | -nodes: for server usage 8 | -days: expire in 365 days 9 | -newkey:2048 generate new certificate and newkey, using RSA 2048 bit 10 | -keyout: key file result 11 | -out: cert file result 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /progjar2/udpclient_broadcast.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import time 3 | 4 | TARGET_IP = '255.255.255.255' 5 | TARGET_PORT = 5005 6 | 7 | 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 9 | sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEPORT, 1) 10 | sock.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST, 1) 11 | 12 | 13 | angka = 0 14 | while True: 15 | angka = angka+1 16 | msg = " BROADCAST ini angka {} " . format(angka) 17 | print(msg) 18 | sock.sendto(msg.encode(), ("255.255.255.255", TARGET_PORT)) 19 | # time.sleep(1) -------------------------------------------------------------------------------- /progjar3/concurrency/single_thread.py: -------------------------------------------------------------------------------- 1 | from library import download_gambar, get_url_list 2 | import time 3 | import datetime 4 | 5 | def download_semua(): 6 | urls = get_url_list() 7 | 8 | catat = datetime.datetime.now() 9 | for k in urls: 10 | print(f"mendownload {urls[k]}") 11 | waktu_proses = download_gambar(urls[k]) 12 | print(f"completed {waktu_proses} detik") 13 | selesai = datetime.datetime.now() - catat 14 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik") 15 | 16 | 17 | #fungsi download_gambar akan dijalankan secara berurutan 18 | 19 | if __name__=='__main__': 20 | download_semua() -------------------------------------------------------------------------------- /progjar7/stream_echo_client.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | async def tcp_echo_client(message): 4 | try: 5 | reader, writer = await asyncio.open_connection( 6 | '127.0.0.1', 10000) 7 | 8 | print(f'Send: {message!r}') 9 | writer.write(message.encode()) 10 | await writer.drain() 11 | 12 | data = await reader.read(100) 13 | print(f'Received: {data.decode()!r}') 14 | 15 | print('Close the connection') 16 | writer.close() 17 | await writer.wait_closed() 18 | except ConnectionRefusedError as e: 19 | print('something is wrong') 20 | print(str(e)) 21 | 22 | asyncio.run(tcp_echo_client('Hello World!')) -------------------------------------------------------------------------------- /progjar3/threading_examples/thread22.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | import datetime 4 | 5 | def fungsi3(): 6 | while True: 7 | waktu = datetime.datetime.now() 8 | print("{} saya adalah fungsi 3 yang berjalan \n" . format(waktu)) 9 | time.sleep(4) 10 | return 11 | 12 | def fungsi2(): 13 | while True: 14 | waktu = datetime.datetime.now() 15 | print("{} saya adalah fungsi 2 yang berjalan \n" . format(waktu)) 16 | time.sleep(2) 17 | return 18 | 19 | def fungsi1(): 20 | while True: 21 | waktu = datetime.datetime.now() 22 | print("{} saya adalah fungsi 1 yang berjalan \n".format(waktu)) 23 | time.sleep(1) 24 | return 25 | 26 | 27 | f1 = threading.Thread(target=fungsi1) 28 | f1.start() 29 | 30 | f2 = threading.Thread(target=fungsi2) 31 | f2.start() 32 | 33 | f3 = threading.Thread(target=fungsi2) 34 | f3.start() 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /progjar3/concurrency/multi_process_pool.py: -------------------------------------------------------------------------------- 1 | from library import download_gambar,get_url_list 2 | import time 3 | import datetime 4 | from concurrent.futures import ProcessPoolExecutor 5 | 6 | 7 | 8 | def download_semua(): 9 | texec = dict() 10 | urls = get_url_list() 11 | 12 | catat_awal = time.perf_counter() 13 | 14 | with ProcessPoolExecutor() as executor: 15 | for k in urls: 16 | print(f"mendownload {urls[k]}") 17 | #bagian ini merupakan bagian yang mengistruksikan eksekusi fungsi download gambar secara multithread 18 | executor.submit(download_gambar,urls[k]) 19 | 20 | catat_akhir = time.perf_counter() 21 | selesai = round(catat_akhir - catat_awal,2) 22 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik {catat_awal} s/d {catat_akhir}") 23 | 24 | 25 | #fungsi download_gambar akan dijalankan secara multithreading 26 | 27 | if __name__=='__main__': 28 | download_semua() -------------------------------------------------------------------------------- /progjar3/concurrency/multi_thread_pool.py: -------------------------------------------------------------------------------- 1 | from library import download_gambar,get_url_list 2 | import time 3 | import datetime 4 | from concurrent.futures import ThreadPoolExecutor 5 | 6 | 7 | 8 | def download_semua(): 9 | texec = dict() 10 | urls = get_url_list() 11 | 12 | catat_awal = time.perf_counter() 13 | 14 | with ThreadPoolExecutor() as executor: 15 | for k in urls: 16 | print(f"mendownload {urls[k]}") 17 | #bagian ini merupakan bagian yang mengistruksikan eksekusi fungsi download gambar secara multithread 18 | executor.submit(download_gambar,urls[k]) 19 | 20 | catat_akhir = time.perf_counter() 21 | selesai = round(catat_akhir - catat_awal,2) 22 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik {catat_awal} s/d {catat_akhir}") 23 | 24 | 25 | #fungsi download_gambar akan dijalankan secara multithreading 26 | 27 | if __name__=='__main__': 28 | download_semua() -------------------------------------------------------------------------------- /progjar3/concurrency_asyncio/multi_thread.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | from library import download_gambar,get_url_list 3 | import time 4 | import datetime 5 | import threading 6 | 7 | 8 | 9 | 10 | async def download_semua(): 11 | texec = dict() 12 | urls = await get_url_list() 13 | 14 | catat_awal = time.perf_counter() 15 | for k in urls: 16 | print(f"mendownload {urls[k]}") 17 | waktu = time.time() 18 | #bagian ini merupakan bagian yang mengistruksikan eksekusi fungsi download gambar secara multithread 19 | texec[k] = await download_gambar(urls[k]) #tanpa await, tidak akan melakukan apa apa 20 | 21 | 22 | catat_akhir = time.perf_counter() 23 | selesai = round(catat_akhir - catat_awal,2) 24 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik {catat_awal} s/d {catat_akhir}") 25 | 26 | 27 | #fungsi download_gambar akan dijalankan secara multithreading 28 | 29 | if __name__=='__main__': 30 | asyncio.run(download_semua()) -------------------------------------------------------------------------------- /progjar4a/file_interface.py: -------------------------------------------------------------------------------- 1 | import os 2 | import json 3 | import base64 4 | from glob import glob 5 | 6 | 7 | class FileInterface: 8 | def __init__(self): 9 | os.chdir('files/') 10 | 11 | def list(self,params=[]): 12 | try: 13 | filelist = glob('*.*') 14 | return dict(status='OK',data=filelist) 15 | except Exception as e: 16 | return dict(status='ERROR',data=str(e)) 17 | 18 | def get(self,params=[]): 19 | try: 20 | filename = params[0] 21 | if (filename == ''): 22 | return None 23 | fp = open(f"{filename}",'rb') 24 | isifile = base64.b64encode(fp.read()).decode() 25 | return dict(status='OK',data_namafile=filename,data_file=isifile) 26 | except Exception as e: 27 | return dict(status='ERROR',data=str(e)) 28 | 29 | 30 | 31 | if __name__=='__main__': 32 | f = FileInterface() 33 | print(f.list()) 34 | print(f.get(['pokijan.jpg'])) 35 | -------------------------------------------------------------------------------- /progjar3/threading_examples/thread4.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | import datetime 4 | 5 | class Worker(threading.Thread): 6 | def __init__(self,nomor): 7 | self.nomor = nomor 8 | self.aktif = 1 9 | threading.Thread.__init__(self) 10 | self.daemon=True 11 | def stop(self): 12 | self.aktif = 0 13 | 14 | def run(self): 15 | while (True and (self.aktif==1)): 16 | waktu = datetime.datetime.now() 17 | print("{} Saya worker nomor {} \n".format(waktu, nomor)) 18 | time.sleep(1) 19 | 20 | def main(): 21 | worker1 = Worker(1) 22 | worker2 = Worker(2) 23 | worker3 = Worker(3) 24 | worker4 = Worker(4) 25 | 26 | worker1.start() 27 | worker2.start() 28 | worker3.start() 29 | worker4.start() 30 | 31 | worker4.stop() 32 | 33 | 34 | if __name__ == "__main__": 35 | try: 36 | main() 37 | while True: 38 | pass 39 | except KeyboardInterrupt: 40 | print('Program stop') 41 | -------------------------------------------------------------------------------- /progjar3/concurrency/multi_process.py: -------------------------------------------------------------------------------- 1 | from library import download_gambar, get_url_list 2 | import time 3 | import datetime 4 | from multiprocessing import Process 5 | 6 | def download_semua(): 7 | texec = dict() 8 | urls = get_url_list() 9 | catat_awal = datetime.datetime.now() 10 | for k in urls: 11 | print(f"mendownload {urls[k]}") 12 | waktu = time.time() 13 | #bagian ini merupakan bagian yang mengistruksikan eksekusi fungsi download gambar secara multiprocess 14 | texec[k] = Process(target=download_gambar, args=(urls[k],)) 15 | texec[k].start() 16 | #setelah menyelesaikan tugasnya, dikembalikan ke main process dengan join 17 | for k in urls: 18 | texec[k].join() 19 | catat_akhir = datetime.datetime.now() 20 | selesai = catat_akhir - catat_awal 21 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik {catat_awal} s/d {catat_akhir}") 22 | #fungsi download_gambar akan dijalankan secara multi process 23 | if __name__=='__main__': 24 | download_semua() -------------------------------------------------------------------------------- /progjar1/socket_info.py: -------------------------------------------------------------------------------- 1 | 2 | import socket 3 | 4 | 5 | def get_my_socket(): 6 | s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 7 | timeout = s.gettimeout() 8 | print(f"timeout : {timeout}") 9 | s.settimeout(10) 10 | timeout = s.gettimeout() 11 | print(f"timeout : {timeout}") 12 | koneksi = socket.getaddrinfo('www.its.ac.id',80, proto=socket.IPPROTO_TCP) 13 | print(koneksi) 14 | 15 | 16 | def get_my_info(): 17 | hostname = socket.gethostname() 18 | print(f"hostname : {hostname}") 19 | 20 | ip_address = socket.gethostbyname(hostname) 21 | print(f"ipaddress: {ip_address}") 22 | 23 | def get_remote_info(): 24 | remote_host = 'www.espnfc.cosm' 25 | try: 26 | remote_host_ip = socket.gethostbyname(remote_host) 27 | print(f"ip address dari {remote_host} adalah {remote_host_ip}") 28 | except Exception as ee: 29 | print(f"ERROR : {str(ee)}") 30 | 31 | 32 | if __name__=='__main__': 33 | # get_my_info() 34 | # get_remote_info() 35 | get_my_socket() 36 | -------------------------------------------------------------------------------- /progjar1/client.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import logging 4 | 5 | #set basic logging 6 | logging.basicConfig(level=logging.INFO) 7 | 8 | try: 9 | # Create a TCP/IP socket 10 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 11 | 12 | # Connect the socket to the port where the server is listening 13 | server_address = ('localhost', 10000) 14 | logging.info(f"connecting to {server_address}") 15 | sock.connect(server_address) 16 | 17 | # Send data 18 | message = 'INI ADALAH DATA YANG DIKIRIM ABCDEFGHIJKLMNOPQ' 19 | logging.info(f"sending {message}") 20 | sock.sendall(message.encode()) 21 | # Look for the response 22 | amount_received = 0 23 | amount_expected = len(message) 24 | while amount_received < amount_expected: 25 | data = sock.recv(16) 26 | amount_received += len(data) 27 | logging.info(f"{data}") 28 | 29 | except Exception as ee: 30 | logging.info(f"ERROR: {str(ee)}") 31 | exit(0) 32 | finally: 33 | logging.info("closing") 34 | sock.close() 35 | -------------------------------------------------------------------------------- /progjar3/concurrency/multi_thread.py: -------------------------------------------------------------------------------- 1 | from library import download_gambar,get_url_list 2 | import time 3 | import datetime 4 | import threading 5 | 6 | 7 | 8 | 9 | def download_semua(): 10 | texec = dict() 11 | urls = get_url_list() 12 | 13 | catat_awal = datetime.datetime.now() 14 | for k in urls: 15 | print(f"mendownload {urls[k]}") 16 | waktu = time.time() 17 | #bagian ini merupakan bagian yang mengistruksikan eksekusi fungsi download gambar secara multithread 18 | texec[k] = threading.Thread(target=download_gambar, args=(urls[k],)) 19 | texec[k].start() 20 | 21 | #setelah menyelesaikan tugasnya, dikembalikan ke main thread dengan join 22 | for k in urls: 23 | texec[k].join() 24 | 25 | catat_akhir = datetime.datetime.now() 26 | selesai = catat_akhir - catat_awal 27 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik {catat_awal} s/d {catat_akhir}") 28 | 29 | 30 | #fungsi download_gambar akan dijalankan secara multithreading 31 | 32 | if __name__=='__main__': 33 | download_semua() -------------------------------------------------------------------------------- /progjar5/client/domain.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIICrzCCAZcCFGfd6KmPB0veURkGCvq/sOi3Vf/tMA0GCSqGSIb3DQEBCwUAMBQx 3 | EjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0yNTA0MjIwMjI4NTdaFw0yNjA0MjIwMjI4 4 | NTdaMBQxEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEP 5 | ADCCAQoCggEBAKsKsbLZgblYo2WSm2R65L7pD36RWv2lOKN8IwjqyTJ7tzETD98y 6 | X2qQm1tmuHqLHEYh/RUNxk+mR3p3ka9wiAlkZUDhUEYIDB2i7LJIbRcJe8BT4RQi 7 | OvsEEInU8hQYvt0gC+DPmX56GNEdIzxO9umVUOJH11Fx6DEeWNOuT8+e0riDnMDO 8 | abze6S83YnOAJqrIbRVjsEwYgvLGD+eG7siwTWHuBumLVK9RBddDK+HAuJXQisIu 9 | qcDTfyRdgOveiLLMDM2vRBPFIwbDQ4e+2iJYIiW4O8i6ewXCaegopoJ9bhxoxUZO 10 | S9PtYk5BAb9W7yBuarFSTHbo/X08ptXvrYECAwEAATANBgkqhkiG9w0BAQsFAAOC 11 | AQEAeL1isfypKpigO22Q7jHm8G2i53AfSAWpEMDYtjsnXjcSO583I4y87nZG6rg9 12 | YC6NdmhKyVboANcBuju8ELvZzEbjCFaJSpIVYQhboTwk8EqG2o18uAJb8hnCZLas 13 | PA/8gSp7eNS6KaaGrHrX7LfgxLx/M+8Hw3aIIjedU09oE9PG9Jo4dtNNiyoxvRq/ 14 | BEar3jRIfK9XIdVuomk0nfNQ9RJ0NGVy999bhzQpvpS2sUKFcV5J+sM8Tc96e6vg 15 | vATrK6Z3+o1hj0VoxLQolkTtFRa1WPv55yYnzbJYrHB/FK/iHQUCArUfiw+TPFEv 16 | AV/8OTweZmmDskvNGJbD6PWCYQ== 17 | -----END CERTIFICATE----- 18 | -------------------------------------------------------------------------------- /progjar1a/client_side/domain.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIICrzCCAZcCFGfd6KmPB0veURkGCvq/sOi3Vf/tMA0GCSqGSIb3DQEBCwUAMBQx 3 | EjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0yNTA0MjIwMjI4NTdaFw0yNjA0MjIwMjI4 4 | NTdaMBQxEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEP 5 | ADCCAQoCggEBAKsKsbLZgblYo2WSm2R65L7pD36RWv2lOKN8IwjqyTJ7tzETD98y 6 | X2qQm1tmuHqLHEYh/RUNxk+mR3p3ka9wiAlkZUDhUEYIDB2i7LJIbRcJe8BT4RQi 7 | OvsEEInU8hQYvt0gC+DPmX56GNEdIzxO9umVUOJH11Fx6DEeWNOuT8+e0riDnMDO 8 | abze6S83YnOAJqrIbRVjsEwYgvLGD+eG7siwTWHuBumLVK9RBddDK+HAuJXQisIu 9 | qcDTfyRdgOveiLLMDM2vRBPFIwbDQ4e+2iJYIiW4O8i6ewXCaegopoJ9bhxoxUZO 10 | S9PtYk5BAb9W7yBuarFSTHbo/X08ptXvrYECAwEAATANBgkqhkiG9w0BAQsFAAOC 11 | AQEAeL1isfypKpigO22Q7jHm8G2i53AfSAWpEMDYtjsnXjcSO583I4y87nZG6rg9 12 | YC6NdmhKyVboANcBuju8ELvZzEbjCFaJSpIVYQhboTwk8EqG2o18uAJb8hnCZLas 13 | PA/8gSp7eNS6KaaGrHrX7LfgxLx/M+8Hw3aIIjedU09oE9PG9Jo4dtNNiyoxvRq/ 14 | BEar3jRIfK9XIdVuomk0nfNQ9RJ0NGVy999bhzQpvpS2sUKFcV5J+sM8Tc96e6vg 15 | vATrK6Z3+o1hj0VoxLQolkTtFRa1WPv55yYnzbJYrHB/FK/iHQUCArUfiw+TPFEv 16 | AV/8OTweZmmDskvNGJbD6PWCYQ== 17 | -----END CERTIFICATE----- 18 | -------------------------------------------------------------------------------- /progjar1a/server_side/certs/domain.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIICrzCCAZcCFGfd6KmPB0veURkGCvq/sOi3Vf/tMA0GCSqGSIb3DQEBCwUAMBQx 3 | EjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0yNTA0MjIwMjI4NTdaFw0yNjA0MjIwMjI4 4 | NTdaMBQxEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEP 5 | ADCCAQoCggEBAKsKsbLZgblYo2WSm2R65L7pD36RWv2lOKN8IwjqyTJ7tzETD98y 6 | X2qQm1tmuHqLHEYh/RUNxk+mR3p3ka9wiAlkZUDhUEYIDB2i7LJIbRcJe8BT4RQi 7 | OvsEEInU8hQYvt0gC+DPmX56GNEdIzxO9umVUOJH11Fx6DEeWNOuT8+e0riDnMDO 8 | abze6S83YnOAJqrIbRVjsEwYgvLGD+eG7siwTWHuBumLVK9RBddDK+HAuJXQisIu 9 | qcDTfyRdgOveiLLMDM2vRBPFIwbDQ4e+2iJYIiW4O8i6ewXCaegopoJ9bhxoxUZO 10 | S9PtYk5BAb9W7yBuarFSTHbo/X08ptXvrYECAwEAATANBgkqhkiG9w0BAQsFAAOC 11 | AQEAeL1isfypKpigO22Q7jHm8G2i53AfSAWpEMDYtjsnXjcSO583I4y87nZG6rg9 12 | YC6NdmhKyVboANcBuju8ELvZzEbjCFaJSpIVYQhboTwk8EqG2o18uAJb8hnCZLas 13 | PA/8gSp7eNS6KaaGrHrX7LfgxLx/M+8Hw3aIIjedU09oE9PG9Jo4dtNNiyoxvRq/ 14 | BEar3jRIfK9XIdVuomk0nfNQ9RJ0NGVy999bhzQpvpS2sUKFcV5J+sM8Tc96e6vg 15 | vATrK6Z3+o1hj0VoxLQolkTtFRa1WPv55yYnzbJYrHB/FK/iHQUCArUfiw+TPFEv 16 | AV/8OTweZmmDskvNGJbD6PWCYQ== 17 | -----END CERTIFICATE----- 18 | -------------------------------------------------------------------------------- /progjar9/protocol.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import json 3 | import shlex 4 | #from logic import PlayerServerInterface 5 | from logic_v2 import PlayerServerInterface 6 | 7 | class PlayerServerProtocol: 8 | def __init__(self): 9 | self.file = PlayerServerInterface() 10 | 11 | def proses_string(self,string_datamasuk=''): 12 | logging.warning(f"string diproses: {string_datamasuk}") 13 | c = shlex.split(string_datamasuk.lower()) 14 | try: 15 | c_request = c[0].strip() 16 | logging.warning(f"memproses request: {c_request}") 17 | params = [x for x in c[1:]] 18 | cl = getattr(self.file,c_request)(params) 19 | return json.dumps(cl) 20 | except Exception: 21 | return json.dumps(dict(status='ERROR',data='request tidak dikenali')) 22 | 23 | 24 | if __name__=='__main__': 25 | #contoh pemakaian 26 | fp = PlayerServerProtocol() 27 | print(fp.proses_string("set_location 1 100 200")) 28 | print(fp.proses_string("get_location 1")) 29 | print(fp.proses_string("get_all_players 0")) -------------------------------------------------------------------------------- /progjar3/threading_examples/client_1.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import logging 4 | 5 | 6 | 7 | def kirim_data(): 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 9 | logging.warning("membuka socket") 10 | 11 | server_address = ('localhost', 10000) 12 | logging.warning(f"opening socket {server_address}") 13 | sock.connect(server_address) 14 | 15 | try: 16 | # Send data 17 | message = 'INI ADALAH DATA YANG DIKIRIM ABCDEFGHIJKLMNOPQ' 18 | logging.warning(f"[CLIENT] sending {message}") 19 | sock.sendall(message.encode()) 20 | # Look for the response 21 | amount_received = 0 22 | amount_expected = len(message) 23 | while amount_received < amount_expected: 24 | data = sock.recv(16) 25 | amount_received += len(data) 26 | logging.warning(f"[DITERIMA DARI SERVER] {data}") 27 | finally: 28 | logging.warning("closing") 29 | sock.close() 30 | return 31 | 32 | 33 | if __name__=='__main__': 34 | for i in range(1,10): 35 | kirim_data() 36 | -------------------------------------------------------------------------------- /progjar3/threading_examples/server.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import logging 4 | import datetime 5 | 6 | # Create a TCP/IP socket 7 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 8 | # Bind the socket to the port 9 | server_address = ('localhost', 10000) 10 | logging.warning(f"starting up on {server_address}") 11 | sock.bind(server_address) 12 | # Listen for incoming connections 13 | sock.listen(1) 14 | while True: 15 | # Wait for a connection 16 | logging.warning("opening connection") 17 | connection, client_address = sock.accept() 18 | logging.warning(f"connection from {client_address}") 19 | # Receive the data in small chunks and retransmit it 20 | while True: 21 | waktu = datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%s") 22 | data = connection.recv(32) 23 | logging.warning(f"{waktu} received {data}") 24 | if data: 25 | logging.warning("[SERVER] {waktu} sending data back to the client") 26 | connection.sendall(data) 27 | else: 28 | logging.warning(f"[SERVER] {waktu} no more data from {client_address}") 29 | break 30 | # Clean up the connection 31 | connection.close() 32 | -------------------------------------------------------------------------------- /environment-demo/app/client/chat-flet.py: -------------------------------------------------------------------------------- 1 | from chatcli import * 2 | 3 | 4 | import flet as ft 5 | 6 | 7 | TARGET_IP = os.getenv("SERVER_IP") or "127.0.0.1" 8 | TARGET_PORT = os.getenv("SERVER_PORT") or "8889" 9 | ON_WEB = os.getenv("ONWEB") or "0" 10 | 11 | 12 | def main(page): 13 | def btn_click(e): 14 | if not cmd.value: 15 | cmd.error_text = "masukkan command" 16 | page.update() 17 | else: 18 | txt = cmd.value 19 | lv.controls.append(ft.Text(f"command: {txt}")) 20 | txt = cc.proses(txt) 21 | lv.controls.append(ft.Text(f"result {cc.tokenid}: {txt}")) 22 | cmd.value="" 23 | page.update() 24 | 25 | cc = ChatClient() 26 | 27 | 28 | lv = ft.ListView(expand=1, spacing=10, padding=20, auto_scroll=True) 29 | cmd = ft.TextField(label="Your command") 30 | 31 | page.add(lv) 32 | page.add(cmd, ft.ElevatedButton("Send", on_click=btn_click)) 33 | 34 | 35 | if __name__=='__main__': 36 | if (ON_WEB=="1"): 37 | ft.app(target=main,view=ft.WEB_BROWSER,port=8550) 38 | else: 39 | ft.app(target=main) 40 | 41 | -------------------------------------------------------------------------------- /environment-demo/docker-compose.yml: -------------------------------------------------------------------------------- 1 | version: '3' 2 | services: 3 | chatserver: 4 | image: python:3.11.3-alpine3.17 5 | restart: unless-stopped 6 | volumes: 7 | - ./app/server:/app 8 | environment: 9 | - SERVER_IP=0.0.0.0 10 | - SERVER_PORT=8889 11 | working_dir: /app 12 | ports: 13 | - 8889:8889 14 | command: 15 | - /bin/sh 16 | - -c 17 | - 'cd /app && pip3 install -r requirements.txt && python3 server.py' 18 | networks: 19 | - progjarnet 20 | chatclient: 21 | image: python:3.11.3-alpine3.17 22 | restart: unless-stopped 23 | environment: 24 | - SERVER_IP=chatserver 25 | - SERVER_PORT=8889 26 | - ONWEB=1 27 | working_dir: /app 28 | ports: 29 | - 8550:8550 30 | volumes: 31 | - ./app/client:/app 32 | command: 33 | - /bin/sh 34 | - -c 35 | - 'cd /app && pip3 install -r requirements.txt && python3 chat-flet.py' 36 | depends_on: 37 | - chatserver 38 | # deploy: 39 | # mode: replicated 40 | # replicas: 1 41 | networks: 42 | - progjarnet 43 | networks: 44 | progjarnet: 45 | ipam: 46 | config: 47 | - subnet: 172.222.221.0/24 48 | -------------------------------------------------------------------------------- /progjar4b/person.py: -------------------------------------------------------------------------------- 1 | import shelve 2 | import uuid 3 | 4 | 5 | class Person: 6 | def __init__(self): 7 | self.data = shelve.open('mydata.dat') 8 | def create_data(self,nama=None,telpon=None): 9 | if (nama is None): 10 | return False 11 | id=str(uuid.uuid4()) 12 | data = dict(id=id,nama=nama,telpon=telpon) 13 | self.data[id]=data 14 | return True 15 | def get_data(self,nama=None): 16 | for i in self.data.keys(): 17 | try: 18 | if (self.data[i]['nama'].lower() ==nama.lower()): 19 | return self.data[i] 20 | except: 21 | return False 22 | def delete_data(self,id=None): 23 | if (id is None): 24 | return False 25 | del self.data[id] 26 | def list_data(self): 27 | k = [self.data[i] for i in self.data.keys()] 28 | return k 29 | 30 | if __name__=='__main__': 31 | p = Person() 32 | p.create_data("vanBasten","621234") 33 | p.create_data("vanPersie","621235") 34 | p.create_data("vanNistelroy","621236") 35 | p.create_data("vanDerVaart","621237") 36 | print(p.list_data()) 37 | print(p.get_data('vanbasten')) 38 | -------------------------------------------------------------------------------- /progjar3/concurrency/multi_thread_async.py: -------------------------------------------------------------------------------- 1 | from library import download_gambar,get_url_list 2 | import time 3 | import datetime 4 | import concurrent.futures 5 | 6 | 7 | 8 | 9 | def download_semua(): 10 | texec = dict() 11 | urls = get_url_list() 12 | status_task = dict() 13 | task = concurrent.futures.ThreadPoolExecutor(max_workers=10) 14 | catat_awal = datetime.datetime.now() 15 | for k in urls: 16 | print(f"mendownload {urls[k]}") 17 | waktu = time.time() 18 | #bagian ini merupakan bagian yang mengistruksikan eksekusi fungsi download gambar secara multithread 19 | texec[k] = task.submit(download_gambar, urls[k]) 20 | 21 | #setelah menyelesaikan tugasnya, dikembalikan ke main thread dengan memanggil result 22 | for k in urls: 23 | status_task[k]=texec[k].result() 24 | 25 | catat_akhir = datetime.datetime.now() 26 | selesai = catat_akhir - catat_awal 27 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik {catat_awal} s/d {catat_akhir}") 28 | print("hasil task yang dijalankan") 29 | print(status_task) 30 | 31 | 32 | #fungsi download_gambar akan dijalankan secara multithreading 33 | 34 | if __name__=='__main__': 35 | download_semua() -------------------------------------------------------------------------------- /progjar9/logic.py: -------------------------------------------------------------------------------- 1 | import os 2 | import json 3 | import base64 4 | from glob import glob 5 | import shelve 6 | 7 | #asumsi, hanya ada player 1, 2 , 3 8 | class PlayerServerInterface: 9 | def __init__(self): 10 | self.players = shelve.open('g.db',writeback=True) 11 | self.players['1']= "100,100" 12 | self.players['2']= "100,100" 13 | self.players['3']= "100,100" 14 | 15 | def set_location(self,params=[]): 16 | pnum = params[0] 17 | x = params[1] 18 | y = params[2] 19 | try: 20 | self.players[pnum]=f"{x},{y}" 21 | self.players.sync() 22 | return dict(status='OK', player=pnum) 23 | except Exception as e: 24 | return dict(status='ERROR') 25 | 26 | def get_location(self,params=[]): 27 | pnum = params[0] 28 | try: 29 | return dict(status='OK',location=self.players[pnum]) 30 | except Exception as ee: 31 | return dict(status='ERROR') 32 | 33 | 34 | 35 | if __name__=='__main__': 36 | p = PlayerServerInterface() 37 | p.set_location(['1',100,100]) 38 | print(p.get_location('1')) 39 | p.set_location(['2',120,100]) 40 | print(p.get_location('2')) 41 | -------------------------------------------------------------------------------- /progjar5/server_asyncio_stream_http.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import time 4 | import sys 5 | import logging 6 | import multiprocessing 7 | from concurrent.futures import ProcessPoolExecutor 8 | import asyncio 9 | from http import HttpServer 10 | 11 | httpserver = HttpServer() 12 | 13 | class ProcessTheClient(asyncio.Protocol): 14 | def connection_made(self, transport): 15 | peername = transport.get_extra_info('peername') 16 | print('Connection from {}'.format(peername)) 17 | self.transport = transport 18 | self.rcv = "" 19 | def data_received(self, data: bytes) -> None: 20 | try: 21 | d = data.decode() 22 | self.rcv=self.rcv+d 23 | if self.rcv[-2:]=='\r\n': 24 | hasil = httpserver.proses(self.rcv) 25 | hasil=hasil+"\r\n\r\n".encode() 26 | self.transport.write(hasil) 27 | self.transport.close() 28 | self.rcv="" 29 | except OSError as e: 30 | pass 31 | 32 | 33 | 34 | async def Server(): 35 | loop = asyncio.get_running_loop() 36 | 37 | server = await loop.create_server( 38 | lambda: ProcessTheClient(), 39 | '0.0.0.0', 8886) 40 | 41 | async with server: 42 | await server.serve_forever() 43 | 44 | if __name__=="__main__": 45 | asyncio.run(Server()) 46 | 47 | -------------------------------------------------------------------------------- /progjar3/threading_examples/server_thread.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import logging 5 | import time 6 | import sys 7 | 8 | class ProcessTheClient(threading.Thread): 9 | def __init__(self,connection,address): 10 | self.connection = connection 11 | self.address = address 12 | threading.Thread.__init__(self) 13 | 14 | def run(self): 15 | while True: 16 | data = self.connection.recv(32) 17 | if data: 18 | self.connection.sendall(data) 19 | else: 20 | break 21 | self.connection.close() 22 | 23 | class Server(threading.Thread): 24 | def __init__(self): 25 | self.the_clients = [] 26 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 27 | threading.Thread.__init__(self) 28 | 29 | def run(self): 30 | self.my_socket.bind(('0.0.0.0',8889)) 31 | self.my_socket.listen(1) 32 | while True: 33 | self.connection, self.client_address = self.my_socket.accept() 34 | logging.warning(f"connection from {self.client_address}") 35 | 36 | clt = ProcessTheClient(self.connection, self.client_address) 37 | clt.start() 38 | self.the_clients.append(clt) 39 | 40 | 41 | def main(): 42 | svr = Server() 43 | svr.start() 44 | 45 | if __name__=="__main__": 46 | main() 47 | 48 | -------------------------------------------------------------------------------- /progjar4a/PROTOKOL.txt: -------------------------------------------------------------------------------- 1 | FILE SERVER 2 | TUJUAN: melayani client dalam request file server 3 | 4 | ATURAN PROTOKOL: 5 | - client harus mengirimkan request dalam bentuk string 6 | - string harus dalam format 7 | REQUEST spasi PARAMETER 8 | - PARAMETER dapat berkembang menjadi PARAMETER1 spasi PARAMETER2 dan seterusnya 9 | 10 | REQUEST YANG DILAYANI: 11 | - informasi umum: 12 | * Jika request tidak dikenali akan menghasilkan pesan 13 | - status: ERROR 14 | - data: request tidak dikenali 15 | * Semua result akan diberikan dalam bentuk JSON dan diakhiri 16 | dengan character ascii code #13#10#13#10 atau "\r\n\r\n" 17 | 18 | LIST 19 | * TUJUAN: untuk mendapatkan daftar seluruh file yang dilayani oleh file server 20 | * PARAMETER: tidak ada 21 | * RESULT: 22 | - BERHASIL: 23 | - status: OK 24 | - data: list file 25 | - GAGAL: 26 | - status: ERROR 27 | - data: pesan kesalahan 28 | 29 | GET 30 | * TUJUAN: untuk mendapatkan isi file dengan menyebutkan nama file dalam parameter 31 | * PARAMETER: 32 | - PARAMETER1 : nama file 33 | * RESULT: 34 | - BERHASIL: 35 | - status: OK 36 | - data_namafile : nama file yang diminta 37 | - data_file : isi file yang diminta (dalam bentuk base64) 38 | - GAGAL: 39 | - status: ERROR 40 | - data: pesan kesalahan 41 | 42 | -------------------------------------------------------------------------------- /progjar3/concurrency/multi_process_async.py: -------------------------------------------------------------------------------- 1 | from library import download_gambar, get_url_list 2 | import time 3 | import datetime 4 | from multiprocessing import Process, Pool 5 | 6 | 7 | 8 | 9 | def download_semua(): 10 | texec = dict() 11 | urls = get_url_list() 12 | status_task = dict() 13 | task_pool = Pool(processes=20) #2 task yang dapat dikerjakan secara simultan, dapat diset sesuai jumlah core 14 | catat_awal = datetime.datetime.now() 15 | for k in urls: 16 | print(f"mendownload {urls[k]}") 17 | #bagian ini merupakan bagian yang mengistruksikan eksekusi fungsi download gambar secara multiprocess 18 | texec[k] = task_pool.apply_async(func=download_gambar, args=(urls[k],)) 19 | 20 | #setelah menyelesaikan tugasnya, dikembalikan ke main process dengan mengambil hasilnya dengan get 21 | for k in urls: 22 | status_task[k]=texec[k].get(timeout=10) 23 | 24 | catat_akhir = datetime.datetime.now() 25 | selesai = catat_akhir - catat_awal 26 | print(f"Waktu TOTAL yang dibutuhkan {selesai} detik {catat_awal} s/d {catat_akhir}") 27 | print("status TASK") 28 | print(status_task) 29 | 30 | 31 | #fungsi download_gambar akan dijalankan secara multi process 32 | 33 | if __name__=='__main__': 34 | download_semua() -------------------------------------------------------------------------------- /progjar3/threading_examples/client_2.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import logging 4 | import threading 5 | 6 | 7 | def kirim_data(nama="kosong"): 8 | logging.warning(f"nama {nama}") 9 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 10 | logging.warning("membuka socket") 11 | 12 | server_address = ('localhost', 8889) 13 | logging.warning(f"opening socket {server_address}") 14 | sock.connect(server_address) 15 | 16 | try: 17 | # Send data 18 | message = 'INI ADALAH DATA YANG DIKIRIM ABCDEFGHIJKLMNOPQ' 19 | logging.warning(f"[CLIENT] sending {message}") 20 | sock.sendall(message.encode()) 21 | # Look for the response 22 | amount_received = 0 23 | amount_expected = len(message) 24 | while amount_received < amount_expected: 25 | data = sock.recv(16) 26 | amount_received += len(data) 27 | logging.warning(f"[DITERIMA DARI SERVER] {data}") 28 | finally: 29 | logging.warning("closing") 30 | sock.close() 31 | return 32 | 33 | 34 | if __name__=='__main__': 35 | threads = [] 36 | for i in range(3): 37 | t = threading.Thread(target=kirim_data, args=(i,)) 38 | threads.append(t) 39 | 40 | for thr in threads: 41 | thr.start() -------------------------------------------------------------------------------- /progjar3/threading_examples/thread6.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import glob 3 | import time 4 | import socket 5 | 6 | all_files = {} 7 | 8 | class FileReaderThread(threading.Thread): 9 | def __init__(self): 10 | threading.Thread.__init__(self) 11 | self.daemon=True 12 | def run(self): 13 | while True: 14 | files = glob.glob('*.py') 15 | for x in files: 16 | fp = open(x,'rb') 17 | all_files[x]=fp.read() 18 | time.sleep(1) 19 | 20 | class UdpServer(threading.Thread): 21 | def __init__(self): 22 | self.address = '127.0.0.1' 23 | self.port = 8888 24 | self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 25 | self.sock.bind((self.address,self.port)) 26 | threading.Thread.__init__(self) 27 | self.daemon=True 28 | def run(self): 29 | while True: 30 | data,addr = self.sock.recvfrom(1024) 31 | for k in all_files: 32 | self.sock.sendto(all_files[k],addr) 33 | print("kirim nama file",k," ke ",addr) 34 | 35 | 36 | 37 | def main(): 38 | frt = FileReaderThread() 39 | frt.start() 40 | 41 | udpserver = UdpServer() 42 | udpserver.start() 43 | 44 | 45 | 46 | if __name__ == "__main__": 47 | try: 48 | main() 49 | while True: 50 | pass 51 | except KeyboardInterrupt: 52 | print(" Program Stop ..") 53 | -------------------------------------------------------------------------------- /progjar4a/file_protocol.py: -------------------------------------------------------------------------------- 1 | import json 2 | import logging 3 | import shlex 4 | 5 | from file_interface import FileInterface 6 | 7 | """ 8 | * class FileProtocol bertugas untuk memproses 9 | data yang masuk, dan menerjemahkannya apakah sesuai dengan 10 | protokol/aturan yang dibuat 11 | 12 | * data yang masuk dari client adalah dalam bentuk bytes yang 13 | pada akhirnya akan diproses dalam bentuk string 14 | 15 | * class FileProtocol akan memproses data yang masuk dalam bentuk 16 | string 17 | """ 18 | 19 | 20 | 21 | class FileProtocol: 22 | def __init__(self): 23 | self.file = FileInterface() 24 | def proses_string(self,string_datamasuk=''): 25 | logging.warning(f"string diproses: {string_datamasuk}") 26 | c = shlex.split(string_datamasuk.lower()) 27 | try: 28 | c_request = c[0].strip() 29 | logging.warning(f"memproses request: {c_request}") 30 | params = [x for x in c[1:]] 31 | cl = getattr(self.file,c_request)(params) 32 | return json.dumps(cl) 33 | except Exception: 34 | return json.dumps(dict(status='ERROR',data='request tidak dikenali')) 35 | 36 | 37 | if __name__=='__main__': 38 | #contoh pemakaian 39 | fp = FileProtocol() 40 | print(fp.proses_string("LIST")) 41 | print(fp.proses_string("GET pokijan.jpg")) 42 | -------------------------------------------------------------------------------- /progjar3/threading_examples/server_thread_echo.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import logging 5 | import time 6 | import sys 7 | 8 | def echo_server(input_data): 9 | output_data = input_data 10 | return output_data 11 | 12 | class ProcessTheClient(threading.Thread): 13 | def __init__(self,connection,address): 14 | self.connection = connection 15 | self.address = address 16 | threading.Thread.__init__(self) 17 | 18 | def run(self): 19 | while True: 20 | data = self.connection.recv(32) 21 | if data: 22 | self.connection.sendall(echo_server(data)) 23 | else: 24 | break 25 | self.connection.close() 26 | 27 | class Server(threading.Thread): 28 | def __init__(self): 29 | self.the_clients = [] 30 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 31 | threading.Thread.__init__(self) 32 | 33 | def run(self): 34 | self.my_socket.bind(('0.0.0.0',8889)) 35 | self.my_socket.listen(1) 36 | while True: 37 | self.connection, self.client_address = self.my_socket.accept() 38 | logging.warning(f"connection from {self.client_address}") 39 | 40 | clt = ProcessTheClient(self.connection, self.client_address) 41 | clt.start() 42 | self.the_clients.append(clt) 43 | 44 | 45 | def main(): 46 | svr = Server() 47 | svr.start() 48 | 49 | if __name__=="__main__": 50 | main() 51 | 52 | -------------------------------------------------------------------------------- /progjar7/stream_echo_server.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | class ServerProtocol(asyncio.Protocol): 3 | def connection_made(self,transport_socket): 4 | #dipanggil ketika koneksi baru dibuat 5 | peername = transport_socket.get_extra_info('peername') 6 | print('Ada koneksi dari {}' . format(peername)) 7 | self.transport_socket = transport_socket 8 | 9 | #balasan dapat dikirimkan kapan saja, karena pada dasarnya socket telah terbentuk 10 | balasan = 'ada apa ya ?' . encode() # string -> bytes agar bisa dikirim ke socket 11 | self.transport_socket.write(balasan) 12 | 13 | def data_received(self, data: bytes): 14 | #dipanggil ketika ada data masuk ke socket (self.transport_socket) 15 | message = data.decode() 16 | print('Data received',message) 17 | balasan = 'ada apa ?'.encode() 18 | self.transport_socket.write(balasan) 19 | self.transport_socket.close() 20 | 21 | 22 | loop = asyncio.get_event_loop() 23 | coro = loop.create_server(ServerProtocol, '127.0.0.1',10001) 24 | server = loop.run_until_complete(coro) 25 | try: 26 | #jalankan server, sampai tombol control-C ditekan 27 | loop.run_forever() 28 | except KeyboardInterrupt: 29 | pass 30 | 31 | #memastikan semua yang hubungannya dengan socket diakhiri 32 | server.close() 33 | loop.run_until_complete(server.wait_closed()) 34 | loop.close() -------------------------------------------------------------------------------- /progjar3/threading_examples/thread5.py: -------------------------------------------------------------------------------- 1 | import threading 2 | import time 3 | import datetime 4 | from random import randint 5 | 6 | def cls(): 7 | for n in range(0, 64, 1): print("\r\n") 8 | 9 | def locate(user_string="*", x=0, y=0): 10 | x=int(x) 11 | y=int(y) 12 | if x>=255: x=255 13 | if y>=255: y=255 14 | if x<=0: x=0 15 | if y<=0: y=0 16 | HORIZ=str(x) 17 | VERT=str(y) 18 | print("\033["+VERT+";"+HORIZ+"f"+user_string) 19 | 20 | 21 | class Star(threading.Thread): 22 | def __init__(self,baris): 23 | self.baris = baris 24 | self.kolom = 1 25 | threading.Thread.__init__(self) 26 | self.daemon=True 27 | 28 | def run(self): 29 | while True: 30 | for x in range(1,50): 31 | locate(' ',x,self.baris) 32 | locate(' *',self.kolom,self.baris) 33 | self.kolom = self.kolom + 1 34 | if (self.kolom>=50): 35 | self.kolom = 1 36 | time.sleep(randint(1,3)) 37 | 38 | def main(): 39 | star1 = Star(1) 40 | star2 = Star(10) 41 | star3 = Star(15) 42 | star4 = Star(20) 43 | 44 | star1.start() 45 | star2.start() 46 | star3.start() 47 | star4.start() 48 | 49 | if __name__ == "__main__": 50 | try: 51 | cls() 52 | main() 53 | while True: 54 | pass 55 | except KeyboardInterrupt: 56 | print(" Program Stop ..") 57 | -------------------------------------------------------------------------------- /progjar8/domain.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIID6zCCAtOgAwIBAgIUNtIo+mlgF8+mR3HocRKf1uHIDUQwDQYJKoZIhvcNAQEL 3 | BQAwgYQxCzAJBgNVBAYTAklEMRIwEAYDVQQIDAlFYXN0IEphdmExETAPBgNVBAcM 4 | CFN1cmFiYXlhMQwwCgYDVQQKDANJVFMxDDAKBgNVBAsMA0lUUzEUMBIGA1UEAwwL 5 | dGVzdGluZy5uZXQxHDAaBgkqhkiG9w0BCQEWDXJveUBpdHMuYWMuaWQwHhcNMjEw 6 | NjE3MjE1NDE2WhcNMjIwNjE3MjE1NDE2WjCBhDELMAkGA1UEBhMCSUQxEjAQBgNV 7 | BAgMCUVhc3QgSmF2YTERMA8GA1UEBwwIU3VyYWJheWExDDAKBgNVBAoMA0lUUzEM 8 | MAoGA1UECwwDSVRTMRQwEgYDVQQDDAt0ZXN0aW5nLm5ldDEcMBoGCSqGSIb3DQEJ 9 | ARYNcm95QGl0cy5hYy5pZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB 10 | AMk6CixbFCCbJnrDNDhjecuiCP0R3PsS2EyL5EpCFBGHHb4IC2eWmPm7e9RS/FYG 11 | nSMiCET1Nip8uhG1qeefRQy7uly824WTlTWTQ8+7w2vX8rdAndNjGHO+2CteNBVx 12 | AxhKbYNdPadUSmKEOJZg5x6NE09SCgz2U2tXFZM1iGS09Ht6/c56rn2fOW7ziKxz 13 | LknI0Juf1u5rQ0vXNAo65wwRFZTgssWmFzzEdaIF4A8qQAVJtqUEwVZGOCbmDd6O 14 | N4PPsaIXicXhlkhCaYLPN+1Ys3gyoR+5aYHaSBLTMzeLJwiOBjkmWRl8Cl+0bJMn 15 | ihpP3TZyVDI/q8e4cAasI8UCAwEAAaNTMFEwHQYDVR0OBBYEFPweKQ2rg5NskE1h 16 | 5fJ/jIPVV13fMB8GA1UdIwQYMBaAFPweKQ2rg5NskE1h5fJ/jIPVV13fMA8GA1Ud 17 | EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAMB8Uyl+WMe0UGk+MkUTucyA 18 | ZDnLQsAOnDats6hIkIJZrEmvI90HawZfEoQjmhnR+5zbwWTjkdgupl16NaQc2H9N 19 | ZN2sGXV9BOWV1/zlYNTFkHnN5lliek6gZNabebIgN94DFvs80AWzrmBrZCe5WUVS 20 | zHTFmaPPvQ7F43j2fexX/h4fAV8UpyKVDlp9BUKJx/ibR0g2Z94c8FI1b4ucnEuw 21 | vagQz4P5QlGwgq6/MlAoEXg26Sy7cAKJHgWdYw9o0iOCkJ+ZyDKVies/txfuFIQA 22 | 6fw48/pJ+4id/P5wU+LMLxLTfbZOF/cJAH49TyuJBZfcKzdS345Hwzza4ncUHeQ= 23 | -----END CERTIFICATE----- 24 | -------------------------------------------------------------------------------- /progjar5/certs/domain.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIID6zCCAtOgAwIBAgIUNtIo+mlgF8+mR3HocRKf1uHIDUQwDQYJKoZIhvcNAQEL 3 | BQAwgYQxCzAJBgNVBAYTAklEMRIwEAYDVQQIDAlFYXN0IEphdmExETAPBgNVBAcM 4 | CFN1cmFiYXlhMQwwCgYDVQQKDANJVFMxDDAKBgNVBAsMA0lUUzEUMBIGA1UEAwwL 5 | dGVzdGluZy5uZXQxHDAaBgkqhkiG9w0BCQEWDXJveUBpdHMuYWMuaWQwHhcNMjEw 6 | NjE3MjE1NDE2WhcNMjIwNjE3MjE1NDE2WjCBhDELMAkGA1UEBhMCSUQxEjAQBgNV 7 | BAgMCUVhc3QgSmF2YTERMA8GA1UEBwwIU3VyYWJheWExDDAKBgNVBAoMA0lUUzEM 8 | MAoGA1UECwwDSVRTMRQwEgYDVQQDDAt0ZXN0aW5nLm5ldDEcMBoGCSqGSIb3DQEJ 9 | ARYNcm95QGl0cy5hYy5pZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB 10 | AMk6CixbFCCbJnrDNDhjecuiCP0R3PsS2EyL5EpCFBGHHb4IC2eWmPm7e9RS/FYG 11 | nSMiCET1Nip8uhG1qeefRQy7uly824WTlTWTQ8+7w2vX8rdAndNjGHO+2CteNBVx 12 | AxhKbYNdPadUSmKEOJZg5x6NE09SCgz2U2tXFZM1iGS09Ht6/c56rn2fOW7ziKxz 13 | LknI0Juf1u5rQ0vXNAo65wwRFZTgssWmFzzEdaIF4A8qQAVJtqUEwVZGOCbmDd6O 14 | N4PPsaIXicXhlkhCaYLPN+1Ys3gyoR+5aYHaSBLTMzeLJwiOBjkmWRl8Cl+0bJMn 15 | ihpP3TZyVDI/q8e4cAasI8UCAwEAAaNTMFEwHQYDVR0OBBYEFPweKQ2rg5NskE1h 16 | 5fJ/jIPVV13fMB8GA1UdIwQYMBaAFPweKQ2rg5NskE1h5fJ/jIPVV13fMA8GA1Ud 17 | EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAMB8Uyl+WMe0UGk+MkUTucyA 18 | ZDnLQsAOnDats6hIkIJZrEmvI90HawZfEoQjmhnR+5zbwWTjkdgupl16NaQc2H9N 19 | ZN2sGXV9BOWV1/zlYNTFkHnN5lliek6gZNabebIgN94DFvs80AWzrmBrZCe5WUVS 20 | zHTFmaPPvQ7F43j2fexX/h4fAV8UpyKVDlp9BUKJx/ibR0g2Z94c8FI1b4ucnEuw 21 | vagQz4P5QlGwgq6/MlAoEXg26Sy7cAKJHgWdYw9o0iOCkJ+ZyDKVies/txfuFIQA 22 | 6fw48/pJ+4id/P5wU+LMLxLTfbZOF/cJAH49TyuJBZfcKzdS345Hwzza4ncUHeQ= 23 | -----END CERTIFICATE----- 24 | -------------------------------------------------------------------------------- /progjar7/stream_async_http.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | #menggunakan library http 4 | from http import HttpServer 5 | 6 | httpserver = HttpServer() 7 | 8 | class ServerProtocol(asyncio.Protocol): 9 | def connection_made(self,transport_socket): 10 | #dipanggil ketika koneksi baru dibuat 11 | peername = transport_socket.get_extra_info('peername') 12 | print('Ada koneksi dari {}' . format(peername)) 13 | #self.transport_socket adalah socket yang bisa dikirimi dan dibaca 14 | self.transport_socket = transport_socket 15 | 16 | 17 | def data_received(self, data: bytes): 18 | #dipanggil ketika ada data masuk ke socket (self.transport_socket) 19 | message = data.decode() 20 | #data stream sudah dikelola oleh library, kita hanya tinggal mengambil dari variabel message 21 | hasil = httpserver.proses(message) 22 | #proses, hasil langsung dideliver ke socket yang merequest 23 | #hasil, sudah berupa bytes, jika menggunakan string, encode lah terlebih dahulu 24 | self.transport_socket.write(hasil) 25 | self.transport_socket.close() 26 | 27 | 28 | loop = asyncio.get_event_loop() 29 | coro = loop.create_server(ServerProtocol, '127.0.0.1',10002) 30 | server = loop.run_until_complete(coro) 31 | try: 32 | #jalankan server, sampai tombol control-C ditekan 33 | loop.run_forever() 34 | except KeyboardInterrupt: 35 | pass 36 | 37 | #memastikan semua yang hubungannya dengan socket diakhiri 38 | server.close() 39 | loop.run_until_complete(server.wait_closed()) 40 | loop.close() -------------------------------------------------------------------------------- /progjar10/paint_nonet.py: -------------------------------------------------------------------------------- 1 | from kivy.app import App 2 | from kivy.uix.widget import Widget 3 | from kivy.graphics import Color, Ellipse, Line 4 | from kivy.properties import StringProperty 5 | import sys 6 | 7 | cwarna = dict() 8 | cwarna["yellow"]=[1,1,0] 9 | cwarna["red"]=[1,0,0] 10 | cwarna["blue"]=[0,0,1] 11 | cwarna["green"]=[0,1,0] 12 | 13 | class MyPaintWidget(Widget): 14 | idplayer=StringProperty("idplayer") 15 | warna=StringProperty("warna") 16 | def __init__(self,*args,**kwargs): 17 | self.warna = kwargs.get('warna') or 'red' 18 | super().__init__(**kwargs) 19 | 20 | def on_touch_down(self, touch): 21 | with self.canvas: 22 | a,b,c = cwarna[self.warna] 23 | Color(a,b,c) 24 | d = 30. 25 | Ellipse(pos=(touch.x - d / 2, touch.y - d / 2), size=(d, d)) 26 | touch.ud['line'] = Line(points=(touch.x, touch.y)) 27 | 28 | def on_touch_move(self, touch): 29 | touch.ud['line'].points += [touch.x, touch.y] 30 | 31 | 32 | class MyPaintApp(App): 33 | idplayer=StringProperty("idplayer") 34 | warna=StringProperty("warna") 35 | def __init__(self,**kwargs): 36 | super().__init__(**kwargs) 37 | 38 | def build(self): 39 | return MyPaintWidget(idplayer=self.idplayer,warna=self.warna) 40 | 41 | 42 | if __name__ == '__main__': 43 | idplayer = '1' 44 | warna = 'red' 45 | try: 46 | idplayer = sys.argv[1] 47 | warna = sys.argv[2] 48 | except: 49 | pass 50 | MyPaintApp(idplayer=idplayer, warna=warna).run() 51 | 52 | -------------------------------------------------------------------------------- /progjar4b/server_thread_person.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import logging 5 | import time 6 | import sys 7 | 8 | from person_machine import PersonMachine 9 | 10 | pm = PersonMachine() 11 | 12 | class ProcessTheClient(threading.Thread): 13 | def __init__(self, connection, address): 14 | self.connection = connection 15 | self.address = address 16 | threading.Thread.__init__(self) 17 | 18 | def run(self): 19 | while True: 20 | data = self.connection.recv(32) 21 | if data: 22 | d = data.decode() 23 | hasil = pm.proses(d) 24 | hasil=hasil+"\r\n" 25 | self.connection.sendall(hasil.encode()) 26 | else: 27 | break 28 | self.connection.close() 29 | 30 | 31 | class Server(threading.Thread): 32 | def __init__(self): 33 | self.the_clients = [] 34 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 35 | threading.Thread.__init__(self) 36 | 37 | def run(self): 38 | self.my_socket.bind(('0.0.0.0', 8889)) 39 | self.my_socket.listen(1) 40 | while True: 41 | self.connection, self.client_address = self.my_socket.accept() 42 | logging.warning(f"connection from {self.client_address}") 43 | 44 | clt = ProcessTheClient(self.connection, self.client_address) 45 | clt.start() 46 | self.the_clients.append(clt) 47 | 48 | 49 | def main(): 50 | svr = Server() 51 | svr.start() 52 | 53 | 54 | if __name__ == "__main__": 55 | main() 56 | 57 | -------------------------------------------------------------------------------- /progjar10/protocol.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import json 3 | import shlex 4 | from logic import PlayerServerInterface 5 | 6 | class PlayerServerProtocol: 7 | def __init__(self): 8 | self.instance = PlayerServerInterface.Instance() 9 | 10 | def proses_string(self,string_datamasuk=''): 11 | logging.warning(f"string diproses: {string_datamasuk}") 12 | c = shlex.split(string_datamasuk.lower()) 13 | try: 14 | c_request = c[0].strip() 15 | logging.warning(f"memproses request: {c_request}") 16 | params = [x for x in c[1:]] 17 | cl = getattr(self.instance,c_request)(params) 18 | return json.dumps(cl) 19 | except Exception: 20 | return json.dumps(dict(status='ERROR',data='request tidak dikenali')) 21 | 22 | 23 | if __name__=='__main__': 24 | #contoh pemakaian 25 | fp = PlayerServerProtocol() 26 | print(fp.proses_string("player_register 1")) 27 | print(fp.proses_string("player_register 2")) 28 | print(fp.proses_string("set_location 1 mousedown 100 200 1 0 0 ")) 29 | print(fp.proses_string("set_location 2 mousedown 10 20 1 1 0 ")) 30 | print(fp.proses_string("set_location 2 mousemove 10 40 1 1 0 ")) 31 | print(fp.proses_string("set_location 1 mousemove 100 300 1 0 0")) 32 | print(fp.proses_string("set_location 1 mousedown 150 200 1 0 0")) 33 | print(fp.proses_string("get_location 1")) 34 | print(fp.proses_string("get_location 1")) 35 | print(fp.proses_string("get_location 1")) 36 | print(fp.proses_string("get_location 1")) 37 | print(fp.proses_string("get_location 2")) 38 | print(fp.proses_string("get_location 2")) 39 | 40 | 41 | -------------------------------------------------------------------------------- /progjar4c/chatserver/server_thread_chat.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import time 5 | import sys 6 | import json 7 | import logging 8 | from chat import Chat 9 | 10 | chatserver = Chat() 11 | 12 | class ProcessTheClient(threading.Thread): 13 | def __init__(self, connection, address): 14 | self.connection = connection 15 | self.address = address 16 | threading.Thread.__init__(self) 17 | 18 | def run(self): 19 | rcv="" 20 | while True: 21 | data = self.connection.recv(32) 22 | if data: 23 | d = data.decode() 24 | rcv=rcv+d 25 | if rcv[-2:]=='\r\n': 26 | #end of command, proses string 27 | logging.warning("data dari client: {}" . format(rcv)) 28 | hasil = json.dumps(chatserver.proses(rcv)) 29 | hasil=hasil+"\r\n\r\n" 30 | logging.warning("balas ke client: {}" . format(hasil)) 31 | self.connection.sendall(hasil.encode()) 32 | rcv="" 33 | else: 34 | break 35 | self.connection.close() 36 | 37 | class Server(threading.Thread): 38 | def __init__(self): 39 | self.the_clients = [] 40 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 41 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 42 | threading.Thread.__init__(self) 43 | 44 | def run(self): 45 | self.my_socket.bind(('0.0.0.0',8889)) 46 | self.my_socket.listen(1) 47 | while True: 48 | self.connection, self.client_address = self.my_socket.accept() 49 | logging.warning("connection from {}" . format(self.client_address)) 50 | 51 | clt = ProcessTheClient(self.connection, self.client_address) 52 | clt.start() 53 | self.the_clients.append(clt) 54 | 55 | 56 | def main(): 57 | svr = Server() 58 | svr.start() 59 | 60 | if __name__=="__main__": 61 | main() 62 | 63 | -------------------------------------------------------------------------------- /progjar5/certs/domain.key: -------------------------------------------------------------------------------- 1 | -----BEGIN PRIVATE KEY----- 2 | MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDJOgosWxQgmyZ6 3 | wzQ4Y3nLogj9Edz7EthMi+RKQhQRhx2+CAtnlpj5u3vUUvxWBp0jIghE9TYqfLoR 4 | tannn0UMu7pcvNuFk5U1k0PPu8Nr1/K3QJ3TYxhzvtgrXjQVcQMYSm2DXT2nVEpi 5 | hDiWYOcejRNPUgoM9lNrVxWTNYhktPR7ev3Oeq59nzlu84iscy5JyNCbn9bua0NL 6 | 1zQKOucMERWU4LLFphc8xHWiBeAPKkAFSbalBMFWRjgm5g3ejjeDz7GiF4nF4ZZI 7 | QmmCzzftWLN4MqEfuWmB2kgS0zM3iycIjgY5JlkZfApftGyTJ4oaT902clQyP6vH 8 | uHAGrCPFAgMBAAECggEBAK6NAyAgzV/PVdytkZHMcG08nFFx+l9spGYZ/yiPEzt1 9 | Gk6qScJMt1wBztOKPMsep5Y/Qi8XCipm0TzleYGq/cmi2nDxffbr40V6/hqnhEf7 10 | JdbiXUVts1tL09YivElRI98hSMfnzMBmdLPqf++qFTHCLFrlDkTaM9hrzRJKIItB 11 | hg5aSDIvInEbF9TJn+Zap+Wk81gQVnklr9ijGZGVzhZrTvqffkqnjih3VS+qwbUU 12 | QJ4ci9Br4fr5QmaM0WzypCRTboi/LBUX0mRUj2o0HDJzgZ5abAWALK71pLElf/sg 13 | 4mmGvT1JnfsBbL8L8nyMkOz3b0dTQEW9lBMFzqGrKIECgYEA81C8wyldtTMiB2Ks 14 | AV/hcRpbtCflHPVxAvqJFViabZilwD3Rgw2Zf41buwR6KgxIns1HDPLWUCOfmmka 15 | GCZGkWYRudzNhmWBTKqzstHeopCnYVLcm3qCIdLYXzLxXh9DIpm+8dngWMFu1q/9 16 | miEhkh1kpFS9EYdAx7uLrIevryECgYEA07eXYLwubgHZx9wLRe5to/v2/k2pQHUJ 17 | 7453n+QPfyoTFnMEbcIecslF5OQcSH2enqC54PDfCUQAHDjxjotn1kle3cXrvq8h 18 | 3NPWuGPSIsNhJp5z6Gb3yN/FS1LR5AGodqh4nZHagoAa9vRlzs8iho0QM3YA7uw6 19 | pN/jB8+xVCUCgYBQIFBpPKAdYd9c60OVmEuXgYSdiV3L8Y/r2TF3lBwW52P+MN1j 20 | +QCJnrWMmubYHf90PEmfnACzl2eh4+ax+TjX/PLtcCdGkPrJkpVm1/InOtfEFxOL 21 | KAbeuJ6EizQtOMJVDKhy4Lsev2SO0poDPdHeWkugSj+RHCdbHwnaITzbwQKBgD/d 22 | HIuwmCzU4BW6mafxoR8bLUlOseRgqauahRk1GTuZvIJEFazqJncnoa7G5IU1Z3ig 23 | MRHadtz7pzDcOHlwMdVg8n3haxhtCcDsIdQjQEr+NrsIhxwum0X7wi7Tf77QhTmt 24 | 3hxh19EPxZKC7Iby0o5V1PJBAU0Q8yuy4XAExZAFAoGASDQX5ViNWmmZW2M1jTow 25 | ZAdrXyCsjQNm6ZROhQczGLnttM6ZVwMz8RDM3BajfvT8yp9rWRQupENwVha+ZV9j 26 | 3acc5s3mCWv0PXHJDl6fozuDySWX7hOIFP2ARDFQzWRsC+KcDt9OcVSdgB4dLSy4 27 | IrU/CgLFtFR2anTJvOf5d7A= 28 | -----END PRIVATE KEY----- 29 | -------------------------------------------------------------------------------- /progjar5/server_async_http.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import time 3 | import sys 4 | import asyncore 5 | import logging 6 | from http import HttpServer 7 | 8 | httpserver = HttpServer() 9 | rcv = "" 10 | 11 | class ProcessTheClient(asyncore.dispatcher_with_send): 12 | def handle_read(self): 13 | global rcv 14 | data = self.recv(1024) 15 | if data: 16 | d = data.decode() 17 | rcv = rcv + d 18 | if rcv[-2:] == '\r\n': 19 | # end of command, proses string 20 | logging.warning("data dari client: {}".format(rcv)) 21 | hasil = httpserver.proses(rcv) 22 | #hasil sudah dalam bentuk bytes 23 | hasil = hasil + "\r\n\r\n".encode() 24 | #agar bisa dioperasikan dengan string \r\n\r\n maka harus diencode dulu => bytes 25 | logging.warning("balas ke client: {}".format(hasil)) 26 | self.send(hasil) #hasil sudah dalam bentuk bytes, kirimkan balik ke client 27 | rcv = "" 28 | self.close() 29 | 30 | #self.send('HTTP/1.1 200 OK \r\n\r\n'.encode()) 31 | #self.send("{}" . format(httpserver.proses(d))) 32 | self.close() 33 | 34 | class Server(asyncore.dispatcher): 35 | def __init__(self,portnumber): 36 | asyncore.dispatcher.__init__(self) 37 | self.create_socket(socket.AF_INET, socket.SOCK_STREAM) 38 | self.set_reuse_addr() 39 | self.bind(('',portnumber)) 40 | self.listen(1) 41 | logging.warning("running on port {}" . format(portnumber)) 42 | 43 | def handle_accept(self): 44 | pair = self.accept() 45 | if pair is not None: 46 | sock, addr = pair 47 | logging.warning("connection from {}" . format(repr(addr))) 48 | handler = ProcessTheClient(sock) 49 | 50 | def main(): 51 | portnumber=8887 52 | try: 53 | portnumber=int(sys.argv[1]) 54 | except: 55 | pass 56 | svr = Server(portnumber) 57 | asyncore.loop() 58 | 59 | if __name__=="__main__": 60 | main() 61 | 62 | -------------------------------------------------------------------------------- /progjar1a/server_side/certs/domain.key: -------------------------------------------------------------------------------- 1 | -----BEGIN PRIVATE KEY----- 2 | MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCrCrGy2YG5WKNl 3 | kptkeuS+6Q9+kVr9pTijfCMI6skye7cxEw/fMl9qkJtbZrh6ixxGIf0VDcZPpkd6 4 | d5GvcIgJZGVA4VBGCAwdouyySG0XCXvAU+EUIjr7BBCJ1PIUGL7dIAvgz5l+ehjR 5 | HSM8TvbplVDiR9dRcegxHljTrk/PntK4g5zAzmm83ukvN2JzgCaqyG0VY7BMGILy 6 | xg/nhu7IsE1h7gbpi1SvUQXXQyvhwLiV0IrCLqnA038kXYDr3oiyzAzNr0QTxSMG 7 | w0OHvtoiWCIluDvIunsFwmnoKKaCfW4caMVGTkvT7WJOQQG/Vu8gbmqxUkx26P19 8 | PKbV762BAgMBAAECggEASlMa1dOjheWpF0XGZbrrdLQ06fSC/C6UNqKGXOUdqeTN 9 | vbMBViV/BgExqV2xM3sIvcceQUxbjRf9/o8/zONTEfXA9BkUt2He1fAK+Av176lM 10 | z84DRCr9wz9IaoSQ7z+zjMZUswuzMR0gdJo7SgUsUWNzoujB/Z/IXLPJuK6J+vdc 11 | y5LjNWD/muLYaSoXzsA6CWKd0YC5qIXf9rW32lNwW0MnOnjERkflRCa2kVcTgEIw 12 | cnHa8CyE9bKogDvuYVTyRwgZss4rM8bhZWjJjKiNvtpl1FxkiOrTt52Pq3PgxuHJ 13 | ldUZlri9F1gla4Tr9i4GxgZs2EH3UagFYXC7KdsawwKBgQDUamCkusPNmcCSPpD0 14 | MwJ9vrpo6GREYyhrXltKzjecP00urvafZ73Vrv/ptoEApETuXJWXuPylSQ1mkdMY 15 | S2Avsl8VL191kjlvyR3pQU3lcD7KhdHFAydCA8hvEUU6b8tP1OshveTQkcTfYFIp 16 | zqBj+8Zy98TzL5Uakeyl7DrJEwKBgQDOIxAiRCDU2fAFF8sxQcDn32odHGBRzrPV 17 | N0hN+2ncisjw65b04oVZGik8c+mAs8xWDe91c5Z/eYH2+wlimOdYcKX9CQdXAOwm 18 | DHpFp4K14BBthSMlkJEZmrXKFzS4ALZUfN8nnim9j/LwDYN7ESs3G1m41sX68ch1 19 | YG6qOE01mwKBgEAcKzcMt3QiZ6C8CXvquWHCYviuyzRoyRY+0EbvnpEl+eGRJRZP 20 | dVg9DTg4wQ60hal7gBre1kH8nnLKqG+4sDs1FsWKGsGddIBsrv5rm1sYWZs+cGWJ 21 | 4htmkOQUzlQo0bAyjxUL/zeEB2tz4tiDaJ1ErEyew26yecofKNGbTtLJAoGAPPdj 22 | 0y6hIzLd6TOzVfsjibCrGrcEyc0/pMT37pB4K9EkQxT6jazdUZAKOCX0HquOuLjg 23 | ZLVuAn+2b4yppu6gJakTfrYH5LSSI2K3WxiC8TW2xh2FWpvaPl9iesXIQs97HZvd 24 | CEOgBr+nU1Y7188pH+BH9gIXhfOynPyLXm7ObxcCgYEAncxEPY2WkLAQytOVR8dF 25 | Qzxoj3n/i3Ai6OXiCelrTQoBFd8PJVSUmHgyoxgUeouF+4YaIyhv6myyI8XxLEdL 26 | K/EqoWEaL841b2gDrAAC3ccTSub4gRZ1hrPhctgdecRaTIyl3GyXq9jRH3Wf6Uy5 27 | jkLBEcW2Gp8A4xfV7e8phMs= 28 | -----END PRIVATE KEY----- 29 | -------------------------------------------------------------------------------- /progjar5/socket_proxy.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import time 5 | import sys 6 | import logging 7 | 8 | 9 | 10 | class ProcessTheClient(threading.Thread): 11 | def __init__(self, connection, address, destination_sock_address): 12 | self.destination_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 13 | self.destination_sock.connect(destination_sock_address) 14 | self.connection = connection 15 | self.address = address 16 | threading.Thread.__init__(self) 17 | 18 | def run(self): 19 | rcv="" 20 | while True: 21 | try: 22 | data = self.connection.recv(8192) 23 | if data: 24 | self.destination_sock.sendall(data) 25 | data_balasan = self.destination_sock.recv(8192) 26 | self.connection.sendall(data_balasan) 27 | logging.warning(data) 28 | logging.warning(data_balasan) 29 | 30 | else: 31 | break 32 | except OSError as e: 33 | pass 34 | self.connection.close() 35 | 36 | 37 | 38 | class Server(threading.Thread): 39 | def __init__(self): 40 | self.the_clients = [] 41 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 42 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 43 | 44 | self.destination_sock_address = ('localhost',8889) 45 | threading.Thread.__init__(self) 46 | 47 | def run(self): 48 | self.my_socket.bind(('0.0.0.0', 18000)) 49 | self.my_socket.listen(1) 50 | while True: 51 | self.connection, self.client_address = self.my_socket.accept() 52 | logging.warning("connection from {}".format(self.client_address)) 53 | 54 | clt = ProcessTheClient(self.connection, self.client_address,self.destination_sock_address) 55 | clt.start() 56 | self.the_clients.append(clt) 57 | 58 | 59 | 60 | def main(): 61 | svr = Server() 62 | svr.start() 63 | 64 | if __name__=="__main__": 65 | main() 66 | 67 | -------------------------------------------------------------------------------- /progjar1/server.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import logging 4 | 5 | logging.basicConfig(level=logging.INFO) 6 | 7 | try: 8 | # Create a TCP/IP socket 9 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 10 | #sock.settimeout(10) 11 | sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1 ) 12 | 13 | # Bind the socket to the port 14 | server_address = ('0.0.0.0', 10000) #--> gunakan 0.0.0.0 agar binding ke seluruh ip yang tersedia 15 | 16 | logging.info(f"starting up on {server_address}") 17 | sock.bind(server_address) 18 | # Listen for incoming connections 19 | sock.listen(1) 20 | #1 = backlog, merupakan jumlah dari koneksi yang belum teraccept/dilayani yang bisa ditampung, diluar jumlah 21 | # tsb, koneks akan direfuse 22 | while True: 23 | # Wait for a connection 24 | logging.info("waiting for a connection") 25 | connection, client_address = sock.accept() 26 | logging.info(f"connection from {client_address}") 27 | # Receive the data in small chunks and retransmit it 28 | while True: 29 | data = connection.recv(32) 30 | #32 -> merupakan buffersize, jumlah maksimum data yang bisa diterima sekaligus 31 | #buffersize lebih baik diset dalam power of 2 contoh: 1024,32,4096 32 | logging.info(f"received {data}") 33 | if data: 34 | logging.info("sending back data") 35 | connection.sendall(data) 36 | else: 37 | #print >>sys.stderr, 'no more data from', client_address 38 | #print(f"no more data from {client_address}") 39 | break 40 | # Clean up the connection 41 | connection.close() 42 | except Exception as ee: 43 | logging.info(f"ERROR: {str(ee)}") 44 | finally: 45 | logging.info('closing') 46 | sock.close() 47 | -------------------------------------------------------------------------------- /progjar6/async_server.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import time 3 | import sys 4 | import asyncore 5 | import logging 6 | from http import HttpServer 7 | 8 | httpserver = HttpServer() 9 | rcv = "" 10 | 11 | class ProcessTheClient(asyncore.dispatcher_with_send): 12 | def handle_read(self): 13 | global rcv 14 | data = self.recv(1024) 15 | if data: 16 | d = data.decode() 17 | rcv = rcv + d 18 | if rcv[-2:] == '\r\n': 19 | # end of command, proses string 20 | #logging.warning("data dari client: {}".format(rcv)) 21 | hasil = httpserver.proses(rcv) 22 | #hasil sudah dalam bentuk bytes 23 | hasil = hasil + "\r\n\r\n".encode() 24 | #agar bisa dioperasikan dengan string \r\n\r\n maka harus diencode dulu => bytes 25 | 26 | #nyalakan ketika proses debugging saja, jika sudah berjalan, matikan 27 | #logging.warning("balas ke client: {}".format(hasil)) 28 | self.send(hasil) #hasil sudah dalam bentuk bytes, kirimkan balik ke client 29 | rcv = "" 30 | self.close() 31 | 32 | #self.send('HTTP/1.1 200 OK \r\n\r\n'.encode()) 33 | #self.send("{}" . format(httpserver.proses(d))) 34 | self.close() 35 | 36 | class Server(asyncore.dispatcher): 37 | def __init__(self,portnumber): 38 | asyncore.dispatcher.__init__(self) 39 | self.create_socket(socket.AF_INET, socket.SOCK_STREAM) 40 | self.set_reuse_addr() 41 | self.bind(('',portnumber)) 42 | self.listen(5) 43 | logging.warning("running on port {}" . format(portnumber)) 44 | 45 | def handle_accept(self): 46 | pair = self.accept() 47 | if pair is not None: 48 | sock, addr = pair 49 | logging.warning("connection from {}" . format(repr(addr))) 50 | handler = ProcessTheClient(sock) 51 | 52 | def main(): 53 | portnumber=8887 54 | try: 55 | portnumber=int(sys.argv[1]) 56 | except: 57 | pass 58 | svr = Server(portnumber) 59 | asyncore.loop() 60 | 61 | if __name__=="__main__": 62 | main() 63 | 64 | -------------------------------------------------------------------------------- /progjar4a/file_server.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import logging 5 | import time 6 | import sys 7 | 8 | 9 | from file_protocol import FileProtocol 10 | fp = FileProtocol() 11 | 12 | 13 | class ProcessTheClient(threading.Thread): 14 | def __init__(self, connection, address): 15 | self.connection = connection 16 | self.address = address 17 | threading.Thread.__init__(self) 18 | 19 | def run(self): 20 | while True: 21 | data = self.connection.recv(32) 22 | if data: 23 | d = data.decode() 24 | hasil = fp.proses_string(d) 25 | hasil=hasil+"\r\n\r\n" 26 | self.connection.sendall(hasil.encode()) 27 | else: 28 | break 29 | self.connection.close() 30 | 31 | 32 | class Server(threading.Thread): 33 | def __init__(self,ipaddress='0.0.0.0',port=8889): 34 | self.ipinfo=(ipaddress,port) 35 | self.the_clients = [] 36 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 37 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 38 | threading.Thread.__init__(self) 39 | 40 | def run(self): 41 | logging.warning(f"server berjalan di ip address {self.ipinfo}") 42 | self.my_socket.bind(self.ipinfo) 43 | self.my_socket.listen(1) 44 | while True: 45 | self.connection, self.client_address = self.my_socket.accept() 46 | logging.warning(f"connection from {self.client_address}") 47 | 48 | clt = ProcessTheClient(self.connection, self.client_address) 49 | clt.start() 50 | self.the_clients.append(clt) 51 | 52 | 53 | def main(): 54 | svr = Server(ipaddress='0.0.0.0',port=6666) 55 | svr.start() 56 | 57 | 58 | if __name__ == "__main__": 59 | main() 60 | 61 | -------------------------------------------------------------------------------- /progjar9/server.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import logging 5 | import time 6 | import sys 7 | 8 | 9 | from protocol import PlayerServerProtocol 10 | fp = PlayerServerProtocol() 11 | 12 | 13 | class ProcessTheClient(threading.Thread): 14 | def __init__(self, connection, address): 15 | self.connection = connection 16 | self.address = address 17 | threading.Thread.__init__(self) 18 | 19 | def run(self): 20 | while True: 21 | data = self.connection.recv(32) 22 | if data: 23 | d = data.decode() 24 | hasil = fp.proses_string(d) 25 | hasil=hasil+"\r\n\r\n" 26 | self.connection.sendall(hasil.encode()) 27 | else: 28 | break 29 | self.connection.close() 30 | 31 | 32 | class Server(threading.Thread): 33 | def __init__(self,ipaddress='0.0.0.0',port=8889): 34 | self.ipinfo=(ipaddress,port) 35 | self.the_clients = [] 36 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 37 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 38 | threading.Thread.__init__(self) 39 | 40 | def run(self): 41 | logging.warning(f"server berjalan di ip address {self.ipinfo}") 42 | self.my_socket.bind(self.ipinfo) 43 | self.my_socket.listen(1) 44 | while True: 45 | self.connection, self.client_address = self.my_socket.accept() 46 | logging.warning(f"connection from {self.client_address}") 47 | 48 | clt = ProcessTheClient(self.connection, self.client_address) 49 | clt.start() 50 | self.the_clients.append(clt) 51 | 52 | 53 | def main(): 54 | svr = Server(ipaddress='0.0.0.0',port=55555) 55 | svr.start() 56 | 57 | 58 | if __name__ == "__main__": 59 | main() 60 | 61 | -------------------------------------------------------------------------------- /progjar9/client2/tank_nonet.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | import sys 3 | 4 | # Initialize Pygame 5 | pygame.init() 6 | 7 | WIDTH, HEIGHT = 640, 480 8 | screen = pygame.display.set_mode((WIDTH, HEIGHT)) 9 | pygame.display.set_caption("Progjar Tank Game") 10 | 11 | clock = pygame.time.Clock() 12 | FPS = 60 13 | 14 | image_size=(64,64) 15 | tank_images = { 16 | "up": pygame.transform.scale(pygame.image.load("p1/tank_up.png"), image_size), 17 | "down": pygame.transform.scale(pygame.image.load("p1/tank_down.png"), image_size), 18 | "left": pygame.transform.scale(pygame.image.load("p1/tank_left.png"), image_size), 19 | "right": pygame.transform.scale(pygame.image.load("p1/tank_right.png"), image_size), 20 | } 21 | 22 | class Tank: 23 | def __init__(self): 24 | self.image = tank_images["up"] 25 | self.direction = "up" 26 | self.x = WIDTH // 2 27 | self.y = HEIGHT // 2 28 | self.speed = 5 29 | 30 | def move(self, keys): 31 | if keys[pygame.K_UP]: 32 | self.y -= self.speed 33 | self.direction = "up" 34 | elif keys[pygame.K_DOWN]: 35 | self.y += self.speed 36 | self.direction = "down" 37 | elif keys[pygame.K_LEFT]: 38 | self.x -= self.speed 39 | self.direction = "left" 40 | elif keys[pygame.K_RIGHT]: 41 | self.x += self.speed 42 | self.direction = "right" 43 | self.image = tank_images[self.direction] 44 | 45 | def draw(self, surface): 46 | surface.blit(self.image, (self.x, self.y)) 47 | 48 | tank = Tank() 49 | 50 | while True: 51 | screen.fill((255, 255, 255)) 52 | 53 | for event in pygame.event.get(): 54 | if event.type == pygame.QUIT: 55 | pygame.quit() 56 | sys.exit() 57 | 58 | keys = pygame.key.get_pressed() 59 | tank.move(keys) 60 | tank.draw(screen) 61 | 62 | pygame.display.flip() 63 | clock.tick(FPS) 64 | -------------------------------------------------------------------------------- /progjar8/secure_client.py: -------------------------------------------------------------------------------- 1 | import os 2 | import socket 3 | import ssl 4 | import logging 5 | 6 | def create_socket(destination_address='localhost',port=10000): 7 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 8 | server_address = (destination_address, port) 9 | logging.warning(f"connecting to {server_address}") 10 | sock.connect(server_address) 11 | return sock 12 | 13 | def create_secure_socket(destination_address='localhost',port=10000): 14 | #get it from https://curl.se/docs/caextract.html 15 | 16 | context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) 17 | context.verify_mode=ssl.CERT_OPTIONAL 18 | context.load_verify_locations(os.getcwd() + '/domain.crt') 19 | 20 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 21 | server_address = (destination_address, port) 22 | logging.warning(f"connecting to {server_address}") 23 | sock.connect(server_address) 24 | secure_socket = context.wrap_socket(sock,server_hostname=destination_address) 25 | print(secure_socket.getpeercert()) 26 | return secure_socket 27 | 28 | 29 | def send_server(sock_connection,request_content): 30 | logging.warning('send request -->') 31 | sock_connection.sendall(request_content.encode()) 32 | buffer = "" 33 | while True: 34 | logging.warning('<--receive content') 35 | data = sock_connection.recv(32).decode() 36 | if (data): 37 | buffer += data 38 | else: 39 | break 40 | return buffer 41 | 42 | 43 | 44 | def run(): 45 | conn = create_secure_socket('localhost',8443) 46 | http_request_content = "GET / HTTP/1.1\r\n" \ 47 | "Host: localhost\r\n" \ 48 | "\r\n" \ 49 | "\r\n" 50 | hasil = send_server(sock_connection=conn, 51 | request_content=http_request_content) 52 | print(hasil) 53 | 54 | 55 | if __name__=='__main__': 56 | run() -------------------------------------------------------------------------------- /progjar9/logic_v2.py: -------------------------------------------------------------------------------- 1 | import os 2 | import json 3 | import base64 4 | from glob import glob 5 | import shelve 6 | 7 | #asumsi, hanya ada player 1, 2 , 3 8 | class PlayerServerInterface: 9 | def __init__(self): 10 | self.players = shelve.open('g.db',writeback=True) 11 | self.players['1']= "100,100" 12 | self.players['2']= "100,100" 13 | self.players['3']= "100,100" 14 | self.players_face=dict() 15 | self.players_face['1']=base64.b64encode(open('images/red.png',"rb").read()) 16 | self.players_face['2']=base64.b64encode(open('images/pink.png',"rb").read()) 17 | self.players_face['3']=base64.b64encode(open('images/cyan.png',"rb").read()) 18 | 19 | def get_all_players(self,params=[]): 20 | return dict(status='OK',players=list(self.players_face.keys())) 21 | 22 | def get_players_face(self, params=[]): 23 | pnum=params[0] 24 | try: 25 | return dict(status='OK',face=self.players_face[pnum].decode()) 26 | except Exception as ee: 27 | return dict(status='ERROR') 28 | 29 | def set_location(self,params=[]): 30 | pnum = params[0] 31 | x = params[1] 32 | y = params[2] 33 | try: 34 | self.players[pnum]=f"{x},{y}" 35 | self.players.sync() 36 | return dict(status='OK', player=pnum) 37 | except Exception as e: 38 | return dict(status='ERROR') 39 | 40 | def get_location(self,params=[]): 41 | pnum = params[0] 42 | try: 43 | return dict(status='OK',location=self.players[pnum]) 44 | except Exception as ee: 45 | return dict(status='ERROR') 46 | 47 | 48 | 49 | if __name__=='__main__': 50 | p = PlayerServerInterface() 51 | p.set_location(['1',100,100]) 52 | print(p.get_location('1')) 53 | p.set_location(['2',120,100]) 54 | print(p.get_location('2')) 55 | print(p.get_players_face('1')) 56 | print(p.get_all_players()) 57 | -------------------------------------------------------------------------------- /progjar3/threading_examples/server_thread_time.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import logging 5 | import time 6 | import sys 7 | 8 | def proses_string(request_string): 9 | balas = "ERROR\r\n" 10 | if (request_string.startswith("TIME") and request_string.endswith("\n")): 11 | from datetime import datetime 12 | now = datetime.now() 13 | waktu = now.strftime("%d-%m-%Y %H:%M:%S") 14 | balas=f"JAM {waktu}\r\n" 15 | if (request_string.startswith("QUIT") and request_string.endswith("\n")): 16 | balas="XXX" 17 | return balas 18 | 19 | 20 | class ProcessTheClient(threading.Thread): 21 | def __init__(self,connection,address): 22 | self.connection = connection 23 | self.address = address 24 | threading.Thread.__init__(self) 25 | def run(self): 26 | while True: 27 | data = self.connection.recv(32) 28 | if data: 29 | request_s = data.decode() 30 | balas = proses_string(request_s) 31 | if (balas == "XXX"): 32 | self.connection.close() 33 | break 34 | self.connection.sendall(balas.encode()) 35 | else: 36 | break 37 | self.connection.close() 38 | 39 | class Server(threading.Thread): 40 | def __init__(self): 41 | self.the_clients = [] 42 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 43 | threading.Thread.__init__(self) 44 | 45 | def run(self): 46 | self.my_socket.bind(('0.0.0.0',51000)) 47 | self.my_socket.listen(1) 48 | while True: 49 | self.connection, self.client_address = self.my_socket.accept() 50 | logging.warning(f"connection from {self.client_address}") 51 | 52 | clt = ProcessTheClient(self.connection, self.client_address) 53 | clt.start() 54 | self.the_clients.append(clt) 55 | 56 | 57 | def main(): 58 | svr = Server() 59 | svr.start() 60 | 61 | if __name__=="__main__": 62 | main() 63 | 64 | -------------------------------------------------------------------------------- /progjar4b/person_machine.py: -------------------------------------------------------------------------------- 1 | from person import Person 2 | import json 3 | import logging 4 | 5 | ''' 6 | PROTOCOL FORMAT 7 | 8 | string terbagi menjadi 2 bagian, dipisahkan oleh spasi 9 | COMMAND spasi PARAMETER spasi PARAMETER ... 10 | 11 | FITUR 12 | 13 | - create : untuk membuat record 14 | request : create 15 | parameter : nama spasi notelpon 16 | response : berhasil -> ok 17 | gagal -> error 18 | 19 | - delete : untuk menghapus record 20 | request: delete 21 | parameter : id 22 | response: berhasil -> OK 23 | gagal -> ERROR 24 | 25 | - list : untuk melihat daftar record 26 | request: list 27 | parameter: tidak ada 28 | response: daftar record person yang ada 29 | 30 | - get : untuk mencari record berdasar nama 31 | request: get 32 | parameter: nama yang dicari 33 | response: record yang dicari dalam bentuk json format 34 | 35 | - jika command tidak dikenali akan merespon dengan ERRCMD 36 | 37 | ''' 38 | p = Person() 39 | 40 | class PersonMachine: 41 | def proses(self,string_to_process): 42 | s = string_to_process 43 | cstring = s.split(" ") 44 | try: 45 | command = cstring[0].strip() 46 | if (command=='create'): 47 | logging.warning("create") 48 | nama = cstring[1].strip() 49 | notelpon = cstring[2].strip() 50 | p.create_data(nama,notelpon) 51 | return "OK" 52 | elif (command=='list'): 53 | logging.warning("list") 54 | hasil = p.list_data() 55 | return json.dumps(hasil) 56 | elif (command=='get'): 57 | logging.warning("list") 58 | nama = cstring[1].strip() 59 | hasil = p.get_data(nama) 60 | return json.dumps(hasil) 61 | else: 62 | return "ERRCMD" 63 | except: 64 | return "ERROR" 65 | 66 | 67 | if __name__=='__main__': 68 | pm = PersonMachine() 69 | hasil = pm.proses("list") 70 | print(hasil) 71 | hasil = pm.proses("get vanbasten") 72 | print(hasil) -------------------------------------------------------------------------------- /progjar5/server_thread_http.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import time 5 | import sys 6 | import logging 7 | from http import HttpServer 8 | 9 | httpserver = HttpServer() 10 | 11 | 12 | class ProcessTheClient(threading.Thread): 13 | def __init__(self, connection, address): 14 | self.connection = connection 15 | self.address = address 16 | threading.Thread.__init__(self) 17 | 18 | def run(self): 19 | rcv="" 20 | while True: 21 | try: 22 | data = self.connection.recv(32) 23 | if data: 24 | #merubah input dari socket (berupa bytes) ke dalam string 25 | #agar bisa mendeteksi \r\n 26 | d = data.decode() 27 | rcv=rcv+d 28 | if rcv[-2:]=='\r\n': 29 | #end of command, proses string 30 | logging.warning("data dari client: {}" . format(rcv)) 31 | hasil = httpserver.proses(rcv) 32 | #hasil akan berupa bytes 33 | #untuk bisa ditambahi dengan string, maka string harus di encode 34 | hasil=hasil+"\r\n\r\n".encode() 35 | logging.warning("balas ke client: {}" . format(hasil)) 36 | #hasil sudah dalam bentuk bytes 37 | self.connection.sendall(hasil) 38 | rcv="" 39 | self.connection.close() 40 | else: 41 | break 42 | except OSError as e: 43 | pass 44 | self.connection.close() 45 | 46 | 47 | 48 | class Server(threading.Thread): 49 | def __init__(self): 50 | self.the_clients = [] 51 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 52 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 53 | threading.Thread.__init__(self) 54 | 55 | def run(self): 56 | self.my_socket.bind(('0.0.0.0', 8889)) 57 | self.my_socket.listen(1) 58 | while True: 59 | self.connection, self.client_address = self.my_socket.accept() 60 | logging.warning("connection from {}".format(self.client_address)) 61 | 62 | clt = ProcessTheClient(self.connection, self.client_address) 63 | clt.start() 64 | self.the_clients.append(clt) 65 | 66 | 67 | 68 | def main(): 69 | svr = Server() 70 | svr.start() 71 | 72 | if __name__=="__main__": 73 | main() 74 | 75 | -------------------------------------------------------------------------------- /progjar2/dns2.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import random 3 | import struct 4 | 5 | def create_query(domain): 6 | # Header: [Transaction ID][Flags][Questions][Answer RRs][Authority RRs][Additional RRs] 7 | tid = random.randint(0, 65535) 8 | flags = 0x0100 # standard query 9 | qdcount = 1 10 | header = struct.pack(">HHHHHH", tid, flags, qdcount, 0, 0, 0) 11 | 12 | def encode_domain(domain): 13 | parts = domain.split(".") 14 | result = b''.join([bytes([len(part)]) + part.encode() for part in parts]) + b'\x00' 15 | return result 16 | 17 | qname = encode_domain(domain) 18 | qtype = 1 # A 19 | qclass = 1 # IN 20 | question = qname + struct.pack(">HH", qtype, qclass) 21 | 22 | return tid, header + question 23 | 24 | def parse_response(data): 25 | tid, flags, qdcount, ancount, _, _ = struct.unpack(">HHHHHH", data[:12]) 26 | offset = 12 27 | for _ in range(qdcount): 28 | while data[offset] != 0: 29 | offset += data[offset] + 1 30 | offset += 5 # null byte + qtype (2) + qclass (2) 31 | 32 | # Parse answers 33 | answers = [] 34 | for _ in range(ancount): 35 | offset += 2 # name (compressed) 36 | rtype, rclass, ttl, rdlength = struct.unpack(">HHIH", data[offset:offset+10]) 37 | offset += 10 38 | rdata = data[offset:offset+rdlength] 39 | offset += rdlength 40 | if rtype == 1 and rclass == 1: # A, IN 41 | ip = ".".join(str(b) for b in rdata) 42 | answers.append(ip) 43 | return answers 44 | 45 | def dns_query(domain, dns_server='8.8.8.8'): 46 | tid, query = create_query(domain) 47 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 48 | sock.settimeout(2) 49 | sock.sendto(query, (dns_server, 53)) 50 | try: 51 | data, _ = sock.recvfrom(512) 52 | ips = parse_response(data) 53 | print(f"[+] {domain} resolved to: {ips}") 54 | except socket.timeout: 55 | print("[!] DNS query timed out") 56 | finally: 57 | sock.close() 58 | 59 | if __name__ == "__main__": 60 | dns_query("www.its.ac.id",dns_server='8.8.8.8') 61 | 62 | -------------------------------------------------------------------------------- /progjar5/server_process_http.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import time 4 | import sys 5 | import logging 6 | import multiprocessing 7 | from http import HttpServer 8 | 9 | httpserver = HttpServer() 10 | 11 | 12 | class ProcessTheClient(multiprocessing.Process): 13 | def __init__(self, connection, address): 14 | self.connection = connection 15 | self.address = address 16 | multiprocessing.Process.__init__(self) 17 | 18 | def run(self): 19 | rcv="" 20 | while True: 21 | try: 22 | data = self.connection.recv(32) 23 | if data: 24 | #merubah input dari socket (berupa bytes) ke dalam string 25 | #agar bisa mendeteksi \r\n 26 | d = data.decode() 27 | rcv=rcv+d 28 | if rcv[-2:]=='\r\n': 29 | #end of command, proses string 30 | #logging.warning("data dari client: {}" . format(rcv)) 31 | hasil = httpserver.proses(rcv) 32 | #hasil akan berupa bytes 33 | #untuk bisa ditambahi dengan string, maka string harus di encode 34 | hasil=hasil+"\r\n\r\n".encode() 35 | #logging.warning("balas ke client: {}" . format(hasil)) 36 | #hasil sudah dalam bentuk bytes 37 | self.connection.sendall(hasil) 38 | rcv="" 39 | self.connection.close() 40 | else: 41 | break 42 | except OSError as e: 43 | pass 44 | self.connection.close() 45 | 46 | 47 | 48 | class Server(multiprocessing.Process): 49 | def __init__(self): 50 | self.the_clients = [] 51 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 52 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 53 | multiprocessing.Process.__init__(self) 54 | 55 | def run(self): 56 | self.my_socket.bind(('0.0.0.0', 8889)) 57 | self.my_socket.listen(1) 58 | while True: 59 | self.connection, self.client_address = self.my_socket.accept() 60 | logging.warning("connection from {}".format(self.client_address)) 61 | 62 | clt = ProcessTheClient(self.connection, self.client_address) 63 | clt.start() 64 | self.the_clients.append(clt) 65 | 66 | 67 | 68 | def main(): 69 | svr = Server() 70 | svr.start() 71 | 72 | if __name__=="__main__": 73 | main() 74 | 75 | -------------------------------------------------------------------------------- /progjar3/concurrency/library.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import requests 3 | import os 4 | import time 5 | import datetime 6 | 7 | 8 | def get_url_list(): 9 | urls = dict() 10 | urls['kompas']='https://asset.kompas.com/crops/qz_jJxyaZgGgboomdCEXsfbSpec=/0x0:998x665/740x500/data/photo/2020/03/01/5e5b52f4db896.jpg' 11 | urls['its']='https://www.its.ac.id/wp-content/uploads/2017/10/logo-its-1.png' 12 | urls['detik']='https://akcdn.detik.net.id/community/media/visual/2021/04/22/detikcom-ramadan-desktop-1.gif?d=1' 13 | urls['file1']='https://images-assets.nasa.gov/image/PIA21073/PIA21073~orig.jpg' 14 | #urls['file2']='https://file-examples-com.github.io/uploads/2018/04/file_example_MOV_1280_1_4MB.mov' 15 | urls['file3']='https://file-examples-com.github.io/uploads/2017/02/zip_2MB.zip' 16 | return urls 17 | 18 | 19 | def download_gambar(url=None,tuliskefile=False): 20 | waktu_awal = datetime.datetime.now() 21 | if (url is None): 22 | return False 23 | ff = requests.get(url) 24 | tipe = dict() 25 | tipe['image/png']='png' 26 | tipe['image/jpg']='jpg' 27 | tipe['image/gif']='gif' 28 | tipe['image/jpeg']='jpg' 29 | tipe['application/zip']='jpg' 30 | tipe['video/quicktime']='mov' 31 | time.sleep(2) #untuk simulasi, diberi tambahan delay 2 detik 32 | 33 | content_type = ff.headers['Content-Type'] 34 | logging.warning(content_type) 35 | if (content_type in list(tipe.keys())): 36 | namafile = os.path.basename(url) 37 | ekstensi = tipe[content_type] 38 | if (tuliskefile): 39 | fp = open(f"{namafile}.{ekstensi}","wb") 40 | fp.write(ff.content) 41 | fp.close() 42 | waktu_process = datetime.datetime.now() - waktu_awal 43 | waktu_akhir =datetime.datetime.now() 44 | logging.warning(f"writing {namafile}.{ekstensi} dalam waktu {waktu_process} {waktu_awal} s/d {waktu_akhir}") 45 | return waktu_process 46 | else: 47 | return False 48 | 49 | 50 | 51 | 52 | if __name__=='__main__': 53 | #check fungsi 54 | k = download_gambar('https://asset.kompas.com/crops/qz_jJxyaZgGgboomdCEXsfbSpec=/0x0:998x665/740x500/data/photo/2020/03/01/5e5b52f4db896.jpg') 55 | print(k) 56 | -------------------------------------------------------------------------------- /progjar5/server_process_pool_http.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import time 4 | import sys 5 | import logging 6 | import multiprocessing 7 | from concurrent.futures import ProcessPoolExecutor 8 | from http import HttpServer 9 | 10 | httpserver = HttpServer() 11 | 12 | #untuk menggunakan processpoolexecutor, karena tidak mendukung subclassing pada process, 13 | #maka class ProcessTheClient dirubah dulu menjadi function, tanpda memodifikasi behaviour didalamnya 14 | 15 | def ProcessTheClient(connection,address): 16 | rcv="" 17 | while True: 18 | try: 19 | data = connection.recv(32) 20 | if data: 21 | #merubah input dari socket (berupa bytes) ke dalam string 22 | #agar bisa mendeteksi \r\n 23 | d = data.decode() 24 | rcv=rcv+d 25 | if rcv[-2:]=='\r\n': 26 | #end of command, proses string 27 | #logging.warning("data dari client: {}" . format(rcv)) 28 | hasil = httpserver.proses(rcv) 29 | #hasil akan berupa bytes 30 | #untuk bisa ditambahi dengan string, maka string harus di encode 31 | hasil=hasil+"\r\n\r\n".encode() 32 | #logging.warning("balas ke client: {}" . format(hasil)) 33 | #hasil sudah dalam bentuk bytes 34 | connection.sendall(hasil) 35 | rcv="" 36 | connection.close() 37 | return 38 | else: 39 | break 40 | except OSError as e: 41 | pass 42 | connection.close() 43 | return 44 | 45 | 46 | 47 | def Server(): 48 | the_clients = [] 49 | my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 50 | my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 51 | 52 | my_socket.bind(('0.0.0.0', 8889)) 53 | my_socket.listen(1) 54 | 55 | with ProcessPoolExecutor(20) as executor: 56 | while True: 57 | connection, client_address = my_socket.accept() 58 | #logging.warning("connection from {}".format(client_address)) 59 | p = executor.submit(ProcessTheClient, connection, client_address) 60 | the_clients.append(p) 61 | #menampilkan jumlah process yang sedang aktif 62 | jumlah = ['x' for i in the_clients if i.running()==True] 63 | print(jumlah) 64 | 65 | 66 | 67 | 68 | 69 | def main(): 70 | Server() 71 | 72 | if __name__=="__main__": 73 | main() 74 | 75 | -------------------------------------------------------------------------------- /progjar5/server_thread_pool_http.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import time 4 | import sys 5 | import logging 6 | import multiprocessing 7 | from concurrent.futures import ThreadPoolExecutor 8 | from http import HttpServer 9 | 10 | httpserver = HttpServer() 11 | 12 | #untuk menggunakan threadpool executor, karena tidak mendukung subclassing pada process, 13 | #maka class ProcessTheClient dirubah dulu menjadi function, tanpda memodifikasi behaviour didalamnya 14 | 15 | def ProcessTheClient(connection,address): 16 | rcv="" 17 | while True: 18 | try: 19 | data = connection.recv(32) 20 | if data: 21 | #merubah input dari socket (berupa bytes) ke dalam string 22 | #agar bisa mendeteksi \r\n 23 | d = data.decode() 24 | rcv=rcv+d 25 | if rcv[-2:]=='\r\n': 26 | #end of command, proses string 27 | #logging.warning("data dari client: {}" . format(rcv)) 28 | hasil = httpserver.proses(rcv) 29 | #hasil akan berupa bytes 30 | #untuk bisa ditambahi dengan string, maka string harus di encode 31 | hasil=hasil+"\r\n\r\n".encode() 32 | #logging.warning("balas ke client: {}" . format(hasil)) 33 | #hasil sudah dalam bentuk bytes 34 | connection.sendall(hasil) 35 | rcv="" 36 | connection.close() 37 | return 38 | else: 39 | break 40 | except OSError as e: 41 | pass 42 | connection.close() 43 | return 44 | 45 | 46 | 47 | def Server(): 48 | the_clients = [] 49 | my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 50 | my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 51 | 52 | my_socket.bind(('0.0.0.0', 8885)) 53 | my_socket.listen(1) 54 | 55 | with ThreadPoolExecutor(20) as executor: 56 | while True: 57 | connection, client_address = my_socket.accept() 58 | #logging.warning("connection from {}".format(client_address)) 59 | p = executor.submit(ProcessTheClient, connection, client_address) 60 | the_clients.append(p) 61 | #menampilkan jumlah process yang sedang aktif 62 | jumlah = ['x' for i in the_clients if i.running()==True] 63 | print(jumlah) 64 | 65 | 66 | 67 | 68 | 69 | def main(): 70 | Server() 71 | 72 | if __name__=="__main__": 73 | main() 74 | 75 | -------------------------------------------------------------------------------- /progjar3/concurrency_asyncio/library.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import asyncio 3 | import os 4 | import time 5 | import datetime 6 | import requests 7 | 8 | 9 | async def get_url_list(): 10 | urls = dict() 11 | urls['kompas']='https://asset.kompas.com/crops/qz_jJxyaZgGgboomdCEXsfbSpec=/0x0:998x665/740x500/data/photo/2020/03/01/5e5b52f4db896.jpg' 12 | urls['its']='https://www.its.ac.id/wp-content/uploads/2017/10/logo-its-1.png' 13 | urls['detik']='https://akcdn.detik.net.id/community/media/visual/2021/04/22/detikcom-ramadan-desktop-1.gif?d=1' 14 | urls['file1']='https://file-examples-com.github.io/uploads/2018/04/file_example_MOV_480_700kB.mov' 15 | urls['file2']='https://file-examples-com.github.io/uploads/2018/04/file_example_MOV_1280_1_4MB.mov' 16 | urls['file3']='https://file-examples-com.github.io/uploads/2017/02/zip_2MB.zip' 17 | return urls 18 | 19 | 20 | async def download_gambar(url=None,tuliskefile=False): 21 | waktu_awal = datetime.datetime.now() 22 | if (url is None): 23 | return False 24 | ff = requests.get(url) 25 | tipe = dict() 26 | tipe['image/png']='png' 27 | tipe['image/jpg']='jpg' 28 | tipe['image/gif']='gif' 29 | tipe['image/jpeg']='jpg' 30 | tipe['application/zip']='jpg' 31 | tipe['video/quicktime']='mov' 32 | time.sleep(2) #untuk simulasi, diberi tambahan delay 2 detik 33 | 34 | content_type = ff.headers['Content-Type'] 35 | logging.warning(content_type) 36 | if (content_type in list(tipe.keys())): 37 | namafile = os.path.basename(url) 38 | ekstensi = tipe[content_type] 39 | if (tuliskefile): 40 | fp = open(f"{namafile}.{ekstensi}","wb") 41 | fp.write(ff.content) 42 | fp.close() 43 | waktu_process = datetime.datetime.now() - waktu_awal 44 | waktu_akhir =datetime.datetime.now() 45 | logging.warning(f"writing {namafile}.{ekstensi} dalam waktu {waktu_process} {waktu_awal} s/d {waktu_akhir}") 46 | return waktu_process 47 | else: 48 | return False 49 | 50 | async def main(): 51 | await download_gambar('https://asset.kompas.com/crops/qz_jJxyaZgGgboomdCEXsfbSpec=/0x0:998x665/740x500/data/photo/2020/03/01/5e5b52f4db896.jpg') 52 | 53 | 54 | if __name__=='__main__': 55 | asyncio.run(main()) 56 | -------------------------------------------------------------------------------- /environment-demo/app/server/server.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import time 5 | import sys 6 | import json 7 | import logging 8 | import os 9 | from chat import Chat 10 | 11 | SERVER_IP=os.getenv('SERVER_IP') or "0.0.0.0" 12 | SERVER_PORT=os.getenv('SERVER_PORT') or "8889" 13 | 14 | chatserver = Chat() 15 | 16 | class ProcessTheClient(threading.Thread): 17 | def __init__(self, connection, address): 18 | self.connection = connection 19 | self.address = address 20 | threading.Thread.__init__(self) 21 | 22 | def run(self): 23 | rcv="" 24 | while True: 25 | data = self.connection.recv(32) 26 | if data: 27 | d = data.decode() 28 | rcv=rcv+d 29 | if rcv[-2:]=='\r\n': 30 | #end of command, proses string 31 | logging.warning("data dari client: {}" . format(rcv)) 32 | hasil = json.dumps(chatserver.proses(rcv)) 33 | hasil=hasil+"\r\n\r\n" 34 | logging.warning("balas ke client: {}" . format(hasil)) 35 | self.connection.sendall(hasil.encode()) 36 | rcv="" 37 | else: 38 | break 39 | self.connection.close() 40 | 41 | class Server(threading.Thread): 42 | def __init__(self): 43 | self.the_clients = [] 44 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 45 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 46 | threading.Thread.__init__(self) 47 | 48 | def run(self): 49 | self.my_socket.bind((SERVER_IP,int(SERVER_PORT))) 50 | self.my_socket.listen(1) 51 | while True: 52 | self.connection, self.client_address = self.my_socket.accept() 53 | logging.warning("connection from {}" . format(self.client_address)) 54 | 55 | clt = ProcessTheClient(self.connection, self.client_address) 56 | clt.start() 57 | self.the_clients.append(clt) 58 | 59 | 60 | def main(): 61 | svr = Server() 62 | svr.start() 63 | 64 | if __name__=="__main__": 65 | main() 66 | 67 | -------------------------------------------------------------------------------- /progjar6/server_process_pool_http.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import time 4 | import sys 5 | import logging 6 | import multiprocessing 7 | from concurrent.futures import ProcessPoolExecutor 8 | from http import HttpServer 9 | 10 | httpserver = HttpServer() 11 | 12 | #untuk menggunakan processpoolexecutor, karena tidak mendukung subclassing pada process, 13 | #maka class ProcessTheClient dirubah dulu menjadi function, tanpda memodifikasi behaviour didalamnya 14 | 15 | def ProcessTheClient(connection,address): 16 | rcv="" 17 | while True: 18 | try: 19 | data = connection.recv(32) 20 | if data: 21 | #merubah input dari socket (berupa bytes) ke dalam string 22 | #agar bisa mendeteksi \r\n 23 | d = data.decode() 24 | rcv=rcv+d 25 | if rcv[-2:]=='\r\n': 26 | #end of command, proses string 27 | logging.warning("data dari client: {}" . format(rcv)) 28 | hasil = httpserver.proses(rcv) 29 | #hasil akan berupa bytes 30 | #untuk bisa ditambahi dengan string, maka string harus di encode 31 | hasil=hasil+"\r\n\r\n".encode() 32 | logging.warning("balas ke client: {}" . format(hasil)) 33 | #hasil sudah dalam bentuk bytes 34 | connection.sendall(hasil) 35 | rcv="" 36 | connection.close() 37 | return 38 | else: 39 | break 40 | except OSError as e: 41 | pass 42 | connection.close() 43 | return 44 | 45 | 46 | 47 | def Server(portnumber=8889): 48 | the_clients = [] 49 | my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 50 | my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 51 | 52 | my_socket.bind(('0.0.0.0', portnumber)) 53 | my_socket.listen(1) 54 | 55 | with ProcessPoolExecutor(20) as executor: 56 | while True: 57 | connection, client_address = my_socket.accept() 58 | #logging.warning("connection from {}".format(client_address)) 59 | p = executor.submit(ProcessTheClient, connection, client_address) 60 | the_clients.append(p) 61 | #menampilkan jumlah process yang sedang aktif 62 | jumlah = ['x' for i in the_clients if i.running()==True] 63 | print(jumlah) 64 | 65 | 66 | 67 | 68 | 69 | def main(): 70 | portnumber=8000 71 | try: 72 | portnumber=int(sys.argv[1]) 73 | except: 74 | pass 75 | svr = Server(portnumber) 76 | 77 | if __name__=="__main__": 78 | main() 79 | 80 | -------------------------------------------------------------------------------- /progjar10/server.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import threading 4 | import logging 5 | import time 6 | import sys 7 | 8 | 9 | from protocol import PlayerServerProtocol 10 | fp = PlayerServerProtocol() 11 | 12 | 13 | class ProcessTheClient(threading.Thread): 14 | def __init__(self, connection, address): 15 | self.connection = connection 16 | self.address = address 17 | threading.Thread.__init__(self) 18 | 19 | def run(self): 20 | rcv="" 21 | while True: 22 | try: 23 | data = self.connection.recv(32) 24 | if data: 25 | #merubah input dari socket (berupa bytes) ke dalam string 26 | #agar bisa mendeteksi \r\n 27 | d = data.decode() 28 | rcv=rcv+d 29 | if rcv[-2:]=='\r\n': 30 | #end of command, proses string 31 | logging.warning("data dari client: {}" . format(rcv)) 32 | hasil = fp.proses_string(rcv) 33 | #hasil akan berupa bytes 34 | #untuk bisa ditambahi dengan string, maka string harus di encode 35 | hasil=hasil.encode()+"\r\n\r\n".encode() 36 | logging.warning("balas ke client: {}" . format(hasil)) 37 | #hasil sudah dalam bentuk bytes 38 | self.connection.sendall(hasil) 39 | rcv="" 40 | self.connection.close() 41 | else: 42 | break 43 | except OSError as e: 44 | pass 45 | self.connection.close() 46 | 47 | 48 | class Server(threading.Thread): 49 | def __init__(self,ipaddress='0.0.0.0',port=8889): 50 | self.ipinfo=(ipaddress,port) 51 | self.the_clients = [] 52 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 53 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 54 | threading.Thread.__init__(self) 55 | 56 | def run(self): 57 | logging.warning(f"server berjalan di ip address {self.ipinfo}") 58 | self.my_socket.bind(self.ipinfo) 59 | self.my_socket.listen(1) 60 | while True: 61 | self.connection, self.client_address = self.my_socket.accept() 62 | logging.warning(f"connection from {self.client_address}") 63 | 64 | clt = ProcessTheClient(self.connection, self.client_address) 65 | clt.start() 66 | self.the_clients.append(clt) 67 | 68 | 69 | def main(): 70 | svr = Server(ipaddress='0.0.0.0',port=6666) 71 | svr.start() 72 | 73 | 74 | if __name__ == "__main__": 75 | main() 76 | 77 | -------------------------------------------------------------------------------- /environment/docker-compose.yml: -------------------------------------------------------------------------------- 1 | version: '2' 2 | services: 3 | mesin1: 4 | container_name: progjar-mesin-1 5 | image: royyana/progjar-jupyter:latest 6 | user: root 7 | privileged: true 8 | cap_add: 9 | - NET_RAW 10 | - ALL 11 | - NET_ADMIN 12 | ports: 13 | - "60001:8888" 14 | - "50001:6666" 15 | - "55555:55555" 16 | environment: 17 | - "DOCKER_STACKS_JUPYTER_CMD=lab" 18 | - "GRANT_SUDO=yes" 19 | - "PASSWORD=mesin1" 20 | working_dir: /home/jovyan/work 21 | volumes: 22 | - ./work1:/home/jovyan/work 23 | networks: 24 | default: 25 | priority: 1 26 | progjar-network: 27 | priority: 2 28 | ipv4_address: "172.16.16.101" 29 | mesin2: 30 | container_name: progjar-mesin-2 31 | image: royyana/progjar-jupyter:latest 32 | user: root 33 | privileged: true 34 | cap_add: 35 | - NET_RAW 36 | - ALL 37 | - NET_ADMIN 38 | ports: 39 | - "60002:8888" 40 | - "50002:6666" 41 | environment: 42 | - "DOCKER_STACKS_JUPYTER_CMD=lab" 43 | - "GRANT_SUDO=yes" 44 | - "PASSWORD=mesin2" 45 | working_dir: /home/jovyan/work 46 | volumes: 47 | - ./work2:/home/jovyan/work 48 | networks: 49 | default: 50 | priority: 1 51 | progjar-network: 52 | priority: 2 53 | ipv4_address: "172.16.16.102" 54 | mesin3: 55 | container_name: progjar-mesin-3 56 | image: royyana/progjar-jupyter:latest 57 | user: root 58 | privileged: true 59 | cap_add: 60 | - NET_RAW 61 | - ALL 62 | - NET_ADMIN 63 | ports: 64 | - "60003:8888" 65 | - "50003:6666" 66 | environment: 67 | - "DOCKER_STACKS_JUPYTER_CMD=lab" 68 | - "GRANT_SUDO=yes" 69 | - "PASSWORD=mesin3" 70 | working_dir: /home/jovyan/work 71 | volumes: 72 | - ./work3:/home/jovyan/work 73 | networks: 74 | default: 75 | priority: 1 76 | progjar-network: 77 | priority: 2 78 | ipv4_address: "172.16.16.103" 79 | networks: 80 | default: 81 | driver: bridge 82 | progjar-network: 83 | name: progjar-network 84 | driver: bridge 85 | driver_opts: 86 | com.docker.network.bridge.enable_icc: "true" 87 | com.docker.network.bridge.name: "progjar-network" 88 | ipam: 89 | driver: default 90 | config: 91 | - subnet: 172.16.16.0/24 92 | gateway: 172.16.16.1 93 | 94 | 95 | -------------------------------------------------------------------------------- /progjar6/lb_async.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import time 3 | import sys 4 | import asyncore 5 | import logging 6 | 7 | 8 | class BackendList: 9 | def __init__(self): 10 | self.servers=[] 11 | self.servers.append(('127.0.0.1',8000)) 12 | self.servers.append(('127.0.0.1',8001)) 13 | self.servers.append(('127.0.0.1',8002)) 14 | # self.servers.append(('127.0.0.1',9005)) 15 | self.current=0 16 | def getserver(self): 17 | s = self.servers[self.current] 18 | self.current=self.current+1 19 | if (self.current>=len(self.servers)): 20 | self.current=0 21 | return s 22 | 23 | 24 | class Backend(asyncore.dispatcher_with_send): 25 | def __init__(self,targetaddress): 26 | asyncore.dispatcher_with_send.__init__(self) 27 | self.create_socket(socket.AF_INET, socket.SOCK_STREAM) 28 | self.connect(targetaddress) 29 | self.connection = self 30 | 31 | def handle_read(self): 32 | try: 33 | self.client_socket.send(self.recv(32)) 34 | except: 35 | pass 36 | def handle_close(self): 37 | try: 38 | self.close() 39 | self.client_socket.close() 40 | except: 41 | pass 42 | 43 | 44 | class ProcessTheClient(asyncore.dispatcher): 45 | def handle_read(self): 46 | data = self.recv(32) 47 | if data: 48 | self.backend.client_socket = self 49 | self.backend.send(data) 50 | def handle_close(self): 51 | self.close() 52 | 53 | class Server(asyncore.dispatcher): 54 | def __init__(self,portnumber): 55 | asyncore.dispatcher.__init__(self) 56 | self.create_socket(socket.AF_INET, socket.SOCK_STREAM) 57 | self.set_reuse_addr() 58 | self.bind(('',portnumber)) 59 | self.listen(5) 60 | self.bservers = BackendList() 61 | logging.warning("load balancer running on port {}" . format(portnumber)) 62 | 63 | def handle_accept(self): 64 | pair = self.accept() 65 | if pair is not None: 66 | sock, addr = pair 67 | logging.warning("connection from {}" . format(repr(addr))) 68 | 69 | #menentukan ke server mana request akan diteruskan 70 | bs = self.bservers.getserver() 71 | logging.warning("koneksi dari {} diteruskan ke {}" . format(addr, bs)) 72 | backend = Backend(bs) 73 | 74 | #mendapatkan handler dan socket dari client 75 | handler = ProcessTheClient(sock) 76 | handler.backend = backend 77 | 78 | 79 | def main(): 80 | portnumber=55555 81 | try: 82 | portnumber=int(sys.argv[1]) 83 | except: 84 | pass 85 | svr = Server(portnumber) 86 | asyncore.loop() 87 | 88 | if __name__=="__main__": 89 | main() 90 | 91 | 92 | -------------------------------------------------------------------------------- /progjar4a/file_client_cli.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import json 3 | import base64 4 | import logging 5 | 6 | server_address=('0.0.0.0',7777) 7 | 8 | def send_command(command_str=""): 9 | global server_address 10 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 11 | sock.connect(server_address) 12 | logging.warning(f"connecting to {server_address}") 13 | try: 14 | logging.warning(f"sending message ") 15 | sock.sendall(command_str.encode()) 16 | # Look for the response, waiting until socket is done (no more data) 17 | data_received="" #empty string 18 | while True: 19 | #socket does not receive all data at once, data comes in part, need to be concatenated at the end of process 20 | data = sock.recv(16) 21 | if data: 22 | #data is not empty, concat with previous content 23 | data_received += data.decode() 24 | if "\r\n\r\n" in data_received: 25 | break 26 | else: 27 | # no more data, stop the process by break 28 | break 29 | # at this point, data_received (string) will contain all data coming from the socket 30 | # to be able to use the data_received as a dict, need to load it using json.loads() 31 | hasil = json.loads(data_received) 32 | logging.warning("data received from server:") 33 | return hasil 34 | except: 35 | logging.warning("error during data receiving") 36 | return False 37 | 38 | 39 | def remote_list(): 40 | command_str=f"LIST" 41 | hasil = send_command(command_str) 42 | if (hasil['status']=='OK'): 43 | print("daftar file : ") 44 | for nmfile in hasil['data']: 45 | print(f"- {nmfile}") 46 | return True 47 | else: 48 | print("Gagal") 49 | return False 50 | 51 | def remote_get(filename=""): 52 | command_str=f"GET {filename}" 53 | hasil = send_command(command_str) 54 | if (hasil['status']=='OK'): 55 | #proses file dalam bentuk base64 ke bentuk bytes 56 | namafile= hasil['data_namafile'] 57 | isifile = base64.b64decode(hasil['data_file']) 58 | fp = open(namafile,'wb+') 59 | fp.write(isifile) 60 | fp.close() 61 | return True 62 | else: 63 | print("Gagal") 64 | return False 65 | 66 | 67 | if __name__=='__main__': 68 | server_address=('172.16.16.101',6666) 69 | remote_list() 70 | remote_get('donalbebek.jpg') 71 | 72 | -------------------------------------------------------------------------------- /progjar1a/insecure_proxy.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import os 3 | import logging 4 | from threading import Thread 5 | 6 | def make_realserver_socket(server_address): 7 | try: 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 9 | logging.warning(f"connecting to {server_address}") 10 | sock.connect(server_address) 11 | return sock 12 | except Exception as ee: 13 | logging.warning(f"error {str(ee)}") 14 | 15 | 16 | def from_client_torealserver(realserver_connection,client_connection): 17 | while True: 18 | data = client_connection.recv(32) 19 | logging.warning(f"received data from client {data}") 20 | if data: 21 | logging.warning(f"sending to realserver {data}") 22 | realserver_connection.sendall(data) 23 | else: 24 | logging.warning(f"no more data") 25 | break 26 | 27 | def from_realserver_to_client(realserver_connection,client_connection): 28 | while True: 29 | data = realserver_connection.recv(32) 30 | logging.warning(f"received data from realserver {data}") 31 | if data: 32 | logging.warning(f"sending to client {data}") 33 | client_connection.sendall(data) 34 | else: 35 | logging.warning(f"no more data") 36 | break 37 | 38 | 39 | def run_proxy_server(proxy_address,realserver_address): 40 | #--- SERVER INISIALISATION --- 41 | proxysock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 42 | proxysock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 43 | # Bind the socket to the port 44 | logging.warning(f"starting up on {realserver_address}") 45 | proxysock.bind(proxy_address) 46 | # Listen for incoming connections 47 | proxysock.listen(1) 48 | while True: 49 | # Wait for a connection 50 | logging.warning("waiting for a connection") 51 | client_connection, client_address = proxysock.accept() 52 | logging.warning(f"Incoming connection from {client_address}") 53 | realserver_connection = make_realserver_socket(realserver_address) 54 | Thread(target=from_client_torealserver,args=(realserver_connection,client_connection)).start() 55 | Thread(target=from_realserver_to_client,args=(realserver_connection,client_connection)).start() 56 | 57 | if __name__=='__main__': 58 | try: 59 | proxy_address = ('0.0.0.0',15000) 60 | realserver_address = ('172.16.16.101',12000) 61 | run_proxy_server(proxy_address,realserver_address) 62 | except KeyboardInterrupt: 63 | logging.warning("Control-C: Program berhenti") 64 | exit(0) 65 | finally: 66 | logging.warning("seelsai") -------------------------------------------------------------------------------- /progjar1a/insecure_proxy_2.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import os 3 | import logging 4 | from threading import Thread 5 | 6 | def make_realserver_socket(server_address): 7 | try: 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 9 | logging.warning(f"connecting to {server_address}") 10 | sock.connect(server_address) 11 | return sock 12 | except Exception as ee: 13 | logging.warning(f"error {str(ee)}") 14 | 15 | 16 | def from_client_torealserver(realserver_connection,client_connection): 17 | while True: 18 | data = client_connection.recv(32) 19 | logging.warning(f"received data from client {data}") 20 | if data: 21 | logging.warning(f"sending to realserver {data}") 22 | realserver_connection.sendall(data) 23 | else: 24 | logging.warning(f"no more data") 25 | break 26 | 27 | def from_realserver_to_client(realserver_connection,client_connection): 28 | while True: 29 | data = realserver_connection.recv(32) 30 | logging.warning(f"received data from realserver {data}") 31 | if data: 32 | logging.warning(f"sending to client {data}") 33 | client_connection.sendall(data) 34 | else: 35 | logging.warning(f"no more data") 36 | break 37 | 38 | 39 | def run_proxy_server(proxy_address,realserver_address): 40 | #--- SERVER INISIALISATION --- 41 | proxysock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 42 | proxysock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 43 | # Bind the socket to the port 44 | logging.warning(f"starting up on {realserver_address}") 45 | proxysock.bind(proxy_address) 46 | # Listen for incoming connections 47 | proxysock.listen(1) 48 | while True: 49 | # Wait for a connection 50 | logging.warning("waiting for a connection") 51 | client_connection, client_address = proxysock.accept() 52 | logging.warning(f"Incoming connection from {client_address}") 53 | realserver_connection = make_realserver_socket(realserver_address) 54 | Thread(target=from_client_torealserver,args=(realserver_connection,client_connection)).start() 55 | Thread(target=from_realserver_to_client,args=(realserver_connection,client_connection)).start() 56 | 57 | if __name__=='__main__': 58 | try: 59 | proxy_address = ('0.0.0.0',16000) 60 | realserver_address = ('172.16.16.103',15000) 61 | run_proxy_server(proxy_address,realserver_address) 62 | except KeyboardInterrupt: 63 | logging.warning("Control-C: Program berhenti") 64 | exit(0) 65 | finally: 66 | logging.warning("seelsai") -------------------------------------------------------------------------------- /progjar5/server_thread_http_secure.py: -------------------------------------------------------------------------------- 1 | import os 2 | from socket import * 3 | import socket 4 | import threading 5 | import time 6 | import sys 7 | import logging 8 | import ssl 9 | 10 | 11 | 12 | 13 | from http import HttpServer 14 | 15 | httpserver = HttpServer() 16 | 17 | 18 | class ProcessTheClient(threading.Thread): 19 | def __init__(self, connection, address): 20 | self.connection = connection 21 | self.address = address 22 | threading.Thread.__init__(self) 23 | 24 | def run(self): 25 | rcv="" 26 | while True: 27 | try: 28 | data = self.connection.recv(32) 29 | if data: 30 | #merubah input dari socket (berupa bytes) ke dalam string 31 | #agar bisa mendeteksi \r\n 32 | d = data.decode() 33 | rcv=rcv+d 34 | if rcv[-2:]=='\r\n': 35 | #end of command, proses string 36 | logging.warning("data dari client: {}" . format(rcv)) 37 | hasil = httpserver.proses(rcv) 38 | #hasil akan berupa bytes 39 | #untuk bisa ditambahi dengan string, maka string harus di encode 40 | hasil=hasil+"\r\n\r\n".encode() 41 | logging.warning("balas ke client: {}" . format(hasil)) 42 | #hasil sudah dalam bentuk bytes 43 | self.connection.sendall(hasil) 44 | rcv="" 45 | self.connection.close() 46 | else: 47 | break 48 | except OSError as e: 49 | pass 50 | self.connection.close() 51 | 52 | 53 | 54 | class Server(threading.Thread): 55 | def __init__(self,hostname='testing.net'): 56 | self.the_clients = [] 57 | #------------------------------ 58 | self.hostname = hostname 59 | cert_location = os.getcwd() + '/certs/' 60 | self.context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) 61 | self.context.load_cert_chain(certfile=cert_location + 'domain.crt', 62 | keyfile=cert_location + 'domain.key') 63 | #--------------------------------- 64 | self.my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 65 | self.my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 66 | threading.Thread.__init__(self) 67 | 68 | def run(self): 69 | self.my_socket.bind(('0.0.0.0', 8443)) 70 | self.my_socket.listen(1) 71 | while True: 72 | self.connection, self.client_address = self.my_socket.accept() 73 | try: 74 | self.secure_connection = self.context.wrap_socket(self.connection, server_side=True) 75 | logging.warning("connection from {}".format(self.client_address)) 76 | clt = ProcessTheClient(self.secure_connection, self.client_address) 77 | clt.start() 78 | self.the_clients.append(clt) 79 | except ssl.SSLError as essl: 80 | print(str(essl)) 81 | 82 | 83 | 84 | 85 | def main(): 86 | svr = Server() 87 | svr.start() 88 | 89 | if __name__=="__main__": 90 | main() 91 | 92 | -------------------------------------------------------------------------------- /progjar10/logic.py: -------------------------------------------------------------------------------- 1 | import os 2 | import json 3 | import base64 4 | from glob import glob 5 | import shelve 6 | import time 7 | import threading, queue 8 | 9 | class Singleton: 10 | def __init__(self, cls): 11 | self._cls = cls 12 | def Instance(self): 13 | try: 14 | return self._instance 15 | except AttributeError: 16 | self._instance = self._cls() 17 | return self._instance 18 | def __call__(self): 19 | raise TypeError('Singletons must be accessed through `Instance()`.') 20 | def __instancecheck__(self, inst): 21 | return isinstance(inst, self._cls) 22 | 23 | class QueueServer(threading.Thread): 24 | def __init__(self,idplayer='1'): 25 | self.idplayer = idplayer 26 | self.q = list() 27 | threading.Thread.__init__(self) 28 | def run(self): 29 | while True: 30 | pass 31 | # 32 | #print(self.idplayer) 33 | #time.sleep(0.1) 34 | 35 | def getall(self): 36 | h = list() 37 | for i in range(len(self.q)): 38 | h.append(self.q[i]) 39 | return h 40 | 41 | def put(self,value=[]): 42 | self.q.append(value) 43 | return True 44 | #player harus di register 45 | 46 | @Singleton 47 | class PlayerServerInterface: 48 | def __init__(self): 49 | self.queues = dict() 50 | def player_register(self,params=[]): 51 | idplayer = params[0] 52 | if (idplayer not in self.queues): 53 | self.queues[idplayer]=QueueServer(idplayer) 54 | self.queues[idplayer].start() 55 | return dict(status='OK') 56 | 57 | def get_players(self,params=[]): 58 | return dict(status='OK',jumlah=len(self.queues)) 59 | 60 | def set_location(self,params=[]): 61 | pnum = params[0] 62 | #x = params[1] 63 | #y = params[2] 64 | try: 65 | self.queues[pnum].put(params) 66 | return dict(status='OK', player=pnum) 67 | except Exception as ee: 68 | print(str(ee)) 69 | return dict(status='ERROR') 70 | 71 | def get_location(self,params=[]): 72 | pnum = params[0] 73 | try: 74 | h = self.queues[pnum].getall() 75 | return dict(status='OK',data=h) 76 | except Exception as ee: 77 | print(str(ee)) 78 | return dict(status='ERROR') 79 | 80 | 81 | 82 | if __name__=='__main__': 83 | p = PlayerServerInterface.Instance() 84 | #p.player_register(["1"]) 85 | #p.player_register(["2"]) 86 | #print(p.set_location(["1",100,100])) 87 | #print(p.set_location(["2",120,100])) 88 | #print(p.get_location('1')) 89 | #print(p.get_location('2')) 90 | #print(p.get_players()) 91 | -------------------------------------------------------------------------------- /progjar6/lb_process.py: -------------------------------------------------------------------------------- 1 | from socket import * 2 | import socket 3 | import time 4 | import sys 5 | import logging 6 | import multiprocessing 7 | from concurrent.futures import ProcessPoolExecutor 8 | from http import HttpServer 9 | 10 | class BackendList: 11 | def __init__(self): 12 | self.servers=[] 13 | self.servers.append(('127.0.0.1',8000)) 14 | self.servers.append(('127.0.0.1',8001)) 15 | self.servers.append(('127.0.0.1',8002)) 16 | # self.servers.append(('127.0.0.1',9005)) 17 | self.current=0 18 | def getserver(self): 19 | s = self.servers[self.current] 20 | print(s) 21 | self.current=self.current+1 22 | if (self.current>=len(self.servers)): 23 | self.current=0 24 | return s 25 | 26 | 27 | 28 | 29 | def ProcessTheClient(connection,address,backend_sock,mode='toupstream'): 30 | try: 31 | while True: 32 | try: 33 | if (mode=='toupstream'): 34 | datafrom_client = connection.recv(32) 35 | if datafrom_client: 36 | backend_sock.sendall(datafrom_client) 37 | else: 38 | backend_sock.close() 39 | break 40 | elif (mode=='toclient'): 41 | datafrom_backend = backend_sock.recv(32) 42 | 43 | if datafrom_backend: 44 | connection.sendall(datafrom_backend) 45 | else: 46 | connection.close() 47 | break 48 | 49 | except OSError as e: 50 | pass 51 | except Exception as ee: 52 | logging.warning(f"error {str(ee)}") 53 | connection.close() 54 | return 55 | 56 | 57 | 58 | def Server(): 59 | the_clients = [] 60 | my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 61 | my_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 62 | backend = BackendList() 63 | 64 | my_socket.bind(('0.0.0.0', 44444)) 65 | my_socket.listen(1) 66 | 67 | with ProcessPoolExecutor(20) as executor: 68 | while True: 69 | connection, client_address = my_socket.accept() 70 | backend_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 71 | backend_sock.settimeout(1) 72 | backend_address = backend.getserver() 73 | logging.warning(f"{client_address} connecting to {backend_address}") 74 | try: 75 | backend_sock.connect(backend_address) 76 | 77 | #logging.warning("connection from {}".format(client_address)) 78 | toupstream = executor.submit(ProcessTheClient, connection, client_address,backend_sock,'toupstream') 79 | #the_clients.append(toupstream) 80 | toclient = executor.submit(ProcessTheClient, connection, client_address,backend_sock,'toclient') 81 | #the_clients.append(toclient) 82 | 83 | #menampilkan jumlah process yang sedang aktif 84 | jumlah = ['x' for i in the_clients if i.running()==True] 85 | #print(jumlah) 86 | except Exception as err: 87 | logging.error(err) 88 | pass 89 | 90 | 91 | 92 | 93 | 94 | def main(): 95 | Server() 96 | 97 | if __name__=="__main__": 98 | main() 99 | 100 | -------------------------------------------------------------------------------- /progjar0/serialize.py: -------------------------------------------------------------------------------- 1 | import csv 2 | import json 3 | import shelve 4 | import yaml 5 | import dicttoxml 6 | import xmltodict 7 | import asn1tools 8 | 9 | from dataclasses import dataclass, asdict 10 | 11 | 12 | @dataclass 13 | class Person: 14 | no_ktp: str 15 | nama: str 16 | tgl_lahir: str 17 | tmp_lahir: str 18 | 19 | fields = ['no_ktp','nama','tgl_lahir','tmp_lahir'] 20 | orang1 = Person(no_ktp='4567', nama='joao felix', tgl_lahir='24/03/2000', tmp_lahir='Mojokerto') 21 | 22 | 23 | def serialize_to_csv(): 24 | f = open('person1.csv','w') 25 | writer = csv.DictWriter(f,fields) 26 | writer.writeheader() 27 | writer.writerow(asdict(orang1)) 28 | 29 | def deserialize_from_csv(): 30 | f = open('person1.csv','r') 31 | reader = csv.DictReader(f,fields) 32 | for row in reader: 33 | print(row) 34 | 35 | def serialize_to_json(): 36 | f = open('person1.json','w') 37 | json.dump(asdict(orang1),f,indent=True) 38 | 39 | def serialize_from_json(): 40 | f=open('person1.json','r') 41 | hasil = json.load(f) 42 | print(hasil) 43 | 44 | 45 | def serialize_to_shelve(): 46 | p = shelve.open('person1.simpan') 47 | p['orang1']=asdict(orang1) 48 | p.close() 49 | 50 | def deserialize_from_shelve(): 51 | p = shelve.open('person1.simpan') 52 | print(p['orang1']) 53 | p.close() 54 | 55 | def serialize_to_xml(): 56 | x = dicttoxml.dicttoxml(asdict(orang1),attr_type=False) 57 | f = open('orang.xml','wb') 58 | f.write(x) 59 | f.close() 60 | 61 | def serialize_from_xml(): 62 | f = open('orang.xml','rb') 63 | x= f.read() 64 | ##OrderedDict([('root', OrderedDict([('no_ktp', '4567'), ('nama', 'joao felix'), ('tgl_lahir', '24/03/2000'), ('tmp_lahir', 'Mojokerto')]))]) 65 | d = dict(xmltodict.parse(x))['root'] 66 | d = dict(d) 67 | print(d) 68 | f.close() 69 | 70 | def serialize_to_yaml(): 71 | f = open('orang.yaml','w') 72 | yaml.dump(asdict(orang1),f,default_flow_style=False) 73 | 74 | def serialize_from_yaml(): 75 | f = open('orang.yaml','r') 76 | hasil = yaml.safe_load(f) 77 | print(hasil) 78 | 79 | 80 | def serialize_to_asn(): 81 | test = asn1tools.compile_files('test.asn') 82 | encoded = test.encode('Question', {'id': 1, 'question': 'Is 1+1=3?'}) 83 | fp = open('test.ber','wb') 84 | fp.write(encoded) 85 | fp.close() 86 | 87 | def serialize_from_asn(): 88 | test = asn1tools.compile_files('test.asn') 89 | fp = open('test.ber','rb') 90 | decoded = test.decode('Question',fp.read()) 91 | fp.close() 92 | print(decoded) 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | if __name__=='__main__': 101 | serialize_to_csv() 102 | deserialize_from_csv() 103 | 104 | serialize_to_json() 105 | serialize_from_json() 106 | 107 | serialize_to_shelve() 108 | deserialize_from_shelve() 109 | 110 | serialize_to_xml() 111 | serialize_from_xml() 112 | 113 | serialize_to_yaml() 114 | serialize_from_yaml() 115 | 116 | serialize_to_asn() 117 | serialize_from_asn() -------------------------------------------------------------------------------- /environment/README.MD: -------------------------------------------------------------------------------- 1 | # LAB PEMROGRAMAN JARINGAN 2 | 3 | Dalam MK pemrograman jaringan , disediakan 3 buah mesin dengan URL sebagai berikut. 4 | mesin-mesin tersebut berupa docker container. tiap-tiap mesin dapat diakses dengan mengakses url melalui web browser 5 | mesin tersebut berupa, jupyter-lab yang didalamnya terdapat utility wireshark 6 | 7 | #### PERHATIAN 8 | ``` 9 | konfigurasi mesin-mesin dalam lab pemrograman jaringan ini dibuat dan telah dicoba dengan baik menggunakan sistem operasi linux 10 | untuk sistem operasi yang lain seperti MACOS bisa jadi tidak berfungsi, untuk memastikan, gunakan WSL (windows subsystem for linux) atau install Virtual Machine dengan HyperV atau virtualbox 11 | (dikarenakan masalah ketidakpastian lisensi, Virtualbox telah diblok dan tidak bisa didownload dalam jaringan ITS, gunakan jaringan internet diluar kampus untuk mendownload Virtualbox) 12 | ``` 13 | 14 | untuk mengakses mesin dengan web based jupyter lab 15 | 16 | - mesin1 : http://[IPaddress]:60001 17 | - mesin2 : http://[IPaddress]:60002 18 | - mesin3 : http://[IPaddress]:60003 19 | 20 | sedangkan untuk mengakses wireshark 21 | 22 | - mesin1 : http://[IPaddress]:50001 23 | - mesin2 : http://[IPaddress]:50002 24 | - mesin3 : http://[IPaddress]:50003 25 | 26 | 27 | untuk mengakses halaman web jupyter ataupun wireshark (dengan vnc) , gunakan password 28 | - pada mesin1, gunakan password "mesin1" 29 | - pada mesin2, gunakan password "mesin2" 30 | - pada mesin3, gunakan password "mesin3" 31 | 32 | 33 | untuk lingkungan internal, masing masing mesin mempunyai IP address sebagai berikut: 34 | - mesin1 : 172.16.16.101 35 | - mesin2 : 172.16.16.102 36 | - mesin3 : 172.16.16.103 37 | - mesin4 : 172.16.16.104 38 | 39 | 40 | masing-masing mesin mempunyai 2 interface yaitu 41 | - eth0 -> menghubungkan dengan dunia luar 42 | - eth1 -> mennghubungkan antar mesin (isolated) 43 | 44 | # LANGKAH-LANGKAH 45 | 46 | - install docker dan docker-compose 47 | - jalankan docker-compose up -d 48 | - cek dengan perintah : docker-compose ps 49 | 50 | ``` 51 | $ docker-compose ps 52 | Name Command State Ports 53 | ----------------------------------------------------------------------------------------------------------------------------------------------- 54 | progjar-mesin-1 /bin/sh /tmp/runme.sh Up (healthy) 0.0.0.0:50001->6666/tcp,:::50001->6666/tcp, 0.0.0.0:60001->8888/tcp,:::60001->8888/tcp 55 | progjar-mesin-2 /bin/sh /tmp/runme.sh Up (healthy) 0.0.0.0:50002->6666/tcp,:::50002->6666/tcp, 0.0.0.0:60002->8888/tcp,:::60002->8888/tcp 56 | progjar-mesin-3 /bin/sh /tmp/runme.sh Up (healthy) 0.0.0.0:50003->6666/tcp,:::50003->6666/tcp, 0.0.0.0:60003->8888/tcp,:::60003->8888/tcp 57 | 58 | ``` 59 | 60 | Download/clone materi untuk pemrograman jaringan di https://github.com/rm77/progjar dengan cara 61 | - akses ke salah satu mesin 62 | - buka terminal (di bagian launcher) 63 | - akseslah layar terminal, ketiklah command berikut ini 64 | 65 | ``` 66 | cd work 67 | git clone https://github.com/rm77/progjar 68 | ``` 69 | 70 | akan menghasilkan direktori "progjar". 71 | untuk menjalankan gunakan command 72 | 73 | ``` 74 | python3 75 | ``` 76 | -------------------------------------------------------------------------------- /progjar7/http.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import os.path 3 | import uuid 4 | from glob import glob 5 | from datetime import datetime 6 | 7 | class HttpServer: 8 | def __init__(self): 9 | self.sessions={} 10 | self.types={} 11 | self.types['.pdf']='application/pdf' 12 | self.types['.jpg']='image/jpeg' 13 | self.types['.txt']='text/plain' 14 | self.types['.html']='text/html' 15 | def response(self,kode=404,message='Not Found',messagebody=bytes(),headers={}): 16 | tanggal = datetime.now().strftime('%c') 17 | resp=[] 18 | resp.append("HTTP/1.0 {} {}\r\n" . format(kode,message)) 19 | resp.append("Date: {}\r\n" . format(tanggal)) 20 | resp.append("Connection: close\r\n") 21 | resp.append("Server: myserver/1.0\r\n") 22 | resp.append("Content-Length: {}\r\n" . format(len(messagebody))) 23 | for kk in headers: 24 | resp.append("{}:{}\r\n" . format(kk,headers[kk])) 25 | resp.append("\r\n") 26 | 27 | response_headers='' 28 | for i in resp: 29 | response_headers="{}{}" . format(response_headers,i) 30 | #menggabungkan resp menjadi satu string dan menggabungkan dengan messagebody yang berupa bytes 31 | #response harus berupa bytes 32 | #message body harus diubah dulu menjadi bytes 33 | if (type(messagebody) is not bytes): 34 | messagebody = messagebody.encode() 35 | 36 | response = response_headers.encode() + messagebody 37 | #response adalah bytes 38 | return response 39 | 40 | def proses(self,data): 41 | 42 | requests = data.split("\r\n") 43 | #print(requests) 44 | 45 | baris = requests[0] 46 | #print(baris) 47 | 48 | all_headers = [n for n in requests[1:] if n!=''] 49 | 50 | j = baris.split(" ") 51 | try: 52 | method=j[0].upper().strip() 53 | if (method=='GET'): 54 | object_address = j[1].strip() 55 | return self.http_get(object_address, all_headers) 56 | if (method=='POST'): 57 | object_address = j[1].strip() 58 | return self.http_post(object_address, all_headers) 59 | else: 60 | return self.response(400,'Bad Request','',{}) 61 | except IndexError: 62 | return self.response(400,'Bad Request','',{}) 63 | def http_get(self,object_address,headers): 64 | files = glob('./*') 65 | thedir='.' 66 | if thedir+object_address not in files: 67 | return self.response(404,'Not Found','',{}) 68 | fp = open(thedir+object_address,'rb') #rb => artinya adalah read dalam bentuk binary 69 | #harus membaca dalam bentuk byte dan BINARY 70 | isi = fp.read() 71 | 72 | fext = os.path.splitext(thedir+object_address)[1] 73 | content_type = self.types[fext] 74 | 75 | headers={} 76 | headers['Content-type']=content_type 77 | 78 | return self.response(200,'OK',isi,headers) 79 | def http_post(self,object_address,headers): 80 | headers ={} 81 | isi = "kosong" 82 | return self.response(200,'OK',isi,headers) 83 | 84 | 85 | #>>> import os.path 86 | #>>> ext = os.path.splitext('/ak/52.png') 87 | 88 | if __name__=="__main__": 89 | httpserver = HttpServer() 90 | d = httpserver.proses('GET testing.txt HTTP/1.0') 91 | print(d) 92 | d = httpserver.http_get('testing2.txt') 93 | print(d) 94 | d = httpserver.http_get('testing.txt') 95 | print(d) 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | -------------------------------------------------------------------------------- /progjar4c/chatserver/chat-cli.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import os 3 | import json 4 | 5 | TARGET_IP = "127.0.0.1" 6 | TARGET_PORT = 8889 7 | 8 | 9 | class ChatClient: 10 | def __init__(self): 11 | self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 12 | self.server_address = (TARGET_IP,TARGET_PORT) 13 | self.sock.connect(self.server_address) 14 | self.tokenid="" 15 | def proses(self,cmdline): 16 | j=cmdline.split(" ") 17 | try: 18 | command=j[0].strip() 19 | if (command=='auth'): 20 | username=j[1].strip() 21 | password=j[2].strip() 22 | return self.login(username,password) 23 | elif (command=='send'): 24 | usernameto = j[1].strip() 25 | message="" 26 | for w in j[2:]: 27 | message="{} {}" . format(message,w) 28 | return self.sendmessage(usernameto,message) 29 | elif (command=='inbox'): 30 | return self.inbox() 31 | else: 32 | return "*Maaf, command tidak benar" 33 | except IndexError: 34 | return "-Maaf, command tidak benar" 35 | def sendstring(self,string): 36 | try: 37 | self.sock.sendall(string.encode()) 38 | receivemsg = "" 39 | while True: 40 | data = self.sock.recv(64) 41 | print("diterima dari server",data) 42 | if (data): 43 | receivemsg = "{}{}" . format(receivemsg,data.decode()) #data harus didecode agar dapat di operasikan dalam bentuk string 44 | if receivemsg[-4:]=='\r\n\r\n': 45 | print("end of string") 46 | return json.loads(receivemsg) 47 | except: 48 | self.sock.close() 49 | return { 'status' : 'ERROR', 'message' : 'Gagal'} 50 | def login(self,username,password): 51 | string="auth {} {} \r\n" . format(username,password) 52 | result = self.sendstring(string) 53 | if result['status']=='OK': 54 | self.tokenid=result['tokenid'] 55 | return "username {} logged in, token {} " .format(username,self.tokenid) 56 | else: 57 | return "Error, {}" . format(result['message']) 58 | def sendmessage(self,usernameto="xxx",message="xxx"): 59 | if (self.tokenid==""): 60 | return "Error, not authorized" 61 | string="send {} {} {} \r\n" . format(self.tokenid,usernameto,message) 62 | print(string) 63 | result = self.sendstring(string) 64 | if result['status']=='OK': 65 | return "message sent to {}" . format(usernameto) 66 | else: 67 | return "Error, {}" . format(result['message']) 68 | def inbox(self): 69 | if (self.tokenid==""): 70 | return "Error, not authorized" 71 | string="inbox {} \r\n" . format(self.tokenid) 72 | result = self.sendstring(string) 73 | if result['status']=='OK': 74 | return "{}" . format(json.dumps(result['messages'])) 75 | else: 76 | return "Error, {}" . format(result['message']) 77 | 78 | 79 | 80 | if __name__=="__main__": 81 | cc = ChatClient() 82 | while True: 83 | cmdline = input("Command {}:" . format(cc.tokenid)) 84 | print(cc.proses(cmdline)) 85 | 86 | -------------------------------------------------------------------------------- /environment-demo/app/client/chatcli.py: -------------------------------------------------------------------------------- 1 | import socket 2 | import os 3 | import json 4 | 5 | TARGET_IP = os.getenv("SERVER_IP") or "127.0.0.1" 6 | TARGET_PORT = os.getenv("SERVER_PORT") or "8889" 7 | 8 | 9 | class ChatClient: 10 | def __init__(self): 11 | self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 12 | print(TARGET_IP) 13 | print(TARGET_PORT) 14 | self.server_address = (TARGET_IP,int(TARGET_PORT)) 15 | self.sock.connect(self.server_address) 16 | self.tokenid="" 17 | def proses(self,cmdline): 18 | j=cmdline.split(" ") 19 | try: 20 | command=j[0].strip() 21 | if (command=='auth'): 22 | username=j[1].strip() 23 | password=j[2].strip() 24 | return self.login(username,password) 25 | elif (command=='send'): 26 | usernameto = j[1].strip() 27 | message="" 28 | for w in j[2:]: 29 | message="{} {}" . format(message,w) 30 | return self.sendmessage(usernameto,message) 31 | elif (command=='inbox'): 32 | return self.inbox() 33 | else: 34 | return "*Maaf, command tidak benar" 35 | except IndexError: 36 | return "-Maaf, command tidak benar" 37 | def sendstring(self,string): 38 | try: 39 | self.sock.sendall(string.encode()) 40 | receivemsg = "" 41 | while True: 42 | data = self.sock.recv(64) 43 | print("diterima dari server",data) 44 | if (data): 45 | receivemsg = "{}{}" . format(receivemsg,data.decode()) #data harus didecode agar dapat di operasikan dalam bentuk string 46 | if receivemsg[-4:]=='\r\n\r\n': 47 | print("end of string") 48 | return json.loads(receivemsg) 49 | except: 50 | self.sock.close() 51 | return { 'status' : 'ERROR', 'message' : 'Gagal'} 52 | def login(self,username,password): 53 | string="auth {} {} \r\n" . format(username,password) 54 | result = self.sendstring(string) 55 | if result['status']=='OK': 56 | self.tokenid=result['tokenid'] 57 | return "username {} logged in, token {} " .format(username,self.tokenid) 58 | else: 59 | return "Error, {}" . format(result['message']) 60 | def sendmessage(self,usernameto="xxx",message="xxx"): 61 | if (self.tokenid==""): 62 | return "Error, not authorized" 63 | string="send {} {} {} \r\n" . format(self.tokenid,usernameto,message) 64 | print(string) 65 | result = self.sendstring(string) 66 | if result['status']=='OK': 67 | return "message sent to {}" . format(usernameto) 68 | else: 69 | return "Error, {}" . format(result['message']) 70 | def inbox(self): 71 | if (self.tokenid==""): 72 | return "Error, not authorized" 73 | string="inbox {} \r\n" . format(self.tokenid) 74 | result = self.sendstring(string) 75 | if result['status']=='OK': 76 | return "{}" . format(json.dumps(result['messages'])) 77 | else: 78 | return "Error, {}" . format(result['message']) 79 | 80 | 81 | 82 | if __name__=="__main__": 83 | cc = ChatClient() 84 | while True: 85 | cmdline = input("Command {}:" . format(cc.tokenid)) 86 | print(cc.proses(cmdline)) 87 | 88 | -------------------------------------------------------------------------------- /progjar5/client/client.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import json 4 | import logging 5 | import ssl 6 | import os 7 | 8 | server_address = ('www.its.ac.id', 443) 9 | server_address = ('www.ietf.org',443) 10 | 11 | 12 | def make_socket(destination_address='localhost', port=12000): 13 | try: 14 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 15 | server_address = (destination_address, port) 16 | logging.warning(f"connecting to {server_address}") 17 | sock.connect(server_address) 18 | return sock 19 | except Exception as ee: 20 | logging.warning(f"error {str(ee)}") 21 | 22 | 23 | def make_secure_socket(destination_address='localhost', port=10000): 24 | try: 25 | # get it from https://curl.se/docs/caextract.html 26 | 27 | context = ssl.create_default_context() 28 | context.check_hostname = False 29 | context.verify_mode = ssl.CERT_NONE 30 | context.load_verify_locations(os.getcwd() + '/domain.crt') 31 | 32 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 33 | server_address = (destination_address, port) 34 | logging.warning(f"connecting to {server_address}") 35 | sock.connect(server_address) 36 | secure_socket = context.wrap_socket(sock, server_hostname=destination_address) 37 | logging.warning(secure_socket.getpeercert()) 38 | return secure_socket 39 | except Exception as ee: 40 | logging.warning(f"error {str(ee)}") 41 | 42 | 43 | 44 | def send_command(command_str, is_secure=False): 45 | alamat_server = server_address[0] 46 | port_server = server_address[1] 47 | # sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 48 | # gunakan fungsi diatas 49 | if is_secure == True: 50 | sock = make_secure_socket(alamat_server, port_server) 51 | else: 52 | sock = make_socket(alamat_server, port_server) 53 | 54 | logging.warning(f"connecting to {server_address}") 55 | try: 56 | logging.warning(f"sending message ") 57 | sock.sendall(command_str.encode()) 58 | logging.warning(command_str) 59 | # Look for the response, waiting until socket is done (no more data) 60 | data_received = "" # empty string 61 | while True: 62 | # socket does not receive all data at once, data comes in part, need to be concatenated at the end of process 63 | data = sock.recv(2048) 64 | if data: 65 | # data is not empty, concat with previous content 66 | data_received += data.decode() 67 | if "\r\n\r\n" in data_received: 68 | break 69 | else: 70 | # no more data, stop the process by break 71 | break 72 | # at this point, data_received (string) will contain all data coming from the socket 73 | # to be able to use the data_received as a dict, need to load it using json.loads() 74 | hasil = data_received 75 | logging.warning("data received from server:") 76 | return hasil 77 | except Exception as ee: 78 | logging.warning(f"error during data receiving {str(ee)}") 79 | return False 80 | 81 | #> GET / HTTP/1.1 82 | #> Host: www.its.ac.id 83 | #> User-Agent: curl/8.7.1 84 | #> Accept: */* 85 | #> 86 | 87 | if __name__ == '__main__': 88 | cmd = f"""GET /rfc/rfc2616.txt HTTP/1.1 89 | Host: www.ietf.org 90 | User-Agent: myclient/1.1 91 | Accept: */* 92 | 93 | """ 94 | hasil = send_command(cmd, is_secure=True) 95 | print(hasil) 96 | -------------------------------------------------------------------------------- /progjar4c/irc-client/library.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import json 4 | import logging 5 | import ssl 6 | import os 7 | 8 | 9 | def make_socket(destination_address='localhost',port=12000): 10 | try: 11 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 12 | server_address = (destination_address, port) 13 | #logging.warning(f"connecting to {server_address}") 14 | sock.connect(server_address) 15 | return sock 16 | except Exception as ee: 17 | logging.warning(f"error {str(ee)}") 18 | 19 | def make_secure_socket(destination_address='localhost',port=10000): 20 | try: 21 | #get it from https://curl.se/docs/caextract.html 22 | 23 | context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) 24 | context.verify_mode=ssl.CERT_OPTIONAL 25 | context.load_verify_locations(os.getcwd() + '/domain.crt') 26 | 27 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 28 | server_address = (destination_address, port) 29 | logging.warning(f"connecting to {server_address}") 30 | sock.connect(server_address) 31 | secure_socket = context.wrap_socket(sock,server_hostname=destination_address) 32 | logging.warning(secure_socket.getpeercert()) 33 | return secure_socket 34 | except Exception as ee: 35 | logging.warning(f"error {str(ee)}") 36 | 37 | def deserialisasi(s,mode='plain'): 38 | logging.warning(f"deserialisasi {s.strip()}") 39 | if mode == 'plain': 40 | return s 41 | elif mode == 'json': 42 | return json.loads(s) 43 | 44 | 45 | def serialisasi(s,mode='plain'): 46 | logging.warning(f"deserialisasi {s.strip()}") 47 | if mode=='plain': 48 | return s 49 | elif mode=='json': 50 | return json.dumps(s) 51 | 52 | 53 | def send_command(destination_address, port, command_str,is_secure=False,serialization='plain',breaker="\r\n\r\n"): 54 | alamat_server = destination_address 55 | port_server = port 56 | # sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 57 | # gunakan fungsi diatas 58 | if is_secure == True: 59 | sock = make_secure_socket(alamat_server,port_server) 60 | else: 61 | sock = make_socket(alamat_server,port_server) 62 | 63 | logging.warning(f"connecting to {alamat_server} di port {port}") 64 | try: 65 | logging.warning(f"sending message ") 66 | sock.sendall(command_str.encode()) 67 | # Look for the response, waiting until socket is done (no more data) 68 | data_received="" #empty string 69 | while True: 70 | #socket does not receive all data at once, data comes in part, need to be concatenated at the end of process 71 | data = sock.recv(16) 72 | if data: 73 | #data is not empty, concat with previous content 74 | data_received += data.decode() 75 | logging.warning(data_received) 76 | if breaker in data_received: 77 | break 78 | else: 79 | # no more data, stop the process by break 80 | break 81 | # at this point, data_received (string) will contain all data coming from the socket 82 | # to be able to use the data_received as a dict, need to load it using json.loads() 83 | hasil = deserialisasi(data_received) 84 | logging.warning("data received from server:") 85 | return hasil 86 | except Exception as ee: 87 | logging.warning(f"error during data receiving {str(ee)}") 88 | return False 89 | 90 | 91 | 92 | -------------------------------------------------------------------------------- /progjar5/http.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import os.path 3 | import uuid 4 | from glob import glob 5 | from datetime import datetime 6 | 7 | class HttpServer: 8 | def __init__(self): 9 | self.sessions={} 10 | self.types={} 11 | self.types['.pdf']='application/pdf' 12 | self.types['.jpg']='image/jpeg' 13 | self.types['.txt']='text/plain' 14 | self.types['.html']='text/html' 15 | def response(self,kode=404,message='Not Found',messagebody=bytes(),headers={}): 16 | tanggal = datetime.now().strftime('%c') 17 | resp=[] 18 | resp.append("HTTP/1.0 {} {}\r\n" . format(kode,message)) 19 | resp.append("Date: {}\r\n" . format(tanggal)) 20 | resp.append("Connection: close\r\n") 21 | resp.append("Server: myserver/1.0\r\n") 22 | resp.append("Content-Length: {}\r\n" . format(len(messagebody))) 23 | for kk in headers: 24 | resp.append("{}:{}\r\n" . format(kk,headers[kk])) 25 | resp.append("\r\n") 26 | 27 | response_headers='' 28 | for i in resp: 29 | response_headers="{}{}" . format(response_headers,i) 30 | #menggabungkan resp menjadi satu string dan menggabungkan dengan messagebody yang berupa bytes 31 | #response harus berupa bytes 32 | #message body harus diubah dulu menjadi bytes 33 | if (type(messagebody) is not bytes): 34 | messagebody = messagebody.encode() 35 | 36 | response = response_headers.encode() + messagebody 37 | #response adalah bytes 38 | return response 39 | 40 | def proses(self,data): 41 | 42 | requests = data.split("\r\n") 43 | #print(requests) 44 | 45 | baris = requests[0] 46 | #print(baris) 47 | 48 | all_headers = [n for n in requests[1:] if n!=''] 49 | 50 | j = baris.split(" ") 51 | try: 52 | method=j[0].upper().strip() 53 | if (method=='GET'): 54 | object_address = j[1].strip() 55 | return self.http_get(object_address, all_headers) 56 | if (method=='POST'): 57 | object_address = j[1].strip() 58 | return self.http_post(object_address, all_headers) 59 | else: 60 | return self.response(400,'Bad Request','',{}) 61 | except IndexError: 62 | return self.response(400,'Bad Request','',{}) 63 | def http_get(self,object_address,headers): 64 | files = glob('./*') 65 | #print(files) 66 | thedir='./' 67 | if (object_address == '/'): 68 | return self.response(200,'OK','Ini Adalah web Server percobaan',dict()) 69 | 70 | if (object_address == '/video'): 71 | return self.response(302,'Found','',dict(location='https://youtu.be/katoxpnTf04')) 72 | if (object_address == '/santai'): 73 | return self.response(200,'OK','santai saja',dict()) 74 | 75 | 76 | object_address=object_address[1:] 77 | if thedir+object_address not in files: 78 | return self.response(404,'Not Found','',{}) 79 | fp = open(thedir+object_address,'rb') #rb => artinya adalah read dalam bentuk binary 80 | #harus membaca dalam bentuk byte dan BINARY 81 | isi = fp.read() 82 | 83 | fext = os.path.splitext(thedir+object_address)[1] 84 | content_type = self.types[fext] 85 | 86 | headers={} 87 | headers['Content-type']=content_type 88 | 89 | return self.response(200,'OK',isi,headers) 90 | def http_post(self,object_address,headers): 91 | headers ={} 92 | isi = "kosong" 93 | return self.response(200,'OK',isi,headers) 94 | 95 | 96 | #>>> import os.path 97 | #>>> ext = os.path.splitext('/ak/52.png') 98 | 99 | if __name__=="__main__": 100 | httpserver = HttpServer() 101 | d = httpserver.proses('GET testing.txt HTTP/1.0') 102 | print(d) 103 | d = httpserver.proses('GET donalbebek.jpg HTTP/1.0') 104 | print(d) 105 | #d = httpserver.http_get('testing2.txt',{}) 106 | #print(d) 107 | # d = httpserver.http_get('testing.txt') 108 | # print(d) 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /progjar6/http.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import os.path 3 | import uuid 4 | from glob import glob 5 | from datetime import datetime 6 | 7 | class HttpServer: 8 | def __init__(self): 9 | self.sessions={} 10 | self.types={} 11 | self.types['.pdf']='application/pdf' 12 | self.types['.jpg']='image/jpeg' 13 | self.types['.txt']='text/plain' 14 | self.types['.html']='text/html' 15 | def response(self,kode=404,message='Not Found',messagebody=bytes(),headers={}): 16 | tanggal = datetime.now().strftime('%c') 17 | resp=[] 18 | resp.append("HTTP/1.0 {} {}\r\n" . format(kode,message)) 19 | resp.append("Date: {}\r\n" . format(tanggal)) 20 | resp.append("Connection: close\r\n") 21 | resp.append("Server: myserver/1.0\r\n") 22 | resp.append("Content-Length: {}\r\n" . format(len(messagebody))) 23 | for kk in headers: 24 | resp.append("{}:{}\r\n" . format(kk,headers[kk])) 25 | resp.append("\r\n") 26 | 27 | response_headers='' 28 | for i in resp: 29 | response_headers="{}{}" . format(response_headers,i) 30 | #menggabungkan resp menjadi satu string dan menggabungkan dengan messagebody yang berupa bytes 31 | #response harus berupa bytes 32 | #message body harus diubah dulu menjadi bytes 33 | if (type(messagebody) is not bytes): 34 | messagebody = messagebody.encode() 35 | 36 | response = response_headers.encode() + messagebody 37 | #response adalah bytes 38 | return response 39 | 40 | def proses(self,data): 41 | 42 | requests = data.split("\r\n") 43 | #print(requests) 44 | 45 | baris = requests[0] 46 | #print(baris) 47 | 48 | all_headers = [n for n in requests[1:] if n!=''] 49 | 50 | j = baris.split(" ") 51 | try: 52 | method=j[0].upper().strip() 53 | if (method=='GET'): 54 | object_address = j[1].strip() 55 | return self.http_get(object_address, all_headers) 56 | if (method=='POST'): 57 | object_address = j[1].strip() 58 | return self.http_post(object_address, all_headers) 59 | else: 60 | return self.response(400,'Bad Request','',{}) 61 | except IndexError: 62 | return self.response(400,'Bad Request','',{}) 63 | def http_get(self,object_address,headers): 64 | files = glob('./*') 65 | #print(files) 66 | thedir='./' 67 | if (object_address == '/'): 68 | return self.response(200,'OK','Ini Adalah web Server percobaan',dict()) 69 | 70 | if (object_address == '/video'): 71 | return self.response(302,'Found','',dict(location='https://youtu.be/katoxpnTf04')) 72 | if (object_address == '/santai'): 73 | return self.response(200,'OK','santai saja',dict()) 74 | 75 | 76 | object_address=object_address[1:] 77 | if thedir+object_address not in files: 78 | return self.response(404,'Not Found','',{}) 79 | fp = open(thedir+object_address,'rb') #rb => artinya adalah read dalam bentuk binary 80 | #harus membaca dalam bentuk byte dan BINARY 81 | isi = fp.read() 82 | 83 | fext = os.path.splitext(thedir+object_address)[1] 84 | content_type = self.types[fext] 85 | 86 | headers={} 87 | headers['Content-type']=content_type 88 | 89 | return self.response(200,'OK',isi,headers) 90 | def http_post(self,object_address,headers): 91 | headers ={} 92 | isi = "kosong" 93 | return self.response(200,'OK',isi,headers) 94 | 95 | 96 | #>>> import os.path 97 | #>>> ext = os.path.splitext('/ak/52.png') 98 | 99 | if __name__=="__main__": 100 | httpserver = HttpServer() 101 | d = httpserver.proses('GET testing.txt HTTP/1.0') 102 | print(d) 103 | d = httpserver.proses('GET donalbebek.jpg HTTP/1.0') 104 | print(d) 105 | #d = httpserver.http_get('testing2.txt',{}) 106 | #print(d) 107 | # d = httpserver.http_get('testing.txt') 108 | # print(d) 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /progjar4c/irc-client/irc-session-example.test: -------------------------------------------------------------------------------- 1 | 2 | 3 | CAP LS 302 4 | :barjavel.freenode.net NOTICE * :*** Looking up your hostname... 5 | NICK zeektest 6 | USER zeektest 0 * :realname 7 | :barjavel.freenode.net NOTICE * :*** Checking Ident 8 | :barjavel.freenode.net NOTICE * :*** Found your hostname 9 | :barjavel.freenode.net NOTICE * :*** No Ident response 10 | :barjavel.freenode.net CAP * LS :account-notify away-notify cap-notify chghost extended-join identify-msg multi-prefix sasl tls 11 | CAP REQ :account-notify away-notify cap-notify chghost extended-join identify-msg multi-prefix 12 | :barjavel.freenode.net CAP zeektest ACK :account-notify away-notify cap-notify chghost extended-join identify-msg multi-prefix 13 | CAP END 14 | :barjavel.freenode.net 001 zeektest :Welcome to the freenode Internet Relay Chat Network zeektest 15 | :barjavel.freenode.net 002 zeektest :Your host is barjavel.freenode.net[195.154.200.232/6667], running version ircd-seven-1.1.9 16 | :barjavel.freenode.net 003 zeektest :This server was created Thu Dec 19 2019 at 20:10:02 UTC 17 | :barjavel.freenode.net 004 zeektest barjavel.freenode.net ircd-seven-1.1.9 DOQRSZaghilopsuwz CFILMPQSbcefgijklmnopqrstuvz bkloveqjfI 18 | :barjavel.freenode.net 005 zeektest CHANTYPES=# EXCEPTS INVEX CHANMODES=eIbq,k,flj,CFLMPQScgimnprstuz CHANLIMIT=#:120 PREFIX=(ov)@+ MAXLIST=bqeI:100 MODES=4 NETWORK=freenode STATUSMSG=@+ CALLERID=g CASEMAPPING=rfc1459 :are supported by this server 19 | :barjavel.freenode.net 005 zeektest CHARSET=ascii NICKLEN=16 CHANNELLEN=50 TOPICLEN=390 DEAF=D FNC TARGMAX=NAMES:1,LIST:1,KICK:1,WHOIS:1,PRIVMSG:4,NOTICE:4,ACCEPT:,MONITOR: EXTBAN=$,ajrxz CLIENTVER=3.0 WHOX KNOCK CPRIVMSG :are supported by this server 20 | :barjavel.freenode.net 005 zeektest CNOTICE ETRACE SAFELIST ELIST=CTU MONITOR=100 :are supported by this server 21 | :barjavel.freenode.net 251 zeektest :There are 101 users and 82081 invisible on 31 servers 22 | :barjavel.freenode.net 252 zeektest 43 :IRC Operators online 23 | :barjavel.freenode.net 253 zeektest 45 :unknown connection(s) 24 | :barjavel.freenode.net 254 zeektest 41982 :channels formed 25 | :barjavel.freenode.net 255 zeektest :I have 3809 clients and 1 servers 26 | :barjavel.freenode.net 265 zeektest 3809 5891 :Current local users 3809, max 5891 27 | :barjavel.freenode.net 266 zeektest 82182 90930 :Current global users 82182, max 90930 28 | :barjavel.freenode.net 250 zeektest :Highest connection count: 5892 (5891 clients) (1543159 connections received) 29 | :barjavel.freenode.net 375 zeektest :- barjavel.freenode.net Message of the Day - 30 | :barjavel.freenode.net 372 zeektest :- Welcome to barjavel.freenode.net in Paris, FR, EU. 31 | ...edited… 32 | :barjavel.freenode.net 372 zeektest :- Thank you for using freenode! 33 | :barjavel.freenode.net 376 zeektest :End of /MOTD command. 34 | :zeektest MODE zeektest :+i 35 | JOIN #freenode 36 | :zeektest!~zeektest@pool-XX-XXX-XXX-XX.washdc.fios.verizon.net JOIN #freenode * :realname 37 | :barjavel.freenode.net 332 zeektest #freenode :Welcome to #freenode | Don't copy/paste spam | No politics. | Feel free to message staff at any time. You can find us using /stats p (shows immediately-available staff) or /who freenode/staff/* (shows all staff) 38 | :barjavel.freenode.net 333 zeektest #freenode deadk 1604191950 39 | ...edited… 40 | :ChanServ!ChanServ@services. NOTICE zeektest :+[#freenode] Please read the topic. 41 | :services. 328 zeektest #freenode :https://freenode.net/ 42 | WHO #freenode %chtsunfra,152 43 | :barjavel.freenode.net 324 zeektest #freenode +CLPcntjf 5:10 #freenode-overflow 44 | ...edited… 45 | PING LAG641756037 46 | :barjavel.freenode.net PONG barjavel.freenode.net :LAG641756037 47 | :willcl_ark!~quassel@cpc123780-trow7-2-0-cust177.18-1.cable.virginm.net AWAY :Away 48 | :EGH!~EGH@79.142.76.202 JOIN #freenode EGH :Erik 49 | PRIVMSG #freenode :One more test... thanks everyone. 50 | QUIT :Leaving 51 | :zeektest!~zeektest@pool-XX-XXX-XXX-XX.washdc.fios.verizon.net QUIT :Client Quit 52 | ERROR :Closing Link: pool-XX-XXX-XXX-XX.washdc.fios.verizon.net (Client Quit) 53 | -------------------------------------------------------------------------------- /progjar4c/irc-client/ircapp.py: -------------------------------------------------------------------------------- 1 | import curses 2 | import threading 3 | from curses.textpad import Textbox, rectangle 4 | import threading 5 | import shlex 6 | from library import * 7 | import random 8 | 9 | class MyIRCClient(threading.Thread): 10 | def __init__(self,ircserver='irc.libera.chat',ircport=6667): 11 | self.ircserver = ircserver 12 | self.ircport = ircport 13 | self.sock = None 14 | self.win = None 15 | self.jalan = True 16 | self.sock = make_socket(self.ircserver, self.ircport) 17 | threading.Thread.__init__(self) 18 | def setwin(self,win): 19 | self.win = win 20 | def motd(self,params): 21 | kirim = f"MOTD\r\n" 22 | self.win.addstr(kirim) 23 | self.sock.sendall(kirim.encode()) 24 | def auth(self,params): 25 | username = params[0] 26 | realname=params[1] 27 | kirim = f"NICK {username}\r\nUSER {username} 0 * :{realname}\r\n" 28 | self.win.addstr(kirim) 29 | self.sock.sendall(kirim.encode()) 30 | def join(self,params): 31 | namachannel = params[0] 32 | kirim = f"JOIN {namachannel}\r\n" 33 | self.win.addstr(kirim) 34 | self.sock.sendall(kirim.encode()) 35 | def sendmessage(self,params): 36 | tujuan=params[0] 37 | message=params[1] 38 | kirim = f"PRIVMSG {tujuan} :{message}\r\n" 39 | self.win.addstr(kirim) 40 | self.sock.sendall(kirim.encode()) 41 | def ping(self,params): 42 | kirim = f"PING {random.randint(10000,12000)}\r\n" 43 | self.win.addstr(kirim) 44 | self.sock.sendall(kirim.encode()) 45 | def stopit(self): 46 | self.jalan = False 47 | def run(self): 48 | data_received = "" 49 | baris = [] 50 | while self.jalan == True: 51 | data = self.sock.recv(32) 52 | if data: 53 | # data is not empty, concat with previous content 54 | data_received += data.decode() 55 | #logging.warning(data_received) 56 | for g in data_received.splitlines(): 57 | self.win.addstr(f"{g}\n") 58 | self.win.refresh() 59 | 60 | 61 | class MyInputProcessor: 62 | def __init__(self, irc_client_thread): 63 | self.irc_client_thread = irc_client_thread 64 | def execute(self,s): 65 | c = shlex.split(s) 66 | try: 67 | command = c[0] 68 | params = [x for x in c[1:]] 69 | cl = getattr(self.irc_client_thread,command)(params) 70 | return cl 71 | except Exception as ee: 72 | return f"ERROR: {str(ee)}" 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | class MyUI(threading.Thread): 82 | def __init__(self): 83 | self.irc_client = None 84 | self.input_processor = None 85 | threading.Thread.__init__(self) 86 | def run(self): 87 | curses.wrapper(self.interaksi) 88 | def interaksi(self,stdscr): 89 | stdscr = curses.initscr() 90 | curses.echo() 91 | stdscr.clear() 92 | stdscr.refresh() 93 | stdscr.border(0) 94 | height, width = stdscr.getmaxyx() 95 | boxwin = curses.newwin(height,width) 96 | boxwin.scrollok(True) 97 | stdscr.addstr(height-2, 0, "Masukkan perintah") 98 | boxwin.refresh() 99 | #boxwin.box() 100 | self.irc_client = MyIRCClient() 101 | self.irc_client.setwin(boxwin) 102 | self.input_processor = MyInputProcessor(self.irc_client) 103 | self.irc_client.start() 104 | 105 | while True: 106 | #stdscr.clear() 107 | s = stdscr.getstr(height-1,0,90) 108 | boxwin.addstr(f"[C]---> {s.decode()}\n") 109 | boxwin.refresh() 110 | if s.decode()=="quit": 111 | self.irc_client.stopit() 112 | break 113 | result = self.input_processor.execute(s.decode()) 114 | #boxwin.clear() 115 | if (type(result) is str): 116 | if result.startswith("ERROR"): 117 | stdscr.addstr(height-2,0,result) 118 | #boxwin.refresh() 119 | stdscr.refresh() 120 | 121 | if __name__=='__main__': 122 | t = MyUI() 123 | t.start() 124 | t.join(timeout=5) 125 | 126 | -------------------------------------------------------------------------------- /progjar9/client1/play_nonet.py: -------------------------------------------------------------------------------- 1 | from kivy.uix.button import Button 2 | from kivy.uix.widget import Widget 3 | from kivy.uix.label import Label 4 | from kivy.uix.boxlayout import BoxLayout 5 | from kivy.app import App 6 | from kivy.graphics import Color, Rectangle, Line 7 | from functools import partial 8 | from kivy.clock import Clock 9 | 10 | import socket 11 | import logging 12 | import json 13 | 14 | 15 | class Player: 16 | def __init__(self,idplayer='1',r=1,g=0,b=0): 17 | self.current_x = 100 18 | self.current_y = 100 19 | self.warna_r = r 20 | self.warna_g = g 21 | self.warna_b = b 22 | self.idplayer = idplayer 23 | self.widget = Widget() 24 | self.buttons = None 25 | self.inisialiasi() 26 | #self.draw(self.widget,self.warna_r,self.warna_g,self.warna_b) 27 | def get_idplayer(self): 28 | return self.idplayer 29 | def set_xy(self,x=100,y=100): 30 | self.current_x = x 31 | self.current_y = y 32 | self.draw() 33 | #self.draw(self.widget, self.warna_r, self.warna_g, self.warna_b) 34 | 35 | def get_widget(self): 36 | return self.widget 37 | def get_buttons(self): 38 | return self.buttons 39 | 40 | def draw(self): 41 | #self.current_x, self.current_y = self.client_interface.get_location() 42 | wid = self.widget 43 | r = self.warna_r 44 | g = self.warna_g 45 | b = self.warna_b 46 | 47 | with wid.canvas: 48 | Color(r,g,b) 49 | Line(rectangle=(self.current_x,self.current_y, 200, 200)) 50 | 51 | def move(self,wid, arah,*kwargs): 52 | #self.draw(wid,0,0,0) 53 | if (arah=='right'): 54 | self.current_x = self.current_x + 10 55 | if (arah=='left'): 56 | self.current_x = self.current_x - 10 57 | if (arah=='up'): 58 | self.current_y = self.current_y + 10 59 | if (arah=='down'): 60 | self.current_y = self.current_y - 10 61 | #self.client_interface.set_location(self.current_x,self.current_y) 62 | #self.draw(wid,self.warna_r,self.warna_g,self.warna_b) 63 | 64 | def inisialiasi(self): 65 | wid = self.widget 66 | btn_left = Button(text='left',on_press=partial(self.move, wid, 'left')) 67 | btn_up = Button(text='up',on_press=partial(self.move, wid, 'up')) 68 | btn_down = Button(text='down',on_press=partial(self.move, wid, 'down')) 69 | btn_right = Button(text='right',on_press=partial(self.move, wid, 'right')) 70 | 71 | self.buttons = BoxLayout(size_hint=(1, None), height=50) 72 | self.buttons.add_widget(btn_left) 73 | self.buttons.add_widget(btn_up) 74 | self.buttons.add_widget(btn_down) 75 | self.buttons.add_widget(btn_right) 76 | 77 | 78 | 79 | class MyApp(App): 80 | players = [] 81 | def refresh(self,callback): 82 | for i in self.players: 83 | i.get_widget().canvas.clear() 84 | i.draw() 85 | 86 | def build(self): 87 | 88 | p1 = Player('1',1,0,0) 89 | p1.set_xy(100,100) 90 | widget1 = p1.get_widget() 91 | buttons1 = p1.get_buttons() 92 | self.players.append(p1) 93 | 94 | 95 | p2 = Player('2',0,1,0) 96 | p2.set_xy(100,200) 97 | widget2 = p2.get_widget() 98 | buttons2 = p2.get_buttons() 99 | self.players.append(p2) 100 | 101 | # p3 = Player('3',0,1,0) 102 | # p3.set_xy(150,150) 103 | # widget3 = p3.get_widget() 104 | # buttons3 = p3.get_buttons() 105 | # self.players.append(p3) 106 | 107 | # p4 = Player('4',0,1,1) 108 | # p4.set_xy(150,150) 109 | # widget4 = p4.get_widget() 110 | # buttons4 = p4.get_buttons() 111 | # self.players.append(p4) 112 | 113 | root = BoxLayout(orientation='horizontal') 114 | root.add_widget(widget1) 115 | root.add_widget(buttons1) 116 | root.add_widget(widget2) 117 | root.add_widget(buttons2) 118 | # root.add_widget(widget3) 119 | # root.add_widget(buttons3) 120 | # root.add_widget(widget4) 121 | # root.add_widget(buttons4) 122 | 123 | 124 | Clock.schedule_interval(self.refresh,1/60) 125 | 126 | return root 127 | 128 | if __name__ == '__main__': 129 | MyApp().run() -------------------------------------------------------------------------------- /progjar1a/client_side/tcp_client.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import json 4 | import logging 5 | import xmltodict 6 | import ssl 7 | import os 8 | 9 | server_address = ('localhost', 12000) 10 | 11 | def make_socket(destination_address='localhost',port=12000): 12 | try: 13 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 14 | server_address = (destination_address, port) 15 | logging.warning(f"connecting to {server_address}") 16 | sock.connect(server_address) 17 | return sock 18 | except Exception as ee: 19 | logging.warning(f"error {str(ee)}") 20 | 21 | def make_secure_socket(destination_address='localhost',port=10000): 22 | try: 23 | #get it from https://curl.se/docs/caextract.html 24 | 25 | context = ssl.create_default_context() 26 | context.check_hostname = False 27 | context.verify_mode=ssl.CERT_NONE 28 | context.load_verify_locations(os.getcwd() + '/domain.crt') 29 | 30 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 31 | server_address = (destination_address, port) 32 | logging.warning(f"connecting to {server_address}") 33 | sock.connect(server_address) 34 | secure_socket = context.wrap_socket(sock,server_hostname=destination_address) 35 | logging.warning(secure_socket.getpeercert()) 36 | return secure_socket 37 | except Exception as ee: 38 | logging.warning(f"error {str(ee)}") 39 | 40 | def deserialisasi(s): 41 | logging.warning(f"deserialisasi {s.strip()}") 42 | return json.loads(s) 43 | 44 | 45 | def send_command(command_str,is_secure=False): 46 | alamat_server = server_address[0] 47 | port_server = server_address[1] 48 | # sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 49 | # gunakan fungsi diatas 50 | if is_secure == True: 51 | sock = make_secure_socket(alamat_server,port_server) 52 | else: 53 | sock = make_socket(alamat_server,port_server) 54 | 55 | logging.warning(f"connecting to {server_address}") 56 | try: 57 | logging.warning(f"sending message ") 58 | sock.sendall(command_str.encode()) 59 | # Look for the response, waiting until socket is done (no more data) 60 | data_received="" #empty string 61 | while True: 62 | #socket does not receive all data at once, data comes in part, need to be concatenated at the end of process 63 | data = sock.recv(16) 64 | if data: 65 | #data is not empty, concat with previous content 66 | data_received += data.decode() 67 | if "\r\n\r\n" in data_received: 68 | break 69 | else: 70 | # no more data, stop the process by break 71 | break 72 | # at this point, data_received (string) will contain all data coming from the socket 73 | # to be able to use the data_received as a dict, need to load it using json.loads() 74 | hasil = deserialisasi(data_received) 75 | logging.warning("data received from server:") 76 | return hasil 77 | except Exception as ee: 78 | logging.warning(f"error during data receiving {str(ee)}") 79 | return False 80 | 81 | 82 | 83 | def getdatapemain(nomor=0,is_secure=False): 84 | cmd=f"getdatapemain {nomor}\r\n\r\n" 85 | hasil = send_command(cmd,is_secure=is_secure) 86 | return hasil 87 | 88 | def lihatversi(is_secure=False): 89 | cmd=f"versi \r\n\r\n" 90 | hasil = send_command(cmd,is_secure=is_secure) 91 | return hasil 92 | 93 | 94 | 95 | if __name__=='__main__': 96 | h = lihatversi(is_secure=True) 97 | if (h): 98 | print(h) 99 | 100 | h = getdatapemain(1,is_secure=True) 101 | if (h): 102 | print(h['nama'],h['nomor']) 103 | else: 104 | print("kegagalan pada data transfer") 105 | 106 | h = getdatapemain(2,is_secure=True) 107 | if (h): 108 | print(h['nama'],h['nomor']) 109 | else: 110 | print("kegagalan pada data transfer") 111 | 112 | h = getdatapemain(3,is_secure=True) 113 | if (h): 114 | print(h['nama'],h['nomor']) 115 | else: 116 | print("kegagalan pada data transfer") 117 | 118 | h = getdatapemain(4,is_secure=True) 119 | if (h): 120 | print(h['nama'],h['nomor']) 121 | else: 122 | print("kegagalan pada data transfer") 123 | -------------------------------------------------------------------------------- /progjar4c/chatserver/chat.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import os 3 | import json 4 | import uuid 5 | import logging 6 | from queue import Queue 7 | 8 | class Chat: 9 | def __init__(self): 10 | self.sessions={} 11 | self.users = {} 12 | self.users['messi']={ 'nama': 'Lionel Messi', 'negara': 'Argentina', 'password': 'surabaya', 'incoming' : {}, 'outgoing': {}} 13 | self.users['henderson']={ 'nama': 'Jordan Henderson', 'negara': 'Inggris', 'password': 'surabaya', 'incoming': {}, 'outgoing': {}} 14 | self.users['lineker']={ 'nama': 'Gary Lineker', 'negara': 'Inggris', 'password': 'surabaya','incoming': {}, 'outgoing':{}} 15 | def proses(self,data): 16 | j=data.split(" ") 17 | try: 18 | command=j[0].strip() 19 | if (command=='auth'): 20 | username=j[1].strip() 21 | password=j[2].strip() 22 | logging.warning("AUTH: auth {} {}" . format(username,password)) 23 | return self.autentikasi_user(username,password) 24 | elif (command=='send'): 25 | sessionid = j[1].strip() 26 | usernameto = j[2].strip() 27 | message="" 28 | for w in j[3:]: 29 | message="{} {}" . format(message,w) 30 | usernamefrom = self.sessions[sessionid]['username'] 31 | logging.warning("SEND: session {} send message from {} to {}" . format(sessionid, usernamefrom,usernameto)) 32 | return self.send_message(sessionid,usernamefrom,usernameto,message) 33 | elif (command=='inbox'): 34 | sessionid = j[1].strip() 35 | username = self.sessions[sessionid]['username'] 36 | logging.warning("INBOX: {}" . format(sessionid)) 37 | return self.get_inbox(username) 38 | else: 39 | return {'status': 'ERROR', 'message': '**Protocol Tidak Benar'} 40 | except KeyError: 41 | return { 'status': 'ERROR', 'message' : 'Informasi tidak ditemukan'} 42 | except IndexError: 43 | return {'status': 'ERROR', 'message': '--Protocol Tidak Benar'} 44 | def autentikasi_user(self,username,password): 45 | if (username not in self.users): 46 | return { 'status': 'ERROR', 'message': 'User Tidak Ada' } 47 | if (self.users[username]['password']!= password): 48 | return { 'status': 'ERROR', 'message': 'Password Salah' } 49 | tokenid = str(uuid.uuid4()) 50 | self.sessions[tokenid]={ 'username': username, 'userdetail':self.users[username]} 51 | return { 'status': 'OK', 'tokenid': tokenid } 52 | def get_user(self,username): 53 | if (username not in self.users): 54 | return False 55 | return self.users[username] 56 | def send_message(self,sessionid,username_from,username_dest,message): 57 | if (sessionid not in self.sessions): 58 | return {'status': 'ERROR', 'message': 'Session Tidak Ditemukan'} 59 | s_fr = self.get_user(username_from) 60 | s_to = self.get_user(username_dest) 61 | 62 | if (s_fr==False or s_to==False): 63 | return {'status': 'ERROR', 'message': 'User Tidak Ditemukan'} 64 | 65 | message = { 'msg_from': s_fr['nama'], 'msg_to': s_to['nama'], 'msg': message } 66 | outqueue_sender = s_fr['outgoing'] 67 | inqueue_receiver = s_to['incoming'] 68 | try: 69 | outqueue_sender[username_from].put(message) 70 | except KeyError: 71 | outqueue_sender[username_from]=Queue() 72 | outqueue_sender[username_from].put(message) 73 | try: 74 | inqueue_receiver[username_from].put(message) 75 | except KeyError: 76 | inqueue_receiver[username_from]=Queue() 77 | inqueue_receiver[username_from].put(message) 78 | return {'status': 'OK', 'message': 'Message Sent'} 79 | 80 | def get_inbox(self,username): 81 | s_fr = self.get_user(username) 82 | incoming = s_fr['incoming'] 83 | msgs={} 84 | for users in incoming: 85 | msgs[users]=[] 86 | while not incoming[users].empty(): 87 | msgs[users].append(s_fr['incoming'][users].get_nowait()) 88 | 89 | return {'status': 'OK', 'messages': msgs} 90 | 91 | 92 | if __name__=="__main__": 93 | j = Chat() 94 | sesi = j.proses("auth messi surabaya") 95 | print(sesi) 96 | #sesi = j.autentikasi_user('messi','surabaya') 97 | #print sesi 98 | tokenid = sesi['tokenid'] 99 | print(j.proses("send {} henderson hello gimana kabarnya son " . format(tokenid))) 100 | print(j.proses("send {} messi hello gimana kabarnya mess " . format(tokenid))) 101 | 102 | #print j.send_message(tokenid,'messi','henderson','hello son') 103 | #print j.send_message(tokenid,'henderson','messi','hello si') 104 | #print j.send_message(tokenid,'lineker','messi','hello si dari lineker') 105 | 106 | 107 | print("isi mailbox dari messi") 108 | print(j.get_inbox('messi')) 109 | print("isi mailbox dari henderson") 110 | print(j.get_inbox('henderson')) 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | -------------------------------------------------------------------------------- /environment-demo/app/server/chat.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import os 3 | import json 4 | import uuid 5 | import logging 6 | from queue import Queue 7 | 8 | class Chat: 9 | def __init__(self): 10 | self.sessions={} 11 | self.users = {} 12 | self.users['messi']={ 'nama': 'Lionel Messi', 'negara': 'Argentina', 'password': 'surabaya', 'incoming' : {}, 'outgoing': {}} 13 | self.users['henderson']={ 'nama': 'Jordan Henderson', 'negara': 'Inggris', 'password': 'surabaya', 'incoming': {}, 'outgoing': {}} 14 | self.users['lineker']={ 'nama': 'Gary Lineker', 'negara': 'Inggris', 'password': 'surabaya','incoming': {}, 'outgoing':{}} 15 | def proses(self,data): 16 | j=data.split(" ") 17 | try: 18 | command=j[0].strip() 19 | if (command=='auth'): 20 | username=j[1].strip() 21 | password=j[2].strip() 22 | logging.warning("AUTH: auth {} {}" . format(username,password)) 23 | return self.autentikasi_user(username,password) 24 | elif (command=='send'): 25 | sessionid = j[1].strip() 26 | usernameto = j[2].strip() 27 | message="" 28 | for w in j[3:]: 29 | message="{} {}" . format(message,w) 30 | usernamefrom = self.sessions[sessionid]['username'] 31 | logging.warning("SEND: session {} send message from {} to {}" . format(sessionid, usernamefrom,usernameto)) 32 | return self.send_message(sessionid,usernamefrom,usernameto,message) 33 | elif (command=='inbox'): 34 | sessionid = j[1].strip() 35 | username = self.sessions[sessionid]['username'] 36 | logging.warning("INBOX: {}" . format(sessionid)) 37 | return self.get_inbox(username) 38 | else: 39 | return {'status': 'ERROR', 'message': '**Protocol Tidak Benar'} 40 | except KeyError: 41 | return { 'status': 'ERROR', 'message' : 'Informasi tidak ditemukan'} 42 | except IndexError: 43 | return {'status': 'ERROR', 'message': '--Protocol Tidak Benar'} 44 | def autentikasi_user(self,username,password): 45 | if (username not in self.users): 46 | return { 'status': 'ERROR', 'message': 'User Tidak Ada' } 47 | if (self.users[username]['password']!= password): 48 | return { 'status': 'ERROR', 'message': 'Password Salah' } 49 | tokenid = str(uuid.uuid4()) 50 | self.sessions[tokenid]={ 'username': username, 'userdetail':self.users[username]} 51 | return { 'status': 'OK', 'tokenid': tokenid } 52 | def get_user(self,username): 53 | if (username not in self.users): 54 | return False 55 | return self.users[username] 56 | def send_message(self,sessionid,username_from,username_dest,message): 57 | if (sessionid not in self.sessions): 58 | return {'status': 'ERROR', 'message': 'Session Tidak Ditemukan'} 59 | s_fr = self.get_user(username_from) 60 | s_to = self.get_user(username_dest) 61 | 62 | if (s_fr==False or s_to==False): 63 | return {'status': 'ERROR', 'message': 'User Tidak Ditemukan'} 64 | 65 | message = { 'msg_from': s_fr['nama'], 'msg_to': s_to['nama'], 'msg': message } 66 | outqueue_sender = s_fr['outgoing'] 67 | inqueue_receiver = s_to['incoming'] 68 | try: 69 | outqueue_sender[username_from].put(message) 70 | except KeyError: 71 | outqueue_sender[username_from]=Queue() 72 | outqueue_sender[username_from].put(message) 73 | try: 74 | inqueue_receiver[username_from].put(message) 75 | except KeyError: 76 | inqueue_receiver[username_from]=Queue() 77 | inqueue_receiver[username_from].put(message) 78 | return {'status': 'OK', 'message': 'Message Sent'} 79 | 80 | def get_inbox(self,username): 81 | s_fr = self.get_user(username) 82 | incoming = s_fr['incoming'] 83 | msgs={} 84 | for users in incoming: 85 | msgs[users]=[] 86 | while not incoming[users].empty(): 87 | msgs[users].append(s_fr['incoming'][users].get_nowait()) 88 | 89 | return {'status': 'OK', 'messages': msgs} 90 | 91 | 92 | if __name__=="__main__": 93 | j = Chat() 94 | sesi = j.proses("auth messi surabaya") 95 | print(sesi) 96 | #sesi = j.autentikasi_user('messi','surabaya') 97 | #print sesi 98 | tokenid = sesi['tokenid'] 99 | print(j.proses("send {} henderson hello gimana kabarnya son " . format(tokenid))) 100 | print(j.proses("send {} messi hello gimana kabarnya mess " . format(tokenid))) 101 | 102 | #print j.send_message(tokenid,'messi','henderson','hello son') 103 | #print j.send_message(tokenid,'henderson','messi','hello si') 104 | #print j.send_message(tokenid,'lineker','messi','hello si dari lineker') 105 | 106 | 107 | print("isi mailbox dari messi") 108 | print(j.get_inbox('messi')) 109 | print("isi mailbox dari henderson") 110 | print(j.get_inbox('henderson')) 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | -------------------------------------------------------------------------------- /progjar1a/server_side/tcp_server.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import socket 3 | import logging 4 | import json 5 | import dicttoxml 6 | import os 7 | import ssl 8 | 9 | alldata = dict() 10 | alldata['1']=dict(nomor=1, nama="dean henderson", posisi="kiper") 11 | alldata['2']=dict(nomor=2, nama="luke shaw", posisi="bek kiri") 12 | alldata['3']=dict(nomor=3, nama="aaron wan-bissaka", posisi="bek kanan") 13 | alldata['4']=dict(nomor=4, nama="victor lindelof", posisi="bek tengah kanan") 14 | 15 | def versi(): 16 | return "versi 0.0.1" 17 | 18 | 19 | def proses_request(request_string): 20 | #format request 21 | # NAMACOMMAND spasi PARAMETER 22 | cstring = request_string.split(" ") 23 | hasil = None 24 | try: 25 | command = cstring[0].strip() 26 | if (command == 'getdatapemain'): 27 | # getdata spasi parameter1 28 | # parameter1 harus berupa nomor pemain 29 | logging.warning("getdata") 30 | nomorpemain = cstring[1].strip() 31 | try: 32 | logging.warning(f"data {nomorpemain} ketemu") 33 | hasil = alldata[nomorpemain] 34 | except: 35 | hasil = None 36 | elif (command == 'versi'): 37 | hasil = versi() 38 | except: 39 | hasil = None 40 | return hasil 41 | 42 | 43 | def serialisasi(a): 44 | #print(a) 45 | #serialized = str(dicttoxml.dicttoxml(a)) 46 | serialized = json.dumps(a) 47 | logging.warning("serialized data") 48 | logging.warning(serialized) 49 | return serialized 50 | 51 | def run_server(server_address,is_secure=False): 52 | # ------------------------------ SECURE SOCKET INITIALIZATION ---- 53 | if is_secure == True: 54 | print(os.getcwd()) 55 | cert_location = os.getcwd() + '/certs/' 56 | socket_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) 57 | socket_context.verify_flags = ssl.CERT_NONE 58 | socket_context.load_cert_chain( 59 | certfile=cert_location + 'domain.crt', 60 | keyfile=cert_location + 'domain.key' 61 | ) 62 | # --------------------------------- 63 | 64 | #--- INISIALISATION --- 65 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 66 | sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 67 | # Bind the socket to the port 68 | logging.warning(f"starting up on {server_address}") 69 | sock.bind(server_address) 70 | # Listen for incoming connections 71 | sock.listen(1000) 72 | 73 | 74 | while True: 75 | # Wait for a connection 76 | logging.warning("waiting for a connection") 77 | koneksi, client_address = sock.accept() 78 | logging.warning(f"Incoming connection from {client_address}") 79 | # Receive the data in small chunks and retransmit it 80 | 81 | try: 82 | if is_secure == True: 83 | connection = socket_context.wrap_socket(koneksi, server_side=True) 84 | else: 85 | connection = koneksi 86 | 87 | selesai=False 88 | data_received="" #string 89 | while True: 90 | data = connection.recv(32) 91 | logging.warning(f"received {data}") 92 | if data: 93 | data_received += data.decode() 94 | if "\r\n\r\n" in data_received: 95 | selesai=True 96 | 97 | if (selesai==True): 98 | hasil = proses_request(data_received) 99 | logging.warning(f"hasil proses: {hasil}") 100 | 101 | #hasil bisa berupa tipe dictionary 102 | #harus diserialisasi dulu sebelum dikirim via network 103 | # Send data 104 | # some data structure may have complex structure 105 | # how to send such data structure through the network ? 106 | # use serialization 107 | # example : json, xml 108 | 109 | # complex structure, nested dict 110 | # all data that will be sent through network has to be encoded into bytes type" 111 | # in this case, the message (type: string) will be encoded to bytes by calling encode 112 | 113 | hasil = serialisasi(hasil) 114 | hasil += "\r\n\r\n" 115 | connection.sendall(hasil.encode()) 116 | selesai = False 117 | data_received = "" # string 118 | break 119 | 120 | else: 121 | logging.warning(f"no more data from {client_address}") 122 | break 123 | # Clean up the connection 124 | except ssl.SSLError as error_ssl: 125 | logging.warning(f"SSL error: {str(error_ssl)}") 126 | 127 | if __name__=='__main__': 128 | try: 129 | run_server(('0.0.0.0', 12000),is_secure=True) 130 | except KeyboardInterrupt: 131 | logging.warning("Control-C: Program berhenti") 132 | exit(0) 133 | finally: 134 | logging.warning("seelsai") 135 | -------------------------------------------------------------------------------- /progjar9/client2/tank_multi_player1.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | import sys 3 | 4 | import socket 5 | import logging 6 | import json 7 | 8 | 9 | 10 | # Initialize Pygame 11 | pygame.init() 12 | 13 | WIDTH, HEIGHT = 640, 480 14 | screen = pygame.display.set_mode((WIDTH, HEIGHT)) 15 | pygame.display.set_caption("Progjar Tank Game") 16 | 17 | clock = pygame.time.Clock() 18 | FPS = 60 19 | 20 | image_size=(64,64) 21 | tank_images=dict() 22 | tank_images['1'] = { 23 | "up": pygame.transform.scale(pygame.image.load("p1/tank_up.png"), image_size), 24 | "down": pygame.transform.scale(pygame.image.load("p1/tank_down.png"), image_size), 25 | "left": pygame.transform.scale(pygame.image.load("p1/tank_left.png"), image_size), 26 | "right": pygame.transform.scale(pygame.image.load("p1/tank_right.png"), image_size), 27 | } 28 | 29 | tank_images['2'] = { 30 | "up": pygame.transform.scale(pygame.image.load("p2/tank_up.png"), image_size), 31 | "down": pygame.transform.scale(pygame.image.load("p2/tank_down.png"), image_size), 32 | "left": pygame.transform.scale(pygame.image.load("p2/tank_left.png"), image_size), 33 | "right": pygame.transform.scale(pygame.image.load("p2/tank_right.png"), image_size), 34 | } 35 | 36 | 37 | class ClientInterface: 38 | def __init__(self,idplayer='1'): 39 | self.idplayer=idplayer 40 | self.server_address=('10.21.84.254',55555) 41 | 42 | def send_command(self,command_str=""): 43 | global server_address 44 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 45 | sock.connect(self.server_address) 46 | logging.warning(f"connecting to {self.server_address}") 47 | try: 48 | logging.warning(f"sending message ") 49 | sock.sendall(command_str.encode()) 50 | # Look for the response, waiting until socket is done (no more data) 51 | data_received="" #empty string 52 | while True: 53 | #socket does not receive all data at once, data comes in part, need to be concatenated at the end of process 54 | data = sock.recv(16) 55 | if data: 56 | #data is not empty, concat with previous content 57 | data_received += data.decode() 58 | if "\r\n\r\n" in data_received: 59 | break 60 | else: 61 | # no more data, stop the process by break 62 | break 63 | # at this point, data_received (string) will contain all data coming from the socket 64 | # to be able to use the data_received as a dict, need to load it using json.loads() 65 | hasil = json.loads(data_received) 66 | logging.warning("data received from server:") 67 | return hasil 68 | except: 69 | logging.warning("error during data receiving") 70 | return False 71 | 72 | def set_location(self,x=100,y=100): 73 | player = self.idplayer 74 | command_str=f"set_location {player} {x} {y}" 75 | hasil = self.send_command(command_str) 76 | if (hasil['status']=='OK'): 77 | return True 78 | else: 79 | return False 80 | 81 | def get_location(self): 82 | player = self.idplayer 83 | command_str=f"get_location {player}" 84 | hasil = self.send_command(command_str) 85 | if (hasil['status']=='OK'): 86 | lokasi = hasil['location'].split(',') 87 | return (int(lokasi[0]),int(lokasi[1])) 88 | else: 89 | return False 90 | 91 | 92 | class Tank: 93 | def __init__(self,id='1',isremote=False): 94 | self.id = id 95 | self.isremote=isremote 96 | self.image = tank_images[self.id]["up"] 97 | self.direction = "up" 98 | self.x = WIDTH // 2 99 | self.y = HEIGHT // 2 100 | self.speed = 5 101 | self.client_interface = ClientInterface(self.id) 102 | 103 | def move(self, keys): 104 | if (self.isremote==False): 105 | if keys[pygame.K_UP]: 106 | self.y -= self.speed 107 | self.direction = "up" 108 | elif keys[pygame.K_DOWN]: 109 | self.y += self.speed 110 | self.direction = "down" 111 | elif keys[pygame.K_LEFT]: 112 | self.x -= self.speed 113 | self.direction = "left" 114 | elif keys[pygame.K_RIGHT]: 115 | self.x += self.speed 116 | self.direction = "right" 117 | self.client_interface.set_location(self.x, self.y) 118 | else: 119 | self.x, self.y = self.client_interface.get_location() 120 | 121 | self.image = tank_images[self.id][self.direction] 122 | 123 | def draw(self, surface): 124 | surface.blit(self.image, (self.x, self.y)) 125 | 126 | tank1 = Tank('1') 127 | tank2 = Tank('2',isremote=True) 128 | 129 | while True: 130 | screen.fill((255, 255, 255)) 131 | 132 | for event in pygame.event.get(): 133 | if event.type == pygame.QUIT: 134 | pygame.quit() 135 | sys.exit() 136 | 137 | keys = pygame.key.get_pressed() 138 | tank1.move(keys) 139 | tank1.draw(screen) 140 | tank2.move(keys) 141 | tank2.draw(screen) 142 | 143 | 144 | pygame.display.flip() 145 | clock.tick(FPS) 146 | -------------------------------------------------------------------------------- /progjar9/client2/tank_multi_player2.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | import sys 3 | 4 | import socket 5 | import logging 6 | import json 7 | 8 | 9 | 10 | # Initialize Pygame 11 | pygame.init() 12 | 13 | WIDTH, HEIGHT = 640, 480 14 | screen = pygame.display.set_mode((WIDTH, HEIGHT)) 15 | pygame.display.set_caption("Progjar Tank Game") 16 | 17 | clock = pygame.time.Clock() 18 | FPS = 60 19 | 20 | image_size=(64,64) 21 | tank_images=dict() 22 | tank_images['1'] = { 23 | "up": pygame.transform.scale(pygame.image.load("p1/tank_up.png"), image_size), 24 | "down": pygame.transform.scale(pygame.image.load("p1/tank_down.png"), image_size), 25 | "left": pygame.transform.scale(pygame.image.load("p1/tank_left.png"), image_size), 26 | "right": pygame.transform.scale(pygame.image.load("p1/tank_right.png"), image_size), 27 | } 28 | 29 | tank_images['2'] = { 30 | "up": pygame.transform.scale(pygame.image.load("p2/tank_up.png"), image_size), 31 | "down": pygame.transform.scale(pygame.image.load("p2/tank_down.png"), image_size), 32 | "left": pygame.transform.scale(pygame.image.load("p2/tank_left.png"), image_size), 33 | "right": pygame.transform.scale(pygame.image.load("p2/tank_right.png"), image_size), 34 | } 35 | 36 | 37 | class ClientInterface: 38 | def __init__(self,idplayer='1'): 39 | self.idplayer=idplayer 40 | self.server_address=('10.21.84.254',55555) 41 | 42 | def send_command(self,command_str=""): 43 | global server_address 44 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 45 | sock.connect(self.server_address) 46 | logging.warning(f"connecting to {self.server_address}") 47 | try: 48 | logging.warning(f"sending message ") 49 | sock.sendall(command_str.encode()) 50 | # Look for the response, waiting until socket is done (no more data) 51 | data_received="" #empty string 52 | while True: 53 | #socket does not receive all data at once, data comes in part, need to be concatenated at the end of process 54 | data = sock.recv(16) 55 | if data: 56 | #data is not empty, concat with previous content 57 | data_received += data.decode() 58 | if "\r\n\r\n" in data_received: 59 | break 60 | else: 61 | # no more data, stop the process by break 62 | break 63 | # at this point, data_received (string) will contain all data coming from the socket 64 | # to be able to use the data_received as a dict, need to load it using json.loads() 65 | hasil = json.loads(data_received) 66 | logging.warning("data received from server:") 67 | return hasil 68 | except: 69 | logging.warning("error during data receiving") 70 | return False 71 | 72 | def set_location(self,x=100,y=100): 73 | player = self.idplayer 74 | command_str=f"set_location {player} {x} {y}" 75 | hasil = self.send_command(command_str) 76 | if (hasil['status']=='OK'): 77 | return True 78 | else: 79 | return False 80 | 81 | def get_location(self): 82 | player = self.idplayer 83 | command_str=f"get_location {player}" 84 | hasil = self.send_command(command_str) 85 | if (hasil['status']=='OK'): 86 | lokasi = hasil['location'].split(',') 87 | return (int(lokasi[0]),int(lokasi[1])) 88 | else: 89 | return False 90 | 91 | 92 | class Tank: 93 | def __init__(self,id='1',isremote=False): 94 | self.id = id 95 | self.isremote=isremote 96 | self.image = tank_images[self.id]["up"] 97 | self.direction = "up" 98 | self.x = WIDTH // 2 99 | self.y = HEIGHT // 2 100 | self.speed = 5 101 | self.client_interface = ClientInterface(self.id) 102 | 103 | def move(self, keys): 104 | if (self.isremote==False): 105 | if keys[pygame.K_UP]: 106 | self.y -= self.speed 107 | self.direction = "up" 108 | elif keys[pygame.K_DOWN]: 109 | self.y += self.speed 110 | self.direction = "down" 111 | elif keys[pygame.K_LEFT]: 112 | self.x -= self.speed 113 | self.direction = "left" 114 | elif keys[pygame.K_RIGHT]: 115 | self.x += self.speed 116 | self.direction = "right" 117 | self.client_interface.set_location(self.x, self.y) 118 | else: 119 | self.x, self.y = self.client_interface.get_location() 120 | 121 | self.image = tank_images[self.id][self.direction] 122 | 123 | def draw(self, surface): 124 | surface.blit(self.image, (self.x, self.y)) 125 | 126 | tank1 = Tank('1',isremote=True) 127 | tank2 = Tank('2') 128 | 129 | while True: 130 | screen.fill((255, 255, 255)) 131 | 132 | for event in pygame.event.get(): 133 | if event.type == pygame.QUIT: 134 | pygame.quit() 135 | sys.exit() 136 | 137 | keys = pygame.key.get_pressed() 138 | tank1.move(keys) 139 | tank1.draw(screen) 140 | tank2.move(keys) 141 | tank2.draw(screen) 142 | 143 | 144 | pygame.display.flip() 145 | clock.tick(FPS) 146 | -------------------------------------------------------------------------------- /progjar9/client3/pac.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | import sys 3 | import io 4 | 5 | import socket 6 | import logging 7 | import json 8 | import base64 9 | 10 | 11 | 12 | # Initialize Pygame 13 | pygame.init() 14 | 15 | WIDTH, HEIGHT = 640, 480 16 | screen = pygame.display.set_mode((WIDTH, HEIGHT)) 17 | pygame.display.set_caption("Progjar Mr Pac Game") 18 | 19 | clock = pygame.time.Clock() 20 | FPS = 60 21 | image_size=(64,64) 22 | 23 | class ClientInterface: 24 | def __init__(self,idplayer='1'): 25 | self.idplayer=idplayer 26 | self.server_address=('10.21.84.254',55555) 27 | 28 | def get_other_players(self): 29 | command_str=f"get_all_players" 30 | hasil = self.send_command(command_str) 31 | if (hasil['status']=='OK'): 32 | h = hasil['players'] 33 | return h 34 | else: 35 | return False 36 | 37 | def get_players_face(self): 38 | idplayer = self.idplayer 39 | command_str=f"get_players_face {idplayer}" 40 | hasil = self.send_command(command_str) 41 | if (hasil['status']=='OK'): 42 | h = hasil['face'] 43 | return h 44 | else: 45 | return False 46 | 47 | def send_command(self,command_str=""): 48 | global server_address 49 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 50 | sock.connect(self.server_address) 51 | logging.warning(f"connecting to {self.server_address}") 52 | try: 53 | logging.warning(f"sending message ") 54 | sock.sendall(command_str.encode()) 55 | # Look for the response, waiting until socket is done (no more data) 56 | data_received="" #empty string 57 | while True: 58 | #socket does not receive all data at once, data comes in part, need to be concatenated at the end of process 59 | data = sock.recv(16) 60 | if data: 61 | #data is not empty, concat with previous content 62 | data_received += data.decode() 63 | if "\r\n\r\n" in data_received: 64 | break 65 | else: 66 | # no more data, stop the process by break 67 | break 68 | # at this point, data_received (string) will contain all data coming from the socket 69 | # to be able to use the data_received as a dict, need to load it using json.loads() 70 | hasil = json.loads(data_received) 71 | logging.warning("data received from server:") 72 | return hasil 73 | except: 74 | logging.warning("error during data receiving") 75 | return False 76 | 77 | def set_location(self,x=100,y=100): 78 | player = self.idplayer 79 | command_str=f"set_location {player} {x} {y}" 80 | hasil = self.send_command(command_str) 81 | if (hasil['status']=='OK'): 82 | return True 83 | else: 84 | return False 85 | 86 | def get_location(self): 87 | player = self.idplayer 88 | command_str=f"get_location {player}" 89 | hasil = self.send_command(command_str) 90 | if (hasil['status']=='OK'): 91 | lokasi = hasil['location'].split(',') 92 | return (int(lokasi[0]),int(lokasi[1])) 93 | else: 94 | return False 95 | 96 | 97 | class Pac: 98 | def __init__(self,id='1',isremote=False): 99 | self.id = id 100 | self.isremote=isremote 101 | self.direction = "up" 102 | self.x = WIDTH // 2 103 | self.y = HEIGHT // 2 104 | self.speed = 5 105 | self.client_interface = ClientInterface(self.id) 106 | self.face = self.client_interface.get_players_face() 107 | self.image = pygame.image.load(io.BytesIO(base64.b64decode(self.face))) 108 | 109 | def move(self, keys): 110 | if (self.isremote==False): 111 | if keys[pygame.K_UP]: 112 | self.y -= self.speed 113 | self.direction = "up" 114 | elif keys[pygame.K_DOWN]: 115 | self.y += self.speed 116 | self.direction = "down" 117 | elif keys[pygame.K_LEFT]: 118 | self.x -= self.speed 119 | self.direction = "left" 120 | elif keys[pygame.K_RIGHT]: 121 | self.x += self.speed 122 | self.direction = "right" 123 | self.client_interface.set_location(self.x, self.y) 124 | else: 125 | self.x, self.y = self.client_interface.get_location() 126 | 127 | def draw(self, surface): 128 | surface.blit(self.image, (self.x, self.y)) 129 | 130 | p_number = input("input your number, playa >>> ") 131 | current_player = Pac(p_number) 132 | 133 | players = dict() 134 | client = ClientInterface() 135 | other_players = client.get_other_players() 136 | for i in other_players: 137 | if (i==p_number): 138 | continue 139 | players[i]=Pac(i,isremote=True) 140 | 141 | while True: 142 | screen.fill((255, 255, 255)) 143 | 144 | for event in pygame.event.get(): 145 | if event.type == pygame.QUIT: 146 | pygame.quit() 147 | sys.exit() 148 | 149 | keys = pygame.key.get_pressed() 150 | current_player.move(keys) 151 | current_player.draw(screen) 152 | 153 | for i in players: 154 | players[i].move(keys) 155 | players[i].draw(screen) 156 | 157 | pygame.display.flip() 158 | clock.tick(FPS) 159 | --------------------------------------------------------------------------------