README

Tegu is a reservation manager which provides the ability to create and manage:
	- quality of service bandwidth reservations
	- flow steering reservations
	- wide area network stitching 

Tegu uses an underlying agent, also included in this repo, to directly manage the 
physical components (OVS or switches) as is needed to implement the reservations.
The underlying agent scripts are contained in the agent directory and the agent 
binary is in the main directory. 

The tegu src is divided into two packages and the main:
	agent	--	Directories containing various direct interfaces to things like
				OVS, Arista switches, floodlight (skoogie), mirroring, etc.

	managers -- functions that are driven as goroutines and thus implement
				major components of the application (reservation manager,
				fq manager, etc.).  

	gizmos	--  source files which implement objects, interfaces and the 
				functions that operate directly on them (link, host, switch, 
				pledge, etc.).

	main	--  Entry point functions (tegu and tegu_agent)
	
	package --	Scripts and metadata templates used to build a package files (.deb)

	system	--	Scripts used to start/stop/manage tegu in a q-lite environment.


Gizmos:
	globals.go		constants and a few globals shared by *.go in this directory
					This module also contains the initialisation function that 
					sets all globals up. 

	flight_if.go	floodlight interface providing methods that allow queries to the 
					controller for gathering link and host information. 

	fence.go		Implements a user limit fence mechanism.

	host.go			represents a single host in the network graph and in a path

	init.go			package level initialisation.

	light.go		functions that were implemented quickly to support tegu-lite. These
					probably should be moved to separate files, or likely into tools, but
					during the hasty implementation of -lite it was easier to keep them 
					bunched here. 

	link.go			represents a link between switches in the network graph and in a path

	mbox.go			middlebox representation for steering reserations.

	obligation.go	used to manage an obligation of something over time; references may time slices

	path.go			manages a path that has been created with a given amout of bandwith

	pledge.go		an interface representing a reservation tracked by resmgr. Implemented
					by pledge_* structs in the pledge_* files.
						pledge_bw.go
						pledge_mirror.go
						pledge_steer.go

	pledge_window.go Manages a time window for pledges and provides basic is_active, is_expired
					functions. 

	queue.go   		manages information needed to set individual queues for a reservation

	spq.go      	a very simple object which allows the return of queue information to a caller in 
					a single bundle (presently, just the struct, no functions exist).
	switch.go		represents a switch in the network graph

	time_slice.go	a single range of time for which a given amount of bandwith has been allocated

	tools.go		some generic tools but not generic enough to prompte to the forge packages

Managers:
	globals.go  	Globals needed by all manager functions and init function
	agent.go   		Manages sessions with agents
	http_api.go		provides the http "rest-ish" interface
	http_mirror_api.go  HTTP interface for mirroring
	network.go		manages the network graph
	net_req.go   	Network manager request struct and related functions
	res_mgr.go		provides the resevation management logic, suplemented by
					three support modules:
						res_mgr_bw.go	
						res_mgr_mirror.go
						res_mgr_steer.go

	osif.go			openstack interface manager.
	osif_proj.go	project specific openstack interface functions.

	fqmgr.go		flowmod/queue manager
	fq_req.go   	Fqmgr request structure and related functions
	fq_mgr_steer.go	Steering based fq-mgr support

	res_mgr_bw.go
	res_mgr_mirror.go
	res_mgr_steer.go

Testing
	tegu_test.go	run 'go -v test'  to run the tests


The tegu source depends on a set of Go packages that were developed along with Tegu, 
but are general enough to warrent their not being included here.  They are all a part
of the gopkgs/* package library.  To use them, clone the git project as described below. 
They will be referenced as needed during the build process (unlike C, there is no need
to build a library to link against). Now that tegu is in github, you should be able
to 'go get github/att/gopkgs'  to pull them down.

Go Environment:
The GOPATH variable must be set to the top level directory in your source 
tree. Within that directory there should be src, bin, and pkg directories. 
Under source there should be a github.com directory which will hold all of your 
Go related repos that are checked out of github.

For example:
	export GOPATH=$HOME/godev
	cd $GOPATH
	mkdir github.com
	cd github.com

	# fork a copy of the tegu and gopkgs first!!!

	# replace XXXXX with your user id, then clone your forks 
	git clone https://XXXXXX@github.com/scm/~XXXXXX/tegu.git
	git clone https://XXXXXX@github.com/scm/~XXXXXX/gopkgs.git

	cd tegu
	git checkout master			# ready to build in lite branch

Build tegu by:
	1) cd main
	2) go build tegu.go   		# generates tegu binary
	3) go build tegu_agent.go	# builds agent