Merge branch 'master' of https://github.com/deranjer/goTorrent

Updating roadmap..

.gitignore

@@ -1,17 +1,26 @@
 downloads/
+downloading/
+downloaded/
+uploadedTorrents/
 storage.db.lock
 storage.db
+storage.db.old
 .torrent.bolt.db.lock
 .torrent.bolt.db
 .idea/torrent-project.iml
 .idea/modules.xml
 .idea/misc.xml
 output.json
-configtest.toml
 .idea/workspace.xml
 .idea/vcs.xml
-1905POD014.mp3.torrent
-bolter.exe
-mythbuntu-16.04.3-desktop-i386.iso.torrent
-ubuntu-17.04-desktop-amd64.iso (1).torrent
-ubuntu.torrent
+*.torrent
+boltbrowser.win64.exe
+logs/server.log
+.goreleaser.yml
+config.toml.backup
+config.1.toml
+config.toml.old
+/public/static/js/kickwebsocket.js.backup
+/public/static/js/kickwebsocket-generated.js
+clientAuth.txt
+dist

.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+    "git.ignoreLimitWarning": true,
+    "cSpell.words": [
+        "anacrolix",
+        "asdine",
+        "btih",
+        "gofeed",
+        "logrus",
+        "mmcdole",
+        "otiai"
+    ]
+}

.vscode/tasks.json

