Initializing manage.py.

Set up a bare-bones for manage.py and removed manage.c. Bare-bones includes:
- Main function
- Import of re (regex library)
- Import of socket (socket library)
Added the parse_msg function.

parse_msg(msg):
	Description:
		parse_msg() takes a string and parses the string into an array of values separated by tabs
	params:
		msg: the string to be parsed
Added the kill_compute function.

kill_compute(sock):
	Description:
		Takes a socket connected to a compute process and sends it a kill message.
		The compute process(es) should then shutdown.
	params:
		sock: a socket connected to a compute process.
Added create_sock_stream function

create_sock_stream():
	Description:
		Creates a new stream socket.
Added bind_sock function.

bind_sock(sock, port):
	Description:
		Takes a socket and a port, and binds the socket to the port.
	params:
		sock: the socket to bind
		port: the port to bind the socket to
Added listen_and_accpet function.

listen_and_accept(sock, backlog):
	Description:
		takes a socket and the max number of backlog connects, then listens and accepts
	params:
		sock: the socket to listen/accept on
		backlog: max number of sockets to backlog
	return: the return value of sock.accept()
Added some constants/global variables and the compute function.

compute():
	Description:
		The main function should create a thread for managing compute processes.
		This function should be the start function when creating the thread that manages
		the compute processes.
		The compute() function connects to the clients compute process. The client then
		sends compute() timing information, which compute() calls get_max_num() to
		find the range to have the client search for perfect numbers in.
		Then compute() enters an infinite loop where it receives from the clients compute.
		The client should send the current number and whether it is perfect or not
		separated by a tab (e.g. "6\ttrue"). If the client is done, it should send "done".
		The compute() function takes the received message and first checks if the
		message is "done" (if so it returns, possibly later keep it going to allow other
		compute processes to connect), then if it doesn't it parses the message into an
		array (e.g. "6\ttrue" => ["6", "true"]), sets the cur_num to the first part of the array
		and finally appends the cur_num to the perfect_nums array if the second part of the
		array is == "true".

	Note:
		At some point in the future, this function needs to deal with signals or some way of letting
		the soon-to-be-added report() function signal this thread that the user wants to kill the
		processes. When dealing with the signals, will need a way to send a kill message to the
		client's compute process.
Added a bunch of stuff to manage AND compute.c

compute.c: now has the ability to get the timing information. Still needs to set up the sockets and send info.
Merge branch 'feature/manage' into develop