testing rate limiting, making API changes

2018-01-31 22:28:45 -05:00
parent 6af49b317d
commit 8db9a43b0f
30 changed files with 2160 additions and 1514 deletions
--- a/engine/clientStructs.go
+++ b/engine/clientStructs.go
@@ -9,7 +9,7 @@ import (

 //All the message types are first, first the server handling messages from the client

-//Message contains the JSON messages from the client, we first unmarshal to get the messagetype, then each module un-marshalls the actual message once we know the type
+//Message contains the JSON messages from the client, we first unmarshal to get the messagetype, then pass it on to each module
 type Message struct {
 	MessageType        string
 	MessageDetail      string `json:",omitempty"`
--- a/engine/cronJobs.go
+++ b/engine/cronJobs.go
@@ -2,7 +2,6 @@ package engine

 import (
 	"io/ioutil"
-	"os"
 	"path/filepath"

 	"github.com/anacrolix/torrent"
@@ -32,18 +31,25 @@ func CheckTorrentWatchFolder(c *cron.Cron, db *storm.DB, tclient *torrent.Client
 		for _, file := range torrentFiles {
 			if filepath.Ext(file.Name()) != ".torrent" {
 				Logger.WithFields(logrus.Fields{"File": file.Name(), "error": err}).Error("Not a torrent file..")
+				continue
 			} else {
 				fullFilePath := filepath.Join(config.TorrentWatchFolder, file.Name())
-				clientTorrent, err := tclient.AddTorrentFromFile(fullFilePath)
+				fullFilePathAbs, err := filepath.Abs(fullFilePath)
+
+				fullNewFilePath := filepath.Join(config.TFileUploadFolder, file.Name())
+				fullNewFilePathAbs, err := filepath.Abs(fullNewFilePath)
+				Logger.WithFields(logrus.Fields{"Name": file.Name(), "FullFilePath": fullFilePathAbs, "newFullFilePath": fullNewFilePathAbs}).Info("Attempting to add the following file... and copy to")
+				CopyFile(fullFilePathAbs, fullNewFilePathAbs)
+				clientTorrent, err := tclient.AddTorrentFromFile(fullNewFilePathAbs)
 				if err != nil {
 					Logger.WithFields(logrus.Fields{"err": err, "Torrent": file.Name()}).Warn("Unable to add torrent to torrent client!")
-					break //break out of the loop entirely for this message since we hit an error
+					continue
 				}
-				fullNewFilePath := filepath.Join(config.TFileUploadFolder, file.Name())
-				StartTorrent(clientTorrent, torrentLocalStorage, db, config.TorrentConfig.DataDir, "file", file.Name(), config.DefaultMoveFolder, "default")
-				CopyFile(fullFilePath, fullNewFilePath)
-				os.Remove(fullFilePath) //delete the torrent after adding it and copying it over
-				Logger.WithFields(logrus.Fields{"Source Folder": config.TorrentWatchFolder, "Destination Folder": config.TFileUploadFolder, "Torrent": file.Name()}).Info("Added torrent from watch folder, and moved torrent file")
+
+				//os.Remove(fullFilePathAbs) //delete the torrent after adding it and copying it over
+				Logger.WithFields(logrus.Fields{"Source Folder": fullFilePathAbs, "Destination Folder": fullNewFilePathAbs, "Torrent": file.Name()}).Info("Added torrent from watch folder, and moved torrent file")
+				StartTorrent(clientTorrent, torrentLocalStorage, db, config.TorrentConfig.DataDir, "file", file.Name(), config.DefaultMoveFolder, "default", config.TFileUploadFolder)
+
 			}
 		}
 	})
@@ -78,7 +84,7 @@ func RefreshRSSCron(c *cron.Cron, db *storm.DB, tclient *torrent.Client, torrent
 					Logger.WithFields(logrus.Fields{"err": err, "Torrent": RSSTorrent.Title}).Warn("Unable to add torrent to torrent client!")
 					break //break out of the loop entirely for this message since we hit an error
 				}
-				StartTorrent(clientTorrent, torrentLocalStorage, db, config.TorrentConfig.DataDir, "magnet", "", config.DefaultMoveFolder, "RSS") //TODO let user specify torrent default storage location and let change on fly
+				StartTorrent(clientTorrent, torrentLocalStorage, db, config.TorrentConfig.DataDir, "magnet", "", config.DefaultMoveFolder, "RSS", config.TFileUploadFolder) //TODO let user specify torrent default storage location and let change on fly
 				singleFeed.Torrents = append(singleFeed.Torrents, singleRSSTorrent)

 			}
--- a/engine/doneTorrentActions.go
+++ b/engine/doneTorrentActions.go
@@ -1,6 +1,7 @@
 package engine

 import (
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -15,12 +16,32 @@ import (
 )

 //MoveAndLeaveSymlink takes the file from the default download dir and moves it to the user specified directory and then leaves a symlink behind.
-func MoveAndLeaveSymlink(config FullClientSettings, tHash string, db *storm.DB) {
+func MoveAndLeaveSymlink(config FullClientSettings, tHash string, db *storm.DB, moveDone bool, oldPath string) { //moveDone and oldPath are for moving a completed torrent
 	tStorage := Storage.FetchTorrentFromStorage(db, tHash)
-	Logger.WithFields(logrus.Fields{"Torrent Name": tStorage.TorrentFileName}).Info("Move and Create symlink started for torrent")
-	oldFilePath := filepath.Join(config.TorrentConfig.DataDir, tStorage.TorrentFileName)
-	newFilePath := filepath.Join(tStorage.StoragePath, tStorage.TorrentFileName)
-	_, err := os.Stat(tStorage.StoragePath)
+	Logger.WithFields(logrus.Fields{"Torrent Name": tStorage.TorrentName}).Info("Move and Create symlink started for torrent")
+	var oldFilePath string
+	if moveDone {
+		oldFilePathTemp := filepath.Join(oldPath, tStorage.TorrentName)
+		oldFilePath, err := filepath.Abs(oldFilePathTemp)
+		if err != nil {
+			Logger.WithFields(logrus.Fields{"Torrent Name": tStorage.TorrentName, "Filepath": oldFilePath}).Error("Cannot create absolute file path!")
+		}
+
+		fmt.Println("oldfilepath", oldFilePath)
+	} else {
+		oldFilePathTemp := filepath.Join(config.TorrentConfig.DataDir, tStorage.TorrentName)
+		oldFilePath, err := filepath.Abs(oldFilePathTemp)
+		if err != nil {
+			Logger.WithFields(logrus.Fields{"Torrent Name": tStorage.TorrentName, "Filepath": oldFilePath}).Error("Cannot create absolute file path!")
+		}
+	}
+
+	newFilePathTemp := filepath.Join(tStorage.StoragePath, tStorage.TorrentName)
+	newFilePath, err := filepath.Abs(newFilePathTemp)
+	if err != nil {
+		Logger.WithFields(logrus.Fields{"Torrent Name": tStorage.TorrentName, "Filepath": newFilePath}).Error("Cannot create absolute file path for new file path!")
+	}
+	_, err = os.Stat(tStorage.StoragePath)
 	if os.IsNotExist(err) {
 		err := os.MkdirAll(tStorage.StoragePath, 0755)
 		if err != nil {
@@ -29,7 +50,7 @@ func MoveAndLeaveSymlink(config FullClientSettings, tHash string, db *storm.DB)
 	}
 	oldFileInfo, err := os.Stat(oldFilePath)
 	if err != nil {
-		Logger.WithFields(logrus.Fields{"Old File info": oldFileInfo, "error": err}).Error("Cannot find the old file to copy/symlink!")
+		Logger.WithFields(logrus.Fields{"Old File info": oldFileInfo, "Old File Path": oldFilePath, "error": err}).Error("Cannot find the old file to copy/symlink!")
 		return
 	}

@@ -37,7 +58,18 @@ func MoveAndLeaveSymlink(config FullClientSettings, tHash string, db *storm.DB)
 		if runtime.GOOS == "windows" { //TODO the windows symlink is broken on windows 10 creator edition, so doing a copy for now until Go 1.11
 			if oldFileInfo.IsDir() {
 				os.Mkdir(newFilePath, 0755)
-				folderCopy.Copy(oldFilePath, newFilePath) //copy the folder to the new location
+				if moveDone {
+					err := folderCopy.Copy(config.TorrentConfig.DataDir, newFilePath)
+					if err != nil {
+						Logger.WithFields(logrus.Fields{"Old File Path": config.TorrentConfig.DataDir, "New File Path": newFilePath, "error": err}).Error("Error Copying Folder!")
+					}
+				} else {
+					err := folderCopy.Copy(oldFilePath, newFilePath) //copy the folder to the new location
+					if err != nil {
+						Logger.WithFields(logrus.Fields{"Old File Path": oldFilePath, "New File Path": newFilePath, "error": err}).Error("Error Copying Folder!")
+					}
+
+				}
 				os.Chmod(newFilePath, 0777)
 				notifyUser(tStorage, config, db)
 				return
@@ -67,13 +99,22 @@ func MoveAndLeaveSymlink(config FullClientSettings, tHash string, db *storm.DB)
 			Logger.WithFields(logrus.Fields{"Old File Path": oldFilePath, "New File Path": newFilePath, "bytesWritten": bytesWritten}).Info("Windows Torrent Copy Completed")
 			notifyUser(tStorage, config, db)
 		} else {
+
 			folderCopy.Copy(oldFilePath, newFilePath)
 			os.Chmod(newFilePath, 0777) //changing permissions on the new file to be permissive
 			os.RemoveAll(oldFilePath)
-			err := os.Symlink(newFilePath, oldFilePath) //For all other OS's create a symlink
-			if err != nil {
-				Logger.WithFields(logrus.Fields{"Old File Path": oldFilePath, "New File Path": newFilePath, "error": err}).Error("Error creating symlink")
-				return
+			if moveDone {
+				err := os.Symlink(newFilePath, config.TorrentConfig.DataDir)
+				if err != nil {
+					Logger.WithFields(logrus.Fields{"Old File Path": config.TorrentConfig.DataDir, "New File Path": newFilePath, "error": err}).Error("Error creating symlink")
+					return
+				}
+			} else {
+				err := os.Symlink(newFilePath, oldFilePath) //For all other OS's create a symlink
+				if err != nil {
+					Logger.WithFields(logrus.Fields{"Old File Path": oldFilePath, "New File Path": newFilePath, "error": err}).Error("Error creating symlink")
+					return
+				}
 			}
 			notifyUser(tStorage, config, db)
 			Logger.WithFields(logrus.Fields{"Old File Path": oldFilePath, "New File Path": newFilePath}).Info("Moving completed torrent")
@@ -83,20 +124,21 @@ func MoveAndLeaveSymlink(config FullClientSettings, tHash string, db *storm.DB)
 }

 func notifyUser(tStorage Storage.TorrentLocal, config FullClientSettings, db *storm.DB) {
-	Logger.WithFields(logrus.Fields{"New File Path": tStorage.StoragePath, "Torrent Name": tStorage.TorrentFileName}).Info("Attempting to notify user..")
+	Logger.WithFields(logrus.Fields{"New File Path": tStorage.StoragePath, "Torrent Name": tStorage.TorrentName}).Info("Attempting to notify user..")
 	tStorage.TorrentMoved = true
-	Storage.AddTorrentLocalStorage(db, tStorage) //Updating the fact that we moved the torrent
+	//Storage.AddTorrentLocalStorage(db, tStorage) //Updating the fact that we moved the torrent
+	Storage.UpdateStorageTick(db, tStorage)
 	if config.PushBulletToken != "" {
 		pb := pushbullet.New(config.PushBulletToken)
 		n := requests.NewNote()
-		n.Title = tStorage.TorrentFileName
+		n.Title = tStorage.TorrentName
 		n.Body = "Completed and moved to " + tStorage.StoragePath
 		if _, err := pb.PostPushesNote(n); err != nil {
-			Logger.WithFields(logrus.Fields{"Torrent": tStorage.TorrentFileName, "New File Path": tStorage.StoragePath, "error": err}).Error("Error pushing PushBullet Note")
+			Logger.WithFields(logrus.Fields{"Torrent": tStorage.TorrentName, "New File Path": tStorage.StoragePath, "error": err}).Error("Error pushing PushBullet Note")
 			return
 		}
-		Logger.WithFields(logrus.Fields{"Torrent": tStorage.TorrentFileName, "New File Path": tStorage.StoragePath}).Info("Pushbullet note sent")
+		Logger.WithFields(logrus.Fields{"Torrent": tStorage.TorrentName, "New File Path": tStorage.StoragePath}).Info("Pushbullet note sent")
 	} else {
-		Logger.WithFields(logrus.Fields{"New File Path": tStorage.StoragePath, "Torrent Name": tStorage.TorrentFileName}).Info("No pushbullet API key set, not notifying")
+		Logger.WithFields(logrus.Fields{"New File Path": tStorage.StoragePath, "Torrent Name": tStorage.TorrentName}).Info("No pushbullet API key set, not notifying")
 	}
 }
--- a/engine/engine.go
+++ b/engine/engine.go
@@ -96,15 +96,17 @@ func timeOutInfo(clientTorrent *torrent.Torrent, seconds time.Duration) (deleted

 }

-func readTorrentFileFromDB(element *Storage.TorrentLocal, tclient *torrent.Client, db *storm.DB) (singleTorrent *torrent.Torrent) {
+func readTorrentFileFromDB(element *Storage.TorrentLocal, tclient *torrent.Client, db *storm.DB) (singleTorrent *torrent.Torrent, err error) {
 	tempFile, err := ioutil.TempFile("", "TorrentFileTemp")
 	if err != nil {
 		Logger.WithFields(logrus.Fields{"tempfile": tempFile, "err": err}).Error("Unable to create tempfile")
+		return nil, err
 	}
 	//defer tempFile.Close() //Todo.. if we remove this do we need to close it?
 	defer os.Remove(tempFile.Name())
 	if _, err := tempFile.Write(element.TorrentFile); err != nil { //writing out out the entire file back into the temp dir from boltdb
 		Logger.WithFields(logrus.Fields{"tempfile": tempFile, "err": err}).Error("Unable to write to tempfile")
+		return nil, err
 	}
 	if err := tempFile.Close(); err != nil { //close the tempfile so that we can add it back into the torrent client
 		Logger.WithFields(logrus.Fields{"tempfile": tempFile, "err": err}).Error("Unable to close tempfile")
@@ -112,18 +114,21 @@ func readTorrentFileFromDB(element *Storage.TorrentLocal, tclient *torrent.Clien
 	_, err = os.Stat(element.TorrentFileName) //if we CAN find the torrent, add it
 	if err != nil {
 		Logger.WithFields(logrus.Fields{"tempfile": tempFile, "err": err}).Error("Unable to find file")
+		Storage.DelTorrentLocalStorage(db, element.Hash) //purge the torrent
+		return nil, err
 	}
 	singleTorrent, err = tclient.AddTorrentFromFile(element.TorrentFileName)
 	if err != nil {
 		Logger.WithFields(logrus.Fields{"tempfile": element.TorrentFileName, "err": err}).Error("Unable to add Torrent from file!")
 		CreateServerPushMessage(ServerPushMessage{MessageType: "serverPushMessage", MessageLevel: "error", Payload: "Unable to add Torrent from file!"}, Conn)
-
+		Storage.DelTorrentLocalStorage(db, element.Hash) //purge the torrent
+		return nil, err
 	}
-	return singleTorrent
+	return singleTorrent, nil
 }

 //StartTorrent creates the storage.db entry and starts A NEW TORRENT and adds to the running torrent array
-func StartTorrent(clientTorrent *torrent.Torrent, torrentLocalStorage Storage.TorrentLocal, torrentDbStorage *storm.DB, dataDir string, torrentType string, torrentFileName string, torrentStoragePath string, labelValue string) {
+func StartTorrent(clientTorrent *torrent.Torrent, torrentLocalStorage Storage.TorrentLocal, torrentDbStorage *storm.DB, dataDir, torrentType, torrentFileName, torrentStoragePath, labelValue, tFileUploadFolder string) {
 	timedOut := timeOutInfo(clientTorrent, 45) //seeing if adding the torrent times out (giving 45 seconds)
 	if timedOut {                              //if we fail to add the torrent return
 		return
@@ -143,11 +148,16 @@ func StartTorrent(clientTorrent *torrent.Torrent, torrentLocalStorage Storage.To
 	torrentLocalStorage.DateAdded = time.Now().Format("Jan _2 2006")
 	torrentLocalStorage.StoragePath = torrentStoragePath
 	torrentLocalStorage.TorrentName = clientTorrent.Name()
-	torrentLocalStorage.TorrentStatus = "Running" //by default start all the torrents as downloading.
-	torrentLocalStorage.TorrentType = torrentType //either "file" or "magnet" maybe more in the future
-	if torrentType == "file" {                    //if it is a file read the entire file into the database for us to spit out later
-		torrentLocalStorage.TorrentFileName = torrentFileName
-		torrentfile, err := ioutil.ReadFile(torrentFileName)
+	torrentLocalStorage.TorrentUploadLimit = true            //by default all of the torrents will stop uploading after the global rate is set.
+	torrentLocalStorage.TorrentMoved = false                 //by default the torrent has no been moved.
+	torrentLocalStorage.TorrentStatus = "Running"            //by default start all the torrents as downloading.
+	torrentLocalStorage.TorrentType = torrentType            //either "file" or "magnet" maybe more in the future
+	torrentLocalStorage.TorrentSize = clientTorrent.Length() //Length will change as we cancel files so store it in DB
+	if torrentType == "file" {                               //if it is a file read the entire file into the database for us to spit out later
+		torrentFilePath := filepath.Join(tFileUploadFolder, torrentFileName)
+		torrentFilePathAbs, err := filepath.Abs(torrentFilePath)
+		torrentfile, err := ioutil.ReadFile(torrentFilePathAbs)
+		torrentLocalStorage.TorrentFileName = torrentFilePathAbs
 		if err != nil {
 			Logger.WithFields(logrus.Fields{"torrentFile": torrentfile, "error": err}).Error("Unable to read the torrent file")
 		}
@@ -182,7 +192,11 @@ func CreateRunningTorrentArray(tclient *torrent.Client, TorrentLocalArray []*Sto
 		//singleTorrentStorageInfo := Storage.FetchTorrentFromStorage(db, TempHash.String())  //pulling the single torrent info from storage ()

 		if singleTorrentFromStorage.TorrentType == "file" { //if it is a file pull it from the uploaded torrent folder
-			singleTorrent = readTorrentFileFromDB(singleTorrentFromStorage, tclient, db)
+			var err error
+			singleTorrent, err = readTorrentFileFromDB(singleTorrentFromStorage, tclient, db)
+			if err != nil {
+				continue
+			}
 			fullClientDB.SourceType = "Torrent File"
 		} else {
 			singleTorrentFromStorageMagnet := "magnet:?xt=urn:btih:" + singleTorrentFromStorage.Hash //For magnet links just need to prepend the magnet part to the hash to readd
@@ -204,26 +218,22 @@ func CreateRunningTorrentArray(tclient *torrent.Client, TorrentLocalArray []*Sto
 		}
 		//Logger.WithFields(logrus.Fields{"singleTorrent": singleTorrentFromStorage.TorrentName}).Info("Generating infohash")
 		TempHash = singleTorrent.InfoHash()
-
-		if (singleTorrent.BytesCompleted() == singleTorrent.Length()) && (singleTorrentFromStorage.TorrentMoved == false) { //if we are done downloading and haven't moved torrent yet
-			MoveAndLeaveSymlink(config, singleTorrent.InfoHash().String(), db) //can take some time to move file so running this in another thread TODO make this a goroutine and skip this block if the routine is still running
+		if (singleTorrent.BytesCompleted() == singleTorrentFromStorage.TorrentSize) && (singleTorrentFromStorage.TorrentMoved == false) { //if we are done downloading and haven't moved torrent yet
+			Logger.WithFields(logrus.Fields{"singleTorrent": singleTorrentFromStorage.TorrentName}).Info("Torrent Completed, moving...")
+			MoveAndLeaveSymlink(config, singleTorrent.InfoHash().String(), db, false, "") //can take some time to move file so running this in another thread TODO make this a goroutine and skip this block if the routine is still running
 		}

 		fullStruct := singleTorrent.Stats()

 		activePeersString := strconv.Itoa(fullStruct.ActivePeers) //converting to strings
 		totalPeersString := fmt.Sprintf("%v", fullStruct.TotalPeers)
-		//fetching all the info from the database
-
-		fullClientDB.StoragePath = singleTorrentFromStorage.StoragePath //grabbed from database
-
+		fullClientDB.StoragePath = singleTorrentFromStorage.StoragePath
 		downloadedSizeHumanized := HumanizeBytes(float32(singleTorrent.BytesCompleted())) //convert size to GB if needed
-		totalSizeHumanized := HumanizeBytes(float32(singleTorrent.Length()))
-		//Logger.WithFields(logrus.Fields{"singleTorrent": singleTorrentFromStorage.TorrentName}).Info("Generated infohash")
-		//grabbed from torrent client
+
+		totalSizeHumanized := HumanizeBytes(float32(singleTorrentFromStorage.TorrentSize))
 		fullClientDB.DownloadedSize = downloadedSizeHumanized
 		fullClientDB.Size = totalSizeHumanized
-		PercentDone := fmt.Sprintf("%.2f", float32(singleTorrent.BytesCompleted())/float32(singleTorrent.Length()))
+		PercentDone := fmt.Sprintf("%.2f", float32(singleTorrent.BytesCompleted())/float32(singleTorrentFromStorage.TorrentSize))
 		fullClientDB.TorrentHash = TempHash
 		fullClientDB.PercentDone = PercentDone
 		fullClientDB.DataBytesRead = fullStruct.ConnStats.DataBytesRead       //used for calculations not passed to client calculating up/down speed
@@ -237,8 +247,7 @@ func CreateRunningTorrentArray(tclient *torrent.Client, TorrentLocalArray []*Sto
 		fullClientDB.BytesCompleted = singleTorrent.BytesCompleted()
 		fullClientDB.NumberofFiles = len(singleTorrent.Files())

-		//ranging over the previous torrent array to calculate the speed for each torrent
-		if len(PreviousTorrentArray) > 0 { //if we actually have  a previous array
+		if len(PreviousTorrentArray) > 0 { //if we actually have  a previous array //ranging over the previous torrent array to calculate the speed for each torrent
 			for _, previousElement := range PreviousTorrentArray {
 				TempHash := singleTorrent.InfoHash()
 				if previousElement.TorrentHashString == TempHash.String() { //matching previous to new
@@ -247,7 +256,7 @@ func CreateRunningTorrentArray(tclient *torrent.Client, TorrentLocalArray []*Sto
 				}
 			}
 		}
-		CalculateTorrentETA(singleTorrent, fullClientDB) //needs to be here since we need the speed calculated before we can estimate the eta.
+		CalculateTorrentETA(singleTorrentFromStorage.TorrentSize, singleTorrent.BytesCompleted(), fullClientDB) //needs to be here since we need the speed calculated before we can estimate the eta.

 		fullClientDB.TotalUploadedSize = HumanizeBytes(float32(fullClientDB.TotalUploadedBytes))
 		fullClientDB.UploadRatio = CalculateUploadRatio(singleTorrent, fullClientDB) //calculate the upload ratio
@@ -345,19 +354,3 @@ func CreateTorrentDetailJSON(tclient *torrent.Client, selectedHash string, torre
 	}
 	return TorrentDetailStruct
 }
-
-func ChangeStorageLocation(newStorageLocation string, torrentHashes []string, db *storm.DB) {
-
-	for _, torrentHash := range torrentHashes {
-		var selectedTorrent Storage.TorrentLocal
-		err := db.Find("TorrentLocal", torrentHash, &selectedTorrent)
-		if err != nil {
-			Logger.WithFields(logrus.Fields{"torrentHash": torrentHash}).Error("Unable to find torrent in db to update!")
-			CreateServerPushMessage(ServerPushMessage{MessageType: "serverPushMessage", MessageLevel: "error", Payload: "Failed to change Storage Location"}, Conn)
-		}
-		fmt.Printf("%+v\n", selectedTorrent)
-		db.UpdateField(&selectedTorrent{Hash: torrentHash}, "StoragePath", newStorageLocation)
-
-	}
-
-}
--- a/engine/engineHelpers.go
+++ b/engine/engineHelpers.go
@@ -8,6 +8,7 @@ import (

 	"github.com/anacrolix/torrent"
 	"github.com/deranjer/goTorrent/storage"
+	Storage "github.com/deranjer/goTorrent/storage"
 	"github.com/sirupsen/logrus"
 )

@@ -45,7 +46,7 @@ func CopyFile(srcFile string, destFile string) {
 	if err != nil {
 		Logger.WithFields(logrus.Fields{"File": srcFile, "Error": err}).Error("Cannot open source file")
 	}
-	outfileContents, err := os.Open(destFile)
+	outfileContents, err := os.Create(destFile)
 	defer outfileContents.Close()
 	if err != nil {
 		Logger.WithFields(logrus.Fields{"File": destFile, "Error": err}).Error("Cannot open destination file")
@@ -82,9 +83,14 @@ func CalculateTorrentSpeed(t *torrent.Torrent, c *ClientDB, oc ClientDB) {
 	c.UpdatedAt = now
 }

+//CalculateDownloadSize will calculate the download size once file priorities are sorted out
+func CalculateDownloadSize(tFromStorage *Storage.TorrentLocal) {
+
+}
+
 //CalculateTorrentETA is used to estimate the remaining dl time of the torrent based on the speed that the MB are being downloaded
-func CalculateTorrentETA(t *torrent.Torrent, c *ClientDB) {
-	missingBytes := t.Length() - t.BytesCompleted()
+func CalculateTorrentETA(tSize int64, tBytesCompleted int64, c *ClientDB) {
+	missingBytes := tSize - tBytesCompleted
 	missingMB := missingBytes / 1024 / 1024
 	if missingMB == 0 {
 		c.ETA = "Done"
@@ -108,8 +114,8 @@ func CalculateUploadRatio(t *torrent.Torrent, c *ClientDB) string {
 }

 //CalculateTorrentStatus is used to determine what the STATUS column of the frontend will display ll2
-func CalculateTorrentStatus(t *torrent.Torrent, c *ClientDB, config FullClientSettings, tFromStorage *storage.TorrentLocal) { //TODO redo all of this to allow for stopped torrents
-	if (tFromStorage.TorrentStatus == "Stopped") || (float64(c.TotalUploadedBytes)/float64(t.BytesCompleted()) >= config.SeedRatioStop) {
+func CalculateTorrentStatus(t *torrent.Torrent, c *ClientDB, config FullClientSettings, tFromStorage *storage.TorrentLocal) {
+	if (tFromStorage.TorrentStatus == "Stopped") || (float64(c.TotalUploadedBytes)/float64(t.BytesCompleted()) >= config.SeedRatioStop && tFromStorage.TorrentUploadLimit == true) { //If storage shows torrent stopped or if it is over the seeding ratio AND is under the global limit
 		c.Status = "Stopped"
 		c.MaxConnections = 0
 		t.SetMaxEstablishedConns(0)
--- a/engine/settings.go
+++ b/engine/settings.go
@@ -4,11 +4,12 @@ import (
 	"fmt"
 	"path/filepath"

+	"golang.org/x/time/rate"
+
 	"github.com/anacrolix/dht"
 	"github.com/anacrolix/torrent"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
-	"golang.org/x/time/rate"
 )

 //FullClientSettings contains all of the settings for our entire application
@@ -49,6 +50,42 @@ func dhtServerSettings(dhtConfig dht.ServerConfig) dht.ServerConfig {
 	return dhtConfig
 }

+func calculateRateLimiters(uploadRate, downloadRate string) (*rate.Limiter, *rate.Limiter) { //TODO reorg
+	var uploadRateLimiterSize int
+	var downloadRateLimiterSize int
+
+	switch uploadRate {
+	case "Low":
+		uploadRateLimiterSize = 50000
+	case "Medium":
+		uploadRateLimiterSize = 500000
+	case "High":
+		uploadRateLimiterSize = 1500000
+	default:
+		downloadRateLimiter := rate.NewLimiter(rate.Inf, 0)
+		uploadRateLimiter := rate.NewLimiter(rate.Inf, 0)
+		return downloadRateLimiter, uploadRateLimiter
+	}
+
+	switch downloadRate {
+	case "Low":
+		downloadRateLimiterSize = 50000
+	case "Medium":
+		downloadRateLimiterSize = 500000
+	case "High":
+		downloadRateLimiterSize = 1500000
+	default:
+		downloadRateLimiter := rate.NewLimiter(rate.Inf, 0)
+		uploadRateLimiter := rate.NewLimiter(rate.Inf, 0)
+		return downloadRateLimiter, uploadRateLimiter
+	}
+	var limitPerSecondUl = rate.Limit(uploadRateLimiterSize)
+	uploadRateLimiter := rate.NewLimiter(limitPerSecondUl, uploadRateLimiterSize)
+	var limitPerSecondDl = rate.Limit(uploadRateLimiterSize)
+	downloadRateLimiter := rate.NewLimiter(limitPerSecondDl, downloadRateLimiterSize)
+	return downloadRateLimiter, uploadRateLimiter
+}
+
 //FullClientSettingsNew creates a new set of setting from config.toml
 func FullClientSettingsNew() FullClientSettings {
 	viper.SetConfigName("config")
@@ -84,6 +121,12 @@ func FullClientSettingsNew() FullClientSettings {
 		fmt.Println("Failed creating absolute path for dataDir", err)
 	}

+	var uploadRateLimiter *rate.Limiter
+	var downloadRateLimiter *rate.Limiter
+	uploadRate := viper.GetString("serverConfig.UploadRateLimit")
+	downloadRate := viper.GetString("serverConfig.DownloadRateLimit")
+	downloadRateLimiter, uploadRateLimiter = calculateRateLimiters(uploadRate, downloadRate)
+
 	listenAddr := viper.GetString("torrentClientConfig.ListenAddr")
 	disablePex := viper.GetBool("torrentClientConfig.DisablePEX")
 	noDHT := viper.GetBool("torrentClientConfig.NoDHT")
@@ -124,12 +167,6 @@ func FullClientSettingsNew() FullClientSettings {
 		dhtServerConfig = dhtServerSettings(dhtServerConfig)
 	}

-	uploadRateLimiter := new(rate.Limiter)
-	viper.UnmarshalKey("UploadRateLimiter", &uploadRateLimiter)
-
-	downloadRateLimiter := new(rate.Limiter)
-	viper.UnmarshalKey("DownloadRateLimiter", &downloadRateLimiter)
-
 	encryptionPolicy := torrent.EncryptionPolicy{
 		DisableEncryption:  viper.GetBool("EncryptionPolicy.DisableEncryption"),
 		ForceEncryption:    viper.GetBool("EncryptionPolicy.ForceEncryption"),
@@ -137,21 +174,21 @@ func FullClientSettingsNew() FullClientSettings {
 	}

 	tConfig := torrent.Config{
-		DataDir:    dataDirAbs,
-		ListenAddr: listenAddr,
-		DisablePEX: disablePex,
-		NoDHT:      noDHT,
-		DHTConfig:  dhtServerConfig,
-		NoUpload:   noUpload,
-		Seed:       seed,
-		//UploadRateLimiter:   uploadRateLimiter,
-		//DownloadRateLimiter: downloadRateLimiter,
-		PeerID:           peerID,
-		DisableUTP:       disableUTP,
-		DisableTCP:       disableTCP,
-		DisableIPv6:      disableIPv6,
-		Debug:            debug,
-		EncryptionPolicy: encryptionPolicy,
+		DataDir:             dataDirAbs,
+		ListenAddr:          listenAddr,
+		DisablePEX:          disablePex,
+		NoDHT:               noDHT,
+		DHTConfig:           dhtServerConfig,
+		NoUpload:            noUpload,
+		Seed:                seed,
+		UploadRateLimiter:   uploadRateLimiter,
+		DownloadRateLimiter: downloadRateLimiter,
+		PeerID:              peerID,
+		DisableUTP:          disableUTP,
+		DisableTCP:          disableTCP,
+		DisableIPv6:         disableIPv6,
+		Debug:               debug,
+		EncryptionPolicy:    encryptionPolicy,
 	}

 	Config := FullClientSettings{