@@ -1,7 +1,7 @@
 {
     // See https://go.microsoft.com/fwlink/?LinkId=733558
     // for the documentation about the tasks.json format
-    "version": "2.0.0",
+    "version": "2.0.0", 
     "tasks": [
         {
             "taskName": "Run Program",
@@ -12,9 +12,9 @@
             ]
         },
         {
-            "taskName": "Build GopherJS",
+            "taskName": "goReleaser Snapshot",
             "type": "shell",
-            "command": "C:/Users/deranjer/go/bin/gopherjs.exe build C:/Users/deranjer/GoglandProjects/torrent-project/public/static/js/frontend-websocket.go",
+            "command": "C:/Users/deranjer/go/bin/goreleaser.exe -rm-dist -snapshot",
             "problemMatcher": [
                 "$go"
             ]

README.md

@@ -1,3 +1,93 @@
 # goTorrent
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/goTorrent-project/Lobby)  [![Go Report Card](https://goreportcard.com/badge/github.com/deranjer/goTorrent)](https://goreportcard.com/report/github.com/deranjer/goTorrent)
+
+goTorrent is a torrenting server built with Go (Golang) with websocket API that comes with a React web frontend.
+
+The current release is an alpha release which means there may be bugs, please open issues to help me improve this software!
+
+Image of the frontend UI
+
+![alt text](/documentation/images/frontend.png "Frontend UI")
+
+## Supported Platforms:
+- Windows
+- Linux
+- MacOS - (untested as I do not have a Mac)
+
+### Supported Arch:
+- x64
+
+## Features:
+ - Responsive React based WebUI
+ - Download torrents from File upload or Magnet Link
+ - Start/Stop/Delete Multiple Torrents
+ - Add RSS feeds and automatically download new torrents from feed
+ - Detailed information for each torrent
+ - Automatic stop after seeding ratio reached
+ - Pushbullet notification on torrent complete
+ - Automatic move of completed torrent to new directory (leave symlink behind for seeding)
+   - Symlinks don't work on Windows yet, have to copy file for now
+ 
+## Roadmap
+- Early-Mid 2018
+
+ - [X] Ability to modify storage path of torrent after it has been added
+
+ - [X] Backend to frontend notification messages
+
+ - [X] Global Rate Limiting for Upload/Download Speed
+
+ - [X] Add torrents from watch folder (cron job every 5 minutes)
+  
+ - [X] Authentication from client to server (done via JWT, will add functionality for 3rd party clients later)
+
+ - [X] Reverse Proxy Support with SSL upgrade added (with provided config for nginx)
+
+ - [X] Mostly generated client config from toml.config on first run
+
+ - [X] Ability to view TOML settings from WebUI (and perhaps change a few as well)
+ 
+ - [X] Ability to set priority for individual files (needs more testing!)
+
+ - [ ] Unit testing completed for a large portion of the package
+ 
+ - [ ] Stability/bug fixing/Optimization rewrite of some of the core structures of the WebUI and base server
+ 
+ - [ ] Put the "Move torrent after download" into own goroutine with checks so the WebUI doesn't freeze when moving torrent
+ 
+ 
+ 
+- Late 2018
+
+ - [X] Define the websocket API for users to write their own clients/extensions
+ 
+ - [ ] React-native Android app (I don't own any Mac products so there will be no iPhone version)
+
+# Documentation
+
+All the documentation is available [here](https://deranjer.github.io/)
+
+
+# Special Thanks
+I viewed cloud-torrent source to construct my project:
+
+[Cloud-Torent:Cloud torrent is a a self-hosted remote torrent client, written in Go (golang)](https://github.com/jpillora/cloud-torrent)
+
+[Anacrolix BitTorrent client package and utilities](https://github.com/anacrolix/torrent)
+
+[goreleaser: Deliver Go binaries as fast and easily as possible](https://github.com/goreleaser/goreleaser)
+
+[Viper: Go configuration with fangs](https://github.com/spf13/viper)
+
+[logrus: Structured, pluggable logging for Go.](https://github.com/sirupsen/logrus)
+
+[boltdb: An embedded key/value database for Go.](https://github.com/boltdb/bolt)
+
+[storm: Simple and powerful toolkit for BoltDB](https://github.com/asdine/storm)
+
+[Gorilla: web toolkit for the Go programming language](http://www.gorillatoolkit.org/)
+
+[gofeed: Parse RSS and Atom feeds in Go](https://github.com/mmcdole/gofeed)
+
+[pushbullet-go: A library to call Pushbullet HTTP API for Golang](https://github.com/mitsuse/pushbullet-go)
 
-Torrent server with web client written in Go and React

client.go

@@ -1,46 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/anacrolix/torrent"
-	"time"
-)
-
-// ClientError formats errors coming from the client.
-type ClientError struct {
-	Type   string
-	Origin error
-}
-
-func (clientError ClientError) Error() string {
-	return fmt.Sprintf("Error %s: %s\n", clientError.Type, clientError.Origin)
-}
-
-type ClientConfig struct {
-	TorrentPath    string
-	Port           int
-	TorrentPort    int
-	Seed           bool
-	TCP            bool
-	MaxConnections int
-	DownloadDir    string
-}
-
-
-type Client struct {
-	Client        *torrent.Client
-	Torrent       *torrent.Torrent
-	Name          string
-	Progress      int64
-	Status        string
-	Seeds         int
-	Peers         int
-	DownloadSpeed int64
-	UploadSpeed   int64
-	ETA           time.Duration
-	Ratio         int
-	Avail         int
-	Config        ClientConfig
-}
-
-

config.toml

@@ -1,59 +1,122 @@
+[serverConfig]
+
+    ServerPort = ":8000" #leave format as is it expects a string with colon
+    ServerAddr = "192.168.1.100" #Put in the IP address you want to bind to
+    LogLevel = "Info" # Options = Debug, Info, Warn, Error, Fatal, Panic
+    LogOutput = "stdout" #Options = file, stdout #file will print it to logs/server.log
+
+    SeedRatioStop = 1.50 #automatically stops the torrent after it reaches this seeding ratio
+
+    #Relative or absolute path accepted, the server will convert any relative path to an absolute path.
+    DefaultMoveFolder = 'downloads' #default path that a finished torrent is symlinked to after completion. Torrents added via RSS will default here
+    TorrentWatchFolder = 'torrentUpload' #folder path that is watched for .torrent files and adds them automatically every 5 minutes
+    
+    #Limits your upload and download speed globally, all are averages and not burst protected (usually burst on start).
+    #Low = ~.05MB/s, Medium = ~.5MB/s, High = ~1.5MB/s
+    UploadRateLimit = "Unlimited"  #Options are "Low", "Medium", "High", "Unlimited" #Unlimited is default
+    DownloadRateLimit = "Unlimited"
+
+[goTorrentWebUI]
+    #Basic goTorrentWebUI authentication (not terribly secure, implemented in JS, password is hashed to SHA256, not salted, basically don't depend on this if you require very good security)
+    WebUIAuth = false # bool, if false no authentication is required for the webUI
+    WebUIUser = "admin"
+    WebUIPassword = "Password1"
+
+
+[notifications]
+
+    PushBulletToken = "" #add your pushbullet api token here to notify of torrent completion to pushbullet
+
+[reverseProxy]
+    #This is for setting up goTorrent behind a reverse Proxy (with SSL, reverse proxy with no SSL will require editing the WSS connection to a WS connection manually)
+    ProxyEnabled = false #bool, either false or true
+    #URL is CASE SENSITIVE
+    BaseURL = "domain.com/subroute/"  # MUST be in the format (if you have a subdomain, and must have trailing slash) "yoursubdomain.domain.org/subroute/"
+
+[EncryptionPolicy]
+
+    DisableEncryption = false
+    ForceEncryption = false
+    PreferNoEncryption = true
+
 [torrentClientConfig]
-DataDir = "downloads"    #the full OR relative path of the default download directory for torrents
-#The address to listen for new uTP and TCP bittorrent protocolconnections. DHT shares a UDP socket with uTP unless configured otherwise.
-ListenAddr = "" #Leave Blank for default, syntax "HOST:PORT"
-#Don't announce to trackers. This only leaves DHT to discover peers.
-DisableTrackers = false  #boolean
-DisablePEX = false # boolean
-# Don't create a DHT.
-NoDHT = false #boolean
-# Overrides the default DHT configuration, see dhtServerConfig
-DHTConfig = false # boolean, set to true and edit dhtServerConfig table to utilize
-# Never send chunks to peers.
-NoUpload = false #boolean
-#seed after download
-Seed = true #boolean
-# Events are data bytes sent in pieces. The burst must be large enough to fit a whole chunk.
-UploadRateLimiter = "" #*rate.Limiter
-#The events are bytes read from connections. The burst must be biggerthan the largest Read performed on a Conn minus one. This is likely to
-#be the larger of the main read loop buffer (~4096), and the requested chunk size (~16KiB).
-DownloadRateLimiter = "" #*rate.Limiter
-#User-provided Client peer ID. If not present, one is generated automatically.
-PeerID = "" #string
-#For the bittorrent protocol.
-DisableUTP = false #bool
-#For the bittorrent protocol.
-DisableTCP = false #bool
-#Called to instantiate storage for each added torrent. Builtin backends
-# are in the storage package. If not set, the "file" implementation is used.
-DefaultStorage = dht.ServerConfig #storage.ClientImpl
+    DownloadDir = 'downloading'    #the full OR relative path where the torrent server stores in-progress torrents
 
-#encryption policy
-IPBlocklist = "" #iplist.Ranger
-DisableIPv6 = false #boolean
-Debug = false #boolean
+    Seed = true #boolean #seed after download
+    
+    # Never send chunks to peers.
+    NoUpload = false #boolean
 
+    #User-provided Client peer ID. If not present, one is generated automatically.
+    PeerID = "" #string
+
+    #The address to listen for new uTP and TCP bittorrent protocol connections. DHT shares a UDP socket with uTP unless configured otherwise.
+    ListenAddr = "" #Leave Blank for default, syntax "HOST:PORT"
+
+    #Don't announce to trackers. This only leaves DHT to discover peers.
+    DisableTrackers = false  #boolean
+
+    DisablePEX = false # boolean
+
+    # Don't create a DHT.
+    NoDHT = false #boolean
+
+    #For the bittorrent protocol.
+    DisableUTP = false #bool
+
+    #For the bittorrent protocol.
+    DisableTCP = false #bool
+
+    #Called to instantiate storage for each added torrent. Builtin backends
+    # are in the storage package. If not set, the "file" implementation is used.
+    DefaultStorage = "storage.ClientImpl"
+
+    #encryption policy
+    IPBlocklist = "" #of type iplist.Ranger
+
+    DisableIPv6 = false #boolean
+
+    Debug = false #boolean
+
+    #HTTP *http.Client
+
+    HTTPUserAgent = "" # HTTPUserAgent changes default UserAgent for HTTP requests
+
+    ExtendedHandshakeClientVersion = "" 
+
+    Bep20 = ""
+
+    # Overrides the default DHT configuration, see dhtServerConfig  #advanced.. so be careful
+    DHTConfig = "" # default is "dht.ServerConfig"
 
 [dhtServerConfig]
-# Set NodeId Manually. Caller must ensure that if NodeId does not conform to DHT Security Extensions, that NoSecurity is also set.
-NodeId = "" #[20]byte
-Conn = "" # https://godoc.org/net#PacketConn #not implemented
-# Don't respond to queries from other nodes.
-Passive = false # boolean
-# the default addressses are "router.utorrent.com:6881","router.bittorrent.com:6881","dht.transmissionbt.com:6881","dht.aelitis.com:6881",
-#https://github.com/anacrolix/dht/blob/master/dht.go
-StartingNodes = "dht.GlobalBootstrapAddrs"
-#Disable the DHT security extension: http://www.libtorrent.org/dht_sec.html.
-NoSecurity = false
-#Initial IP blocklist to use. Applied before serving and bootstrapping begins.
-IPBlocklist = "" #iplist.Ranger
-#Used to secure the server's ID. Defaults to the Conn's LocalAddr(). Set to the IP that remote nodes will see,
-#as that IP is what they'll use to validate our ID.
-PublicIP = "" #net.IP
+    # Set NodeId Manually. Caller must ensure that if NodeId does not conform to DHT Security Extensions, that NoSecurity is also set.
+    NodeId = "" #[20]byte
 
-#Hook received queries. Return true if you don't want to propagate to the default handlers.
-OnQuery = "func(query *krpc.Msg, source net.Addr) (propagate bool)"
-#Called when a peer successfully announces to us.
-OnAnnouncePeer = "func(infoHash metainfo.Hash, peer Peer)"
-#How long to wait before resending queries that haven't received a response. Defaults to a random value between 4.5 and 5.5s.
-QueryResendDelay = "func() time.Duration"
+    Conn = "" # https:#godoc.org/net#PacketConn #not implemented
+
+    # Don't respond to queries from other nodes.
+    Passive = false # boolean
+
+    # the default addresses are "router.utorrent.com:6881","router.bittorrent.com:6881","dht.transmissionbt.com:6881","dht.aelitis.com:6881",
+    #https:#github.com/anacrolix/dht/blob/master/dht.go
+    StartingNodes = "dht.GlobalBootstrapAddrs"
+
+    #Disable the DHT security extension: http:#www.libtorrent.org/dht_sec.html.
+    NoSecurity = false
+
+    #Initial IP blocklist to use. Applied before serving and bootstrapping begins.
+    IPBlocklist = "" #of type iplist.Ranger
+
+    #Used to secure the server's ID. Defaults to the Conn's LocalAddr(). Set to the IP that remote nodes will see,
+    #as that IP is what they'll use to validate our ID.
+    PublicIP = "" #net.IP
+
+    #Hook received queries. Return true if you don't want to propagate to the default handlers.
+    OnQuery = "func(query *krpc.Msg, source net.Addr) (propagate bool)"
+
+    #Called when a peer successfully announces to us.
+    OnAnnouncePeer = "func(infoHash metainfo.Hash, peer Peer)"
+
+    #How long to wait before re-sending queries that haven't received a response. Defaults to a random value between 4.5 and 5.5s.
+    QueryResendDelay = "func() time.Duration"

dist-specific-files/Linux-systemd/goTorrent.service

@@ -0,0 +1,13 @@
+[Unit]
+Description=goTorrent Server
+After=network.target
+
+[Service]
+type=simple
+User=goTorrent
+WorkingDirectory=/opt/goTorrent
+ExecStart=/opt/goTorrent/goTorrent
+Restart=on-abort
+
+[Install]
+WantedBy=multi-user.target

dist-specific-files/ReverseProxy/nginx.conf

@@ -0,0 +1,12 @@
+location ^~ /gotorrent/ {
+    proxy_pass http://192.168.1.100:8000/;
+    proxy_redirect http:// https://;
+    proxy_pass_header Server;
+    proxy_set_header Host $http_host;
+    proxy_set_header X-Real-IP $http_address;
+    proxy_set_header X-Scheme $scheme;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection "Upgrade";
+
+}

engine/clientStructs.go

@@ -0,0 +1,122 @@
+package engine
+
+import (
+	"time"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+	Settings "github.com/deranjer/goTorrent/settings"
+	Storage "github.com/deranjer/goTorrent/storage"
+)
+
+//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 pass it on to each module
+type Message struct {
+	MessageType string
+	Payload     interface{}
+}
+
+//Next are the messages the server sends to the client
+
+//AuthResponse is sent when the client fails to perform authentication correctly
+type AuthResponse struct {
+	MessageType string
+	Payload     string
+}
+
+//ServerPushMessage is information (usually logs and status messages) that the server pushes to the client
+type ServerPushMessage struct {
+	MessageType  string
+	MessageLevel string //can be "success", "error", "warn", "info"
+	Payload      string //the actual message
+}
+
+//RSSJSONList is a slice of gofeed.Feeds sent to the client
+type RSSJSONList struct {
+	MessageType   string
+	TotalRSSFeeds int
+	RSSFeeds      []RSSFeedsNames //strings of the full rss feed
+}
+
+//RSSFeedsNames stores all of the feeds by name and with URL
+type RSSFeedsNames struct {
+	RSSName    string
+	RSSFeedURL string
+}
+
+//SingleRSSFeedMessage contains the torrents/name/etc of a single torrent feed
+type SingleRSSFeedMessage struct { //TODO had issues with getting this to work with Storage or Engine
+	MessageType   string
+	URL           string //the URL of the individual RSS feed
+	Name          string
+	TotalTorrents int
+	Torrents      []Storage.SingleRSSTorrent //name of the torrents
+}
+
+//TorrentList struct contains the torrent list that is sent to the client
+type TorrentList struct { //helps create the JSON structure that react expects to receive
+	MessageType    string     `json:"MessageType"`
+	Totaltorrents  int        `json:"total"`
+	ClientDBstruct []ClientDB `json:"data"`
+}
+
+//TorrentFileList supplies a list of files attached to a single torrent along with some additional information
+type TorrentFileList struct {
+	MessageType string
+	TotalFiles  int           `json:"TotalFiles"`
+	FileList    []TorrentFile `json:"FileList"`
+}
+
+//PeerFileList returns a slice of peers
+type PeerFileList struct {
+	MessageType string
+	TotalPeers  int
+	PeerList    []torrent.Peer
+}
+
+//TorrentFile describes a single file that a torrent client is downloading for a single torrent
+type TorrentFile struct {
+	TorrentHashString string //Used to tie the file to a torrent //TODO not sure if needed
+	FileName          string //The name of the file
+	FilePath          string //The relative filepath to the file
+	FileSize          string //Humanized file size display
+	FilePercent       string //String value of percent of individual file percent done
+	FilePriority      string //Currently "High", "Normal", or "Cancel"
+}
+
+type SettingsFile struct {
+	MessageType string
+	Config      Settings.FullClientSettings
+}
+
+//ClientDB struct contains the struct that is used to compose the torrentlist
+type ClientDB struct { //TODO maybe separate out the internal bits into another client struct
+	TorrentHashString  string         //Passed to client for displaying hash and is used to uniquely identify all torrents
+	TorrentName        string         //String of the name of the torrent
+	DownloadedSize     string         //how much the client has downloaded total
+	Size               string         //total size of the torrent
+	DownloadSpeed      string         //the dl speed of the torrent
+	Status             string         //Passed to client for display
+	PercentDone        string         //Passed to client to show percent done
+	ActivePeers        string         //passed to client
+	UploadSpeed        string         //passed to client to show Uploadspeed
+	StoragePath        string         //Passed to client (and stored in stormdb)
+	DateAdded          string         //Passed to client (and stored in stormdb)
+	ETA                string         //Passed to client
+	TorrentLabel       string         //Passed to client and stored in stormdb
+	SourceType         string         //Stores whether the torrent came from a torrent file or a magnet link
+	KnownSwarm         []torrent.Peer //Passed to client for Peer Tab
+	UploadRatio        string         //Passed to client, stores the string for uploadratio stored in stormdb
+	TotalUploadedSize  string         //Humanized version of TotalUploadedBytes to pass to the client
+	TotalUploadedBytes int64          `json:"-"` //includes bytes that happened before reboot (from stormdb)
+	downloadSpeedInt   int64          //Internal used for calculating dl speed
+	BytesCompleted     int64          `json:"-"` //Internal used for calculating the dl speed
+	DataBytesWritten   int64          `json:"-"` //Internal used for calculating dl speed
+	DataBytesRead      int64          `json:"-"` //Internal used for calculating dl speed
+	UpdatedAt          time.Time      `json:"-"` //Internal used for calculating speeds of upload and download
+	TorrentHash        metainfo.Hash  `json:"-"` //Used to create string for TorrentHashString... not sure why I have it... make that a TODO I guess
+	NumberofFiles      int            //Number of files in the torrent
+	NumberofPieces     int            //Total number of pieces in the torrent (Not currently used)
+	MaxConnections     int            //Used to stop the torrent by limiting the max allowed connections
+}

engine/cronJobs.go

@@ -0,0 +1,103 @@
+package engine
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/anacrolix/torrent"
+	"github.com/asdine/storm"
+	Settings "github.com/deranjer/goTorrent/settings"
+	Storage "github.com/deranjer/goTorrent/storage"
+	"github.com/mmcdole/gofeed"
+	"github.com/robfig/cron"
+	"github.com/sirupsen/logrus"
+)
+
+//InitializeCronEngine initializes and starts the cron engine so we can add tasks as needed, returns pointer to the engine
+func InitializeCronEngine() *cron.Cron {
+	c := cron.New()
+	c.Start()
+	return c
+}
+
+//CheckTorrentWatchFolder adds torrents from a watch folder //TODO see if you can use filepath.Abs instead of changing directory
+func CheckTorrentWatchFolder(c *cron.Cron, db *storm.DB, tclient *torrent.Client, torrentLocalStorage Storage.TorrentLocal, config Settings.FullClientSettings) {
+	c.AddFunc("@every 5m", func() {
+		Logger.WithFields(logrus.Fields{"Watch Folder": config.TorrentWatchFolder}).Info("Running the watch folder cron job")
+		torrentFiles, err := ioutil.ReadDir(config.TorrentWatchFolder)
+		if err != nil {
+			Logger.WithFields(logrus.Fields{"Folder": config.TorrentWatchFolder, "Error": err}).Error("Unable to read from the torrent upload folder")
+			return
+		}
+		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())
+				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!")
+					continue
+				}
+
+				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, "file", fullNewFilePathAbs, config.DefaultMoveFolder, "default", config)
+
+			}
+		}
+	})
+}
+
+//RefreshRSSCron refreshes all of the RSS feeds on an hourly basis
+func RefreshRSSCron(c *cron.Cron, db *storm.DB, tclient *torrent.Client, torrentLocalStorage Storage.TorrentLocal, config Settings.FullClientSettings) {
+	c.AddFunc("@hourly", func() {
+		torrentHashHistory := Storage.FetchHashHistory(db)
+		RSSFeedStore := Storage.FetchRSSFeeds(db)
+		singleRSSTorrent := Storage.SingleRSSTorrent{}
+		newFeedStore := Storage.RSSFeedStore{ID: RSSFeedStore.ID} //creating a new feed store just using old one to parse for new torrents
+		fp := gofeed.NewParser()
+		for _, singleFeed := range RSSFeedStore.RSSFeeds {
+			feed, err := fp.ParseURL(singleFeed.URL)
+			if err != nil {
+				Logger.WithFields(logrus.Fields{"err": err, "url": singleFeed.URL}).Error("Failed to parse RSS URL")
+			}
+			for _, RSSTorrent := range feed.Items {
+				Logger.WithFields(logrus.Fields{"Torrent": RSSTorrent.Title}).Info("Found new torrent")
+				singleRSSTorrent.Link = RSSTorrent.Link
+				singleRSSTorrent.Title = RSSTorrent.Title
+				singleRSSTorrent.PubDate = RSSTorrent.Published
+				for _, hash := range torrentHashHistory.HashList {
+					linkHash := singleRSSTorrent.Link[20:60] //cutting the infohash out of the link
+					if linkHash == hash {
+						Logger.WithFields(logrus.Fields{"Torrent": RSSTorrent.Title}).Warn("Torrent already added for this RSS item, skipping torrent")
+					}
+				}
+				clientTorrent, err := tclient.AddMagnet(RSSTorrent.Link)
+				if err != nil {
+					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, "magnet", "", config.DefaultMoveFolder, "RSS", config) //TODO let user specify torrent default storage location and let change on fly
+				singleFeed.Torrents = append(singleFeed.Torrents, singleRSSTorrent)
+
+			}
+			newFeedStore.RSSFeeds = append(newFeedStore.RSSFeeds, singleFeed)
+		}
+		Storage.UpdateRSSFeeds(db, newFeedStore) //Calling this to fully update storage will all rss feeds
+	})
+
+}
+
+//LogCronStatus prints out the status of the cron jobs to the log
+func LogCronStatus(c *cron.Cron) { //TODO add a cron to inspect cron jobs and log the outputs
+
+}

engine/doneTorrentActions.go

@@ -0,0 +1,99 @@
+package engine
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/asdine/storm"
+	Settings "github.com/deranjer/goTorrent/settings"
+	Storage "github.com/deranjer/goTorrent/storage"
+	pushbullet "github.com/mitsuse/pushbullet-go"
+	"github.com/mitsuse/pushbullet-go/requests"
+	folderCopy "github.com/otiai10/copy"
+	"github.com/sirupsen/logrus"
+)
+
+//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 Settings.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.TorrentName}).Info("Move and Create symlink started for torrent")
+	var oldFilePath string
+	if moveDone { //only occurs on manual move
+		oldFilePathTemp := filepath.Join(oldPath, tStorage.TorrentName)
+		var err error
+		oldFilePath, err = filepath.Abs(oldFilePathTemp)
+		if err != nil {
+			Logger.WithFields(logrus.Fields{"Torrent Name": tStorage.TorrentName, "Filepath": oldFilePath}).Error("Cannot create absolute file path!")
+		}
+	} else {
+		oldFilePathTemp := filepath.Join(config.TorrentConfig.DataDir, tStorage.TorrentName)
+		var err error
+		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 {
+			Logger.WithFields(logrus.Fields{"New File Path": newFilePath, "error": err}).Error("Cannot create new directory")
+		}
+	}
+	oldFileInfo, err := os.Stat(oldFilePath)
+	if err != nil {
+		Logger.WithFields(logrus.Fields{"Old File info": oldFileInfo, "Old File Path": oldFilePath, "error": err}).Error("Cannot find the old file to copy/symlink!")
+		return
+	}
+
+	if oldFilePath != newFilePath {
+		newFilePathDir := filepath.Dir(newFilePath)
+		os.Mkdir(newFilePathDir, 0755)
+		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)
+		if runtime.GOOS != "windows" { //TODO the windows symlink is broken on windows 10 creator edition, so on the other platforms create symlink (windows will copy) until Go1.11
+			os.RemoveAll(oldFilePath)
+			err = os.Symlink(newFilePath, oldFilePath)
+			if err != nil {
+				Logger.WithFields(logrus.Fields{"Old File Path": oldFilePath, "New File Path": newFilePath, "error": err}).Error("Error creating symlink")
+			}
+		}
+		if moveDone == false {
+			tStorage.TorrentMoved = true     //TODO error handling instead of just saying torrent was moved when it was not
+			notifyUser(tStorage, config, db) //Only notify if we haven't moved yet, don't want to push notify user every time user uses change storage button
+		}
+		Logger.WithFields(logrus.Fields{"Old File Path": oldFilePath, "New File Path": newFilePath}).Info("Moving completed torrent")
+		tStorage.StoragePath = filepath.Dir(newFilePath)
+		Storage.UpdateStorageTick(db, tStorage)
+	}
+
+}
+
+func notifyUser(tStorage Storage.TorrentLocal, config Settings.FullClientSettings, db *storm.DB) {
+	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.UpdateStorageTick(db, tStorage)
+	if config.PushBulletToken != "" {
+		pb := pushbullet.New(config.PushBulletToken)
+		n := requests.NewNote()
+		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.TorrentName, "New File Path": tStorage.StoragePath, "error": err}).Error("Error pushing PushBullet Note")
+			return
+		}
+		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.TorrentName}).Info("No pushbullet API key set, not notifying")
+	}
+}

engine/doneTorrentActions_test.go

@@ -0,0 +1,47 @@
+package engine
+
+import (
+	"testing"
+
+	"github.com/asdine/storm"
+	Settings "github.com/deranjer/goTorrent/settings"
+	Storage "github.com/deranjer/goTorrent/storage"
+)
+
+func TestMoveAndLeaveSymlink(t *testing.T) {
+	type args struct {
+		config   Settings.FullClientSettings
+		tStorage Storage.TorrentLocal
+		db       *storm.DB
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			MoveAndLeaveSymlink(tt.args.config, tt.args.tStorage, tt.args.db)
+		})
+	}
+}
+
+func Test_notifyUser(t *testing.T) {
+	type args struct {
+		tStorage Storage.TorrentLocal
+		config   Settings.FullClientSettings
+		db       *storm.DB
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			notifyUser(tt.args.tStorage, tt.args.config, tt.args.db)
+		})
+	}
+}

engine/engine.go

@@ -0,0 +1,407 @@
+package engine //main file for all the calculations and data gathering needed for creating the running torrent arrays
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+	"github.com/asdine/storm"
+	Settings "github.com/deranjer/goTorrent/settings"
+	Storage "github.com/deranjer/goTorrent/storage"
+	"github.com/gorilla/websocket"
+	"github.com/mmcdole/gofeed"
+	"github.com/sirupsen/logrus"
+)
+
+//Logger is the injected variable for global logger
+var Logger *logrus.Logger
+
+//Config is the injected variable for the torrent config
+var Config Settings.FullClientSettings
+
+//Conn is the injected variable for the websocket connection
+var Conn *websocket.Conn
+
+//CreateServerPushMessage Pushes a message from the server to the client
+func CreateServerPushMessage(message ServerPushMessage, conn *websocket.Conn) {
+	conn.WriteJSON(message)
+}
+
+//RefreshSingleRSSFeed refreshing a single RSS feed to send to the client (so no updating database) mainly by updating the torrent list to display any changes
+func RefreshSingleRSSFeed(db *storm.DB, RSSFeed Storage.SingleRSSFeed) Storage.SingleRSSFeed { //Todo.. duplicate as cron job... any way to merge these to reduce duplication?
+	singleRSSFeed := Storage.SingleRSSFeed{URL: RSSFeed.URL, Name: RSSFeed.Name}
+	singleRSSTorrent := Storage.SingleRSSTorrent{}
+	fp := gofeed.NewParser()
+	feed, err := fp.ParseURL(RSSFeed.URL)
+	if err != nil {
+		Logger.WithFields(logrus.Fields{"RSSFeedURL": RSSFeed.URL, "error": err}).Error("Unable to parse URL")
+		CreateServerPushMessage(ServerPushMessage{MessageType: "serverPushMessage", MessageLevel: "error", Payload: "Unable to add Storage Path"}, Conn)
+	}
+	for _, RSSTorrent := range feed.Items {
+		singleRSSTorrent.Link = RSSTorrent.Link
+		singleRSSTorrent.Title = RSSTorrent.Title
+		singleRSSTorrent.PubDate = RSSTorrent.Published
+		singleRSSFeed.Torrents = append(singleRSSFeed.Torrents, singleRSSTorrent)
+
+	}
+	return singleRSSFeed
+
+}
+
+//ForceRSSRefresh forces a refresh (in addition to the cron schedule) to add the new RSS feed
+func ForceRSSRefresh(db *storm.DB, RSSFeedStore Storage.RSSFeedStore) { //Todo.. duplicate as cron job... any way to merge these to reduce duplication?
+	singleRSSTorrent := Storage.SingleRSSTorrent{}
+	newFeedStore := Storage.RSSFeedStore{ID: RSSFeedStore.ID} //creating a new feed store just using old one to parse for new torrents
+	fp := gofeed.NewParser()
+	Logger.WithFields(logrus.Fields{"RSSFeedStoreLength": len(RSSFeedStore.RSSFeeds)}).Debug("Length of RSS feeds (should be ONE)")
+	for _, singleFeed := range RSSFeedStore.RSSFeeds {
+		feed, err := fp.ParseURL(singleFeed.URL)
+		if err != nil {
+			Logger.WithFields(logrus.Fields{"RSSFeedURL": singleFeed.URL, "error": err}).Error("Unable to parse RSS URL")
+			CreateServerPushMessage(ServerPushMessage{MessageType: "serverPushMessage", MessageLevel: "error", Payload: "Unable to parse RSS URL"}, Conn)
+		}
+		for _, RSSTorrent := range feed.Items {
+			singleRSSTorrent.Link = RSSTorrent.Link
+			singleRSSTorrent.Title = RSSTorrent.Title
+			singleRSSTorrent.PubDate = RSSTorrent.Published
+			singleFeed.Torrents = append(singleFeed.Torrents, singleRSSTorrent)
+
+		}
+		newFeedStore.RSSFeeds = append(newFeedStore.RSSFeeds, singleFeed)
+	}
+	Storage.UpdateRSSFeeds(db, newFeedStore) //Calling this to fully update storage will all rss feeds
+}
+
+//timeOutInfo forcing a timeout of the torrent if it doesn't load from program restart
+func timeOutInfo(clientTorrent *torrent.Torrent, seconds time.Duration) (deleted bool) {
+	Logger.WithFields(logrus.Fields{"Seconds to wait for info...": seconds}).Info("Attempting to download info for torrent")
+	timeout := make(chan bool, 1) //creating a timeout channel for our gotinfo
+	go func() {
+		time.Sleep(seconds * time.Second)
+		timeout <- true
+	}()
+	select {
+	case <-clientTorrent.GotInfo(): //attempting to retrieve info for torrent
+		Logger.WithFields(logrus.Fields{"clientTorrentName": clientTorrent.Name()}).Debug("Received torrent info for torrent")
+		return false
+	case <-timeout: // getting info for torrent has timed out so purging the torrent
+		Logger.WithFields(logrus.Fields{"clientTorrentName": clientTorrent.Name()}).Error("Forced to drop torrent from timeout waiting for info")
+		CreateServerPushMessage(ServerPushMessage{MessageType: "serverPushMessage", MessageLevel: "error", Payload: "Timout waiting for torrent info... dropping"}, Conn)
+		clientTorrent.Drop()
+		return true
+	}
+
+}
+
+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")
+	}
+	_, 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, 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, torrentType, torrentFilePathAbs, torrentStoragePath, labelValue string, config Settings.FullClientSettings) {
+	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
+	}
+	var TempHash metainfo.Hash
+	TempHash = clientTorrent.InfoHash()
+	allStoredTorrents := Storage.FetchAllStoredTorrents(torrentDbStorage)
+	for _, runningTorrentHashes := range allStoredTorrents {
+		if runningTorrentHashes.Hash == TempHash.String() {
+			Logger.WithFields(logrus.Fields{"Hash": TempHash.String()}).Error("Torrent has duplicate hash to already running torrent... will not add to storage")
+			return
+		}
+	}
+	torrentLocalStorage.Hash = TempHash.String() // we will store the infohash to add it back later on client restart (if needed)
+	torrentLocalStorage.InfoBytes = clientTorrent.Metainfo().InfoBytes
+	torrentLocalStorage.Label = labelValue
+	torrentLocalStorage.DateAdded = time.Now().Format("Jan _2 2006")
+	torrentLocalStorage.StoragePath = torrentStoragePath
+	torrentLocalStorage.TempStoragePath = config.TorrentConfig.DataDir
+	torrentLocalStorage.TorrentName = clientTorrent.Name()
+	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
+		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")
+		}
+		torrentLocalStorage.TorrentFile = torrentfile //storing the entire file in to database
+	}
+	Logger.WithFields(logrus.Fields{"Storage Path": torrentStoragePath, "Torrent Name": clientTorrent.Name()}).Info("Adding Torrent with following storage path")
+	torrentFiles := clientTorrent.Files() //storing all of the files in the database along with the priority
+	var TorrentFilePriorityArray = []Storage.TorrentFilePriority{}
+	for _, singleFile := range torrentFiles { //creating the database setup for the file array
+		var torrentFilePriority = Storage.TorrentFilePriority{}
+		torrentFilePriority.TorrentFilePath = singleFile.DisplayPath()
+		torrentFilePriority.TorrentFilePriority = "Normal"
+		torrentFilePriority.TorrentFileSize = singleFile.Length()
+		TorrentFilePriorityArray = append(TorrentFilePriorityArray, torrentFilePriority)
+
+	}
+
+	torrentLocalStorage.TorrentFilePriority = TorrentFilePriorityArray
+	Storage.AddTorrentLocalStorage(torrentDbStorage, torrentLocalStorage) //writing all of the data to the database
+	clientTorrent.DownloadAll()                                           //set all pieces to download
+	NumPieces := clientTorrent.NumPieces()                                //find the number of pieces
+	clientTorrent.CancelPieces(1, NumPieces)                              //cancel all of the pieces to use file priority
+	for _, singleFile := range clientTorrent.Files() {                    //setting all of the file priorities to normal
+		singleFile.SetPriority(torrent.PiecePriorityNormal)
+	}
+	fmt.Println("Downloading ALL") //starting the download
+
+	CreateServerPushMessage(ServerPushMessage{MessageType: "serverPushMessage", MessageLevel: "success", Payload: "Torrent added!"}, Conn)
+}
+
+//CreateInitialTorrentArray adds all the torrents on program start from the database
+func CreateInitialTorrentArray(tclient *torrent.Client, TorrentLocalArray []*Storage.TorrentLocal, db *storm.DB) {
+	for _, singleTorrentFromStorage := range TorrentLocalArray {
+		var singleTorrent *torrent.Torrent
+		var err error
+		if singleTorrentFromStorage.TorrentType == "file" { //if it is a file pull it from the uploaded torrent folder
+			singleTorrent, err = readTorrentFileFromDB(singleTorrentFromStorage, tclient, db)
+			if err != nil {
+				continue
+			}
+		} else {
+			singleTorrentFromStorageMagnet := "magnet:?xt=urn:btih:" + singleTorrentFromStorage.Hash //For magnet links just need to prepend the magnet part to the hash to readd
+			singleTorrent, err = tclient.AddMagnet(singleTorrentFromStorageMagnet)
+			if err != nil {
+				continue
+			}
+
+		}
+		if len(singleTorrentFromStorage.InfoBytes) == 0 { //TODO.. kind of a fringe scenario.. not sure if needed since the db should always have the infobytes
+			timeOut := timeOutInfo(singleTorrent, 45)
+			if timeOut == true { // if we did timeout then drop the torrent from the bolt.db database
+				Storage.DelTorrentLocalStorage(db, singleTorrentFromStorage.Hash) //purging torrent from the local database
+				continue
+			}
+			singleTorrentFromStorage.InfoBytes = singleTorrent.Metainfo().InfoBytes
+		}
+
+		err = singleTorrent.SetInfoBytes(singleTorrentFromStorage.InfoBytes) //setting the infobytes back into the torrent
+		if err != nil {
+			Logger.WithFields(logrus.Fields{"torrentFile": singleTorrent.Name(), "error": err}).Error("Unable to add infobytes to the torrent!")
+		}
+		if singleTorrentFromStorage.TorrentStatus != "Completed" && singleTorrentFromStorage.TorrentStatus != "Stopped" {
+			fmt.Println("Starting torrent as download", singleTorrent.Name())
+			singleTorrent.DownloadAll()                        //set all of the pieces to download (piece prio is NE to file prio)
+			NumPieces := singleTorrent.NumPieces()             //find the number of pieces
+			singleTorrent.CancelPieces(1, NumPieces)           //cancel all of the pieces to use file priority
+			for _, singleFile := range singleTorrent.Files() { //setting all of the file priorities to normal
+				singleFile.SetPriority(torrent.PiecePriorityNormal)
+			}
+		} else {
+			fmt.Println("Torrent status is....", singleTorrentFromStorage.TorrentStatus)
+		}
+
+	}
+	SetFilePriority(tclient, db) //Setting the desired file priority from storage
+}
+
+//CreateRunningTorrentArray creates the entire torrent list to pass to client
+func CreateRunningTorrentArray(tclient *torrent.Client, TorrentLocalArray []*Storage.TorrentLocal, PreviousTorrentArray []ClientDB, config Settings.FullClientSettings, db *storm.DB) (RunningTorrentArray []ClientDB) {
+
+	for _, singleTorrentFromStorage := range TorrentLocalArray {
+		var singleTorrent *torrent.Torrent
+		var TempHash metainfo.Hash
+		for _, liveTorrent := range tclient.Torrents() { //matching the torrent from storage to the live torrent
+			if singleTorrentFromStorage.Hash == liveTorrent.InfoHash().String() {
+				singleTorrent = liveTorrent
+			}
+		}
+
+		tickUpdateStruct := Storage.TorrentLocal{} //we are shoving the tick updates into a torrentlocal struct to pass to storage happens at the end of the routine
+
+		fullClientDB := new(ClientDB)
+		//singleTorrentStorageInfo := Storage.FetchTorrentFromStorage(db, TempHash.String())  //pulling the single torrent info from storage ()
+
+		if singleTorrentFromStorage.TorrentStatus == "Dropped" {
+			Logger.WithFields(logrus.Fields{"selection": singleTorrentFromStorage.TorrentName}).Info("Deleting just the torrent")
+			singleTorrent.Drop()
+			Storage.DelTorrentLocalStorage(db, singleTorrentFromStorage.Hash)
+		}
+		if singleTorrentFromStorage.TorrentStatus == "DroppedData" {
+			Logger.WithFields(logrus.Fields{"selection": singleTorrentFromStorage.TorrentName}).Info("Deleting just the torrent")
+			singleTorrent.Drop()
+			Storage.DelTorrentLocalStorageAndFiles(db, singleTorrentFromStorage.Hash, Config.TorrentConfig.DataDir)
+
+		}
+		if singleTorrentFromStorage.TorrentType == "file" { //if it is a file pull it from the uploaded torrent folder
+			fullClientDB.SourceType = "Torrent File"
+		} else {
+			fullClientDB.SourceType = "Magnet Link"
+		}
+
+		calculatedTotalSize := CalculateDownloadSize(singleTorrentFromStorage, singleTorrent)
+		calculatedCompletedSize := CalculateCompletedSize(singleTorrentFromStorage, singleTorrent)
+		TempHash = singleTorrent.InfoHash()
+		if (calculatedCompletedSize == 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...")
+			go 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)
+		fullClientDB.StoragePath = singleTorrentFromStorage.StoragePath
+
+		downloadedSizeHumanized := HumanizeBytes(float32(calculatedCompletedSize)) //convert size to GB if needed
+		totalSizeHumanized := HumanizeBytes(float32(calculatedTotalSize))
+
+		fullClientDB.DownloadedSize = downloadedSizeHumanized
+		fullClientDB.Size = totalSizeHumanized
+		PercentDone := fmt.Sprintf("%.2f", float32(calculatedCompletedSize)/float32(calculatedTotalSize))
+		fullClientDB.TorrentHash = TempHash
+		fullClientDB.PercentDone = PercentDone
+		fullClientDB.DataBytesRead = fullStruct.ConnStats.BytesReadData       //used for calculations not passed to client calculating up/down speed
+		fullClientDB.DataBytesWritten = fullStruct.ConnStats.BytesWrittenData //used for calculations not passed to client calculating up/down speed
+		fullClientDB.ActivePeers = activePeersString + " / (" + totalPeersString + ")"
+		fullClientDB.TorrentHashString = TempHash.String()
+		fullClientDB.TorrentName = singleTorrentFromStorage.TorrentName
+		fullClientDB.DateAdded = singleTorrentFromStorage.DateAdded
+		fullClientDB.TorrentLabel = singleTorrentFromStorage.Label
+		fullClientDB.BytesCompleted = calculatedCompletedSize
+		fullClientDB.NumberofFiles = len(singleTorrent.Files())
+
+		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
+					CalculateTorrentSpeed(singleTorrent, fullClientDB, previousElement, calculatedCompletedSize)
+					fullClientDB.TotalUploadedBytes = singleTorrentFromStorage.UploadedBytes + (fullStruct.ConnStats.BytesWrittenData - previousElement.DataBytesWritten)
+				}
+			}
+		}
+		CalculateTorrentETA(singleTorrentFromStorage.TorrentSize, calculatedCompletedSize, 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
+
+		CalculateTorrentStatus(singleTorrent, fullClientDB, config, singleTorrentFromStorage, calculatedCompletedSize, calculatedTotalSize)
+
+		tickUpdateStruct.UploadRatio = fullClientDB.UploadRatio
+		tickUpdateStruct.TorrentSize = calculatedTotalSize
+		tickUpdateStruct.UploadedBytes = fullClientDB.TotalUploadedBytes
+		tickUpdateStruct.TorrentStatus = fullClientDB.Status
+		tickUpdateStruct.Hash = fullClientDB.TorrentHashString //needed for index
+		Storage.UpdateStorageTick(db, tickUpdateStruct)
+		RunningTorrentArray = append(RunningTorrentArray, *fullClientDB)
+
+	}
+	return RunningTorrentArray
+}
+
+//CreateFileListArray creates a file list for a single torrent that is selected and sent to the server
+func CreateFileListArray(tclient *torrent.Client, selectedHash string, db *storm.DB, config Settings.FullClientSettings) TorrentFileList {
+	runningTorrents := tclient.Torrents() //don't need running torrent array since we aren't adding or deleting from storage
+	torrentFileListStorage := Storage.FetchTorrentFromStorage(db, selectedHash)
+	TorrentFileListSelected := TorrentFileList{}
+	TorrentFileStruct := TorrentFile{}
+	for _, singleTorrent := range runningTorrents {
+		tempHash := singleTorrent.InfoHash().String()
+		if tempHash == selectedHash { // if our selection hash equals our torrent hash
+			torrentFilesRaw := singleTorrent.Files()
+			Logger.WithFields(logrus.Fields{"torrentFiles": torrentFilesRaw}).Debug("Unable to close tempfile")
+			for _, singleFile := range torrentFilesRaw {
+				TorrentFileStruct.TorrentHashString = tempHash
+				TorrentFileStruct.FileName = singleFile.DisplayPath()
+				TorrentFileStruct.FilePath = singleFile.Path()
+				PieceState := singleFile.State()
+				var downloadedBytes int64
+				for _, piece := range PieceState {
+					if piece.Complete {
+						downloadedBytes = downloadedBytes + piece.Bytes //adding up the bytes in the completed pieces
+					}
+				}
+				TorrentFileStruct.FilePercent = fmt.Sprintf("%.2f", float32(downloadedBytes)/float32(singleFile.Length()))
+
+				for i, specificFile := range torrentFileListStorage.TorrentFilePriority { //searching for that specific file in storage
+					if specificFile.TorrentFilePath == singleFile.DisplayPath() {
+						TorrentFileStruct.FilePriority = torrentFileListStorage.TorrentFilePriority[i].TorrentFilePriority
+					}
+				}
+				TorrentFileStruct.FileSize = HumanizeBytes(float32(singleFile.Length()))
+				TorrentFileListSelected.FileList = append(TorrentFileListSelected.FileList, TorrentFileStruct)
+			}
+			TorrentFileListSelected.MessageType = "torrentFileList"
+			TorrentFileListSelected.TotalFiles = len(singleTorrent.Files())
+			Logger.WithFields(logrus.Fields{"selectedFiles": TorrentFileListSelected}).Debug("Selected Torrent Files")
+			return TorrentFileListSelected
+		}
+
+	}
+	return TorrentFileListSelected
+}
+
+//CreatePeerListArray create a list of peers for the torrent and displays them
+func CreatePeerListArray(tclient *torrent.Client, selectedHash string) PeerFileList {
+	runningTorrents := tclient.Torrents()
+	TorrentPeerList := PeerFileList{}
+	for _, singleTorrent := range runningTorrents {
+		tempHash := singleTorrent.InfoHash().String()
+		if (strings.Compare(tempHash, selectedHash)) == 0 {
+			TorrentPeerList.MessageType = "torrentPeerList"
+			TorrentPeerList.PeerList = singleTorrent.KnownSwarm()
+			TorrentPeerList.TotalPeers = len(TorrentPeerList.PeerList)
+			return TorrentPeerList
+		}
+	}
+	return TorrentPeerList
+}
+
+//CreateTorrentDetailJSON creates the json response for a request for more torrent information
+func CreateTorrentDetailJSON(tclient *torrent.Client, selectedHash string, torrentStorage *storm.DB) ClientDB {
+
+	localTorrentInfo := Storage.FetchTorrentFromStorage(torrentStorage, selectedHash)
+
+	runningTorrents := tclient.Torrents()
+
+	TorrentDetailStruct := ClientDB{}
+	for _, singleTorrent := range runningTorrents { //ranging through the running torrents to find the one we are looking for
+		tempHash := singleTorrent.InfoHash().String()
+		if tempHash == selectedHash {
+			Logger.WithFields(logrus.Fields{"torrentHash": tempHash, "detailedInfo": localTorrentInfo}).Info("Creating detailed torrent list")
+			return TorrentDetailStruct
+		}
+	}
+	return TorrentDetailStruct
+}

engine/engineHelpers.go

@@ -0,0 +1,206 @@
+package engine
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"github.com/anacrolix/torrent"
+	"github.com/asdine/storm"
+	Settings "github.com/deranjer/goTorrent/settings"
+	"github.com/deranjer/goTorrent/storage"
+	Storage "github.com/deranjer/goTorrent/storage"
+	"github.com/sirupsen/logrus"
+)
+
+func secondsToMinutes(inSeconds int64) string {
+	minutes := inSeconds / 60
+	seconds := inSeconds % 60
+	minutesString := fmt.Sprintf("%d", minutes)
+	secondsString := fmt.Sprintf("%d", seconds)
+	str := minutesString + " Min/ " + secondsString + " Sec"
+	return str
+}
+
+//MakeRange creates a range of pieces to set their priority based on a file
+func MakeRange(min, max int) []int {
+	a := make([]int, max-min+1)
+	for i := range a {
+		a[i] = min + i
+	}
+	return a
+}
+
+//HumanizeBytes returns a nice humanized version of bytes in either GB or MB
+func HumanizeBytes(bytes float32) string {
+	if bytes < 1000000 { //if we have less than 1MB in bytes convert to KB
+		pBytes := fmt.Sprintf("%.2f", bytes/1024)
+		pBytes = pBytes + " KB"
+		return pBytes
+	}
+	bytes = bytes / 1024 / 1024 //Converting bytes to a useful measure
+	if bytes > 1024 {
+		pBytes := fmt.Sprintf("%.2f", bytes/1024)
+		pBytes = pBytes + " GB"
+		return pBytes
+	}
+	pBytes := fmt.Sprintf("%.2f", bytes) //If not too big or too small leave it as MB
+	pBytes = pBytes + " MB"
+	return pBytes
+}
+
+//CopyFile takes a source file string and a destination file string and copies the file
+func CopyFile(srcFile string, destFile string) { //TODO move this to our imported copy repo
+	fileContents, err := os.Open(srcFile)
+	defer fileContents.Close()
+	if err != nil {
+		Logger.WithFields(logrus.Fields{"File": srcFile, "Error": err}).Error("Cannot open source file")
+	}
+	outfileContents, err := os.Create(destFile)
+	defer outfileContents.Close()
+	if err != nil {
+		Logger.WithFields(logrus.Fields{"File": destFile, "Error": err}).Error("Cannot open destination file")
+	}
+	_, err = io.Copy(outfileContents, fileContents)
+	if err != nil {
+		Logger.WithFields(logrus.Fields{"Source File": srcFile, "Destination File": destFile, "Error": err}).Error("Cannot write contents to destination file")
+	}
+
+}
+
+//SetFilePriority sets the priorities for all of the files in a torrent
+func SetFilePriority(t *torrent.Client, db *storm.DB) {
+	storedTorrents := Storage.FetchAllStoredTorrents(db)
+	for _, singleTorrent := range t.Torrents() {
+		for _, storedTorrent := range storedTorrents {
+			if storedTorrent.Hash == singleTorrent.InfoHash().String() {
+				for _, file := range singleTorrent.Files() {
+					for _, storedFile := range storedTorrent.TorrentFilePriority {
+						if storedFile.TorrentFilePath == file.DisplayPath() {
+							switch storedFile.TorrentFilePriority {
+							case "High":
+								file.SetPriority(torrent.PiecePriorityHigh)
+							case "Normal":
+								file.SetPriority(torrent.PiecePriorityNormal)
+							case "Cancel":
+								file.SetPriority(torrent.PiecePriorityNone)
+							default:
+								file.SetPriority(torrent.PiecePriorityNormal)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//CalculateTorrentSpeed is used to calculate the torrent upload and download speed over time c is current clientdb, oc is last client db to calculate speed over time
+func CalculateTorrentSpeed(t *torrent.Torrent, c *ClientDB, oc ClientDB, completedSize int64) {
+	now := time.Now()
+	bytes := completedSize
+	bytesUpload := t.Stats().BytesWrittenData
+	dt := float32(now.Sub(oc.UpdatedAt))     // get the delta time length between now and last updated
+	db := float32(bytes - oc.BytesCompleted) //getting the delta bytes
+	rate := db * (float32(time.Second) / dt) // converting into seconds
+	dbU := float32(bytesUpload - oc.DataBytesWritten)
+	rateUpload := dbU * (float32(time.Second) / dt)
+	if rate >= 0 {
+		rateMB := rate / 1024 / 1024 //creating MB to calculate ETA
+		c.DownloadSpeed = fmt.Sprintf("%.2f", rateMB)
+		c.DownloadSpeed = c.DownloadSpeed + " MB/s"
+		c.downloadSpeedInt = int64(rate)
+	}
+	if rateUpload >= 0 {
+		rateUpload = rateUpload / 1024 / 1024
+		c.UploadSpeed = fmt.Sprintf("%.2f", rateUpload)
+		c.UploadSpeed = c.UploadSpeed + " MB/s"
+
+	}
+	c.UpdatedAt = now
+}
+
+//CalculateDownloadSize will calculate the download size once file priorities are sorted out
+func CalculateDownloadSize(tFromStorage *Storage.TorrentLocal, activeTorrent *torrent.Torrent) int64 {
+	var totalLength int64
+	for _, file := range tFromStorage.TorrentFilePriority {
+		if file.TorrentFilePriority != "Cancel" {
+			totalLength = totalLength + file.TorrentFileSize
+		}
+	}
+	return totalLength
+}
+
+//CalculateCompletedSize will be used to calculate how much of the actual torrent we have completed minus the canceled files (even if they have been partially downloaded)
+func CalculateCompletedSize(tFromStorage *Storage.TorrentLocal, activeTorrent *torrent.Torrent) int64 {
+	var discardByteLength int64
+	for _, storageFile := range tFromStorage.TorrentFilePriority {
+		if storageFile.TorrentFilePriority == "Cancel" { //If the file is canceled don't count it as downloaded
+			for _, activeFile := range activeTorrent.Files() {
+				if activeFile.DisplayPath() == storageFile.TorrentFilePath { //match the file from storage to active
+					for _, piece := range activeFile.State() {
+						if piece.Partial || piece.Complete {
+							discardByteLength = discardByteLength + piece.Bytes
+						}
+					}
+				}
+			}
+		}
+	}
+	downloadedLength := activeTorrent.BytesCompleted() - discardByteLength
+	if downloadedLength < 0 {
+		downloadedLength = 0
+	}
+	return downloadedLength
+}
+
+//CalculateTorrentETA is used to estimate the remaining dl time of the torrent based on the speed that the MB are being downloaded
+func CalculateTorrentETA(tSize int64, tBytesCompleted int64, c *ClientDB) {
+	missingBytes := tSize - tBytesCompleted
+	if missingBytes == 0 {
+		c.ETA = "Done"
+	} else if c.downloadSpeedInt == 0 {
+		c.ETA = "N/A"
+	} else {
+		ETASeconds := missingBytes / c.downloadSpeedInt
+		str := secondsToMinutes(ETASeconds) //converting seconds to minutes + seconds
+		c.ETA = str
+	}
+}
+
+//CalculateUploadRatio calculates the download to upload ratio so you can see if you are being a good seeder
+func CalculateUploadRatio(t *torrent.Torrent, c *ClientDB) string {
+	if c.TotalUploadedBytes > 0 && t.BytesCompleted() > 0 { //If we have actually started uploading and downloading stuff start calculating our ratio
+		uploadRatio := fmt.Sprintf("%.2f", float64(c.TotalUploadedBytes)/float64(t.BytesCompleted()))
+		return uploadRatio
+	}
+	uploadRatio := "0.00" //we haven't uploaded anything so no upload ratio just pass a string directly
+	return uploadRatio
+}
+
+//CalculateTorrentStatus is used to determine what the STATUS column of the frontend will display ll2
+func CalculateTorrentStatus(t *torrent.Torrent, c *ClientDB, config Settings.FullClientSettings, tFromStorage *storage.TorrentLocal, bytesCompleted int64, totalSize int64) {
+	if (tFromStorage.TorrentStatus == "Stopped") || (float64(c.TotalUploadedBytes)/float64(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)
+
+	} else { //Only has 2 states in storage, stopped or running, so we know it should be running, and the websocket request handled updating the database with connections and status
+		bytesMissing := totalSize - bytesCompleted
+		c.MaxConnections = 80
+		t.SetMaxEstablishedConns(80)
+		//t.DownloadAll() //ensure that we are setting the torrent to download
+		if t.Seeding() && t.Stats().ActivePeers > 0 && bytesMissing == 0 {
+			c.Status = "Seeding"
+		} else if t.Stats().ActivePeers > 0 && bytesMissing > 0 {
+			c.Status = "Downloading"
+		} else if t.Stats().ActivePeers == 0 && bytesMissing == 0 {
+			c.Status = "Completed"
+		} else if t.Stats().ActivePeers == 0 && bytesMissing > 0 {
+			c.Status = "Awaiting Peers"
+		} else {
+			c.Status = "Unknown"
+		}
+	}
+}

goTorrentWebUI/.babelrc

@@ -0,0 +1,10 @@
+{ 
+	"presets": [
+		"react",
+		"env",
+		"stage-2",
+	],
+	
+	"plugins": ["transform-class-properties"]
+	
+}

goTorrentWebUI/acorn

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/acorn/bin/acorn" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/acorn/bin/acorn" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/acorn.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\acorn\bin\acorn" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\acorn\bin\acorn" %*
+)

goTorrentWebUI/ansi-html

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/ansi-html/bin/ansi-html" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/ansi-html/bin/ansi-html" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/ansi-html.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\ansi-html\bin\ansi-html" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\ansi-html\bin\ansi-html" %*
+)

goTorrentWebUI/atob

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/atob/bin/atob.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/atob/bin/atob.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/atob.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\atob\bin\atob.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\atob\bin\atob.js" %*
+)

goTorrentWebUI/browserslist

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/browserslist/cli.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/browserslist/cli.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/browserslist.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\browserslist\cli.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\browserslist\cli.js" %*
+)

goTorrentWebUI/cssesc

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/cssesc/bin/cssesc" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/cssesc/bin/cssesc" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/cssesc.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\cssesc\bin\cssesc" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\cssesc\bin\cssesc" %*
+)

goTorrentWebUI/csso

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/csso/bin/csso" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/csso/bin/csso" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/csso.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\csso\bin\csso" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\csso\bin\csso" %*
+)

goTorrentWebUI/detect

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/detect-port-alt/bin/detect-port" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/detect-port-alt/bin/detect-port" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/detect-port

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/detect-port-alt/bin/detect-port" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/detect-port-alt/bin/detect-port" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/detect-port.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\detect-port-alt\bin\detect-port" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\detect-port-alt\bin\detect-port" %*
+)

goTorrentWebUI/detect.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\detect-port-alt\bin\detect-port" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\detect-port-alt\bin\detect-port" %*
+)

goTorrentWebUI/errno

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/errno/cli.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/errno/cli.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/errno.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\errno\cli.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\errno\cli.js" %*
+)

goTorrentWebUI/escodegen

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/escodegen/bin/escodegen.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/escodegen/bin/escodegen.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/escodegen.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\escodegen\bin\escodegen.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\escodegen\bin\escodegen.js" %*
+)

goTorrentWebUI/esgenerate

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/escodegen/bin/esgenerate.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/escodegen/bin/esgenerate.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/esgenerate.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\escodegen\bin\esgenerate.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\escodegen\bin\esgenerate.js" %*
+)

goTorrentWebUI/eslint

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/eslint/bin/eslint.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/eslint/bin/eslint.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/eslint.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\eslint\bin\eslint.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\eslint\bin\eslint.js" %*
+)

goTorrentWebUI/esparse

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/esprima/bin/esparse.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/esprima/bin/esparse.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/esparse.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\esprima\bin\esparse.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\esprima\bin\esparse.js" %*
+)

goTorrentWebUI/esvalidate

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/esprima/bin/esvalidate.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/esprima/bin/esvalidate.js" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/esvalidate.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\esprima\bin\esvalidate.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\esprima\bin\esvalidate.js" %*
+)

goTorrentWebUI/handlebars

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/handlebars/bin/handlebars" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/handlebars/bin/handlebars" "$@"
+  ret=$?
+fi
+exit $ret

goTorrentWebUI/handlebars.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\node_modules\handlebars\bin\handlebars" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\node_modules\handlebars\bin\handlebars" %*
+)

goTorrentWebUI/he

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/node_modules/he/bin/he" "$@"
+  ret=$?
+else 
+  node  "$basedir/node_modules/he/bin/he" "$@"
+  ret=$?
+fi
+exit $ret