From 9a5ded48a696d4b4a2cc991646350af6c55616fe Mon Sep 17 00:00:00 2001 From: Vincent Batts Date: Wed, 27 Mar 2013 16:30:24 -0400 Subject: [PATCH] running go fmt --- client.go | 119 +++--- config.go | 49 +-- db_fileutil.go | 74 ++-- hash.go | 37 +- hash_test.go | 47 ++- imgsrv.go | 339 +++++++++-------- layouts.go | 145 ++++---- server.go | 989 ++++++++++++++++++++++++------------------------- types.go | 22 +- version.go | 10 +- 10 files changed, 906 insertions(+), 925 deletions(-) diff --git a/client.go b/client.go index 2664008..5e53d36 100644 --- a/client.go +++ b/client.go @@ -1,75 +1,74 @@ package main import ( - "bufio" - "crypto/tls" - "io/ioutil" - "log" - "mime" - "net/http" - "os" - "path/filepath" - "time" + "bufio" + "crypto/tls" + "io/ioutil" + "log" + "mime" + "net/http" + "os" + "path/filepath" + "time" ) func PutFileFromPath(host, filename string) (path string, err error) { - ext := filepath.Ext(filename) - file, err := os.Open(filename) - if (err != nil) { - return - } - resp, err := http.Post(host, mime.TypeByExtension(ext) , bufio.NewReader(file)) - if (err != nil) { - return - } - bytes, err := ioutil.ReadAll(resp.Body) - if (err != nil) { - return - } - return string(bytes), nil + ext := filepath.Ext(filename) + file, err := os.Open(filename) + if err != nil { + return + } + resp, err := http.Post(host, mime.TypeByExtension(ext), bufio.NewReader(file)) + if err != nil { + return + } + bytes, err := ioutil.ReadAll(resp.Body) + if err != nil { + return + } + return string(bytes), nil } func FetchFileFromURL(url string) (filename string, err error) { - var t time.Time + var t time.Time - tr := &http.Transport{ - TLSClientConfig: &tls.Config{ InsecureSkipVerify: true }, - } - client := &http.Client{ - //CheckRedirect: redirectPolicyFunc, - Transport: tr, - } - resp, err := client.Get(url) - defer resp.Body.Close() - if (err != nil) { - return - } + tr := &http.Transport{ + TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, + } + client := &http.Client{ + //CheckRedirect: redirectPolicyFunc, + Transport: tr, + } + resp, err := client.Get(url) + defer resp.Body.Close() + if err != nil { + return + } - mtime := resp.Header.Get("last-modified") - if (len(mtime) > 0) { - t, err = time.Parse(http.TimeFormat, mtime) - if (err != nil) { - return - } - } else { - log.Println("Last-Modified not present. Using current time") - t = time.Now() - } - _, url_filename := filepath.Split(url) + mtime := resp.Header.Get("last-modified") + if len(mtime) > 0 { + t, err = time.Parse(http.TimeFormat, mtime) + if err != nil { + return + } + } else { + log.Println("Last-Modified not present. Using current time") + t = time.Now() + } + _, url_filename := filepath.Split(url) - log.Println(resp) + log.Println(resp) - bytes, err := ioutil.ReadAll(resp.Body) - if (err != nil) { - return - } - err = ioutil.WriteFile(filepath.Join(os.TempDir(), url_filename), bytes, 0644) - if (err != nil) { - return - } - err = os.Chtimes(filepath.Join(os.TempDir(), url_filename), t, t) + bytes, err := ioutil.ReadAll(resp.Body) + if err != nil { + return + } + err = ioutil.WriteFile(filepath.Join(os.TempDir(), url_filename), bytes, 0644) + if err != nil { + return + } + err = os.Chtimes(filepath.Join(os.TempDir(), url_filename), t, t) - // lastly, return - return filepath.Join(os.TempDir(), url_filename), nil + // lastly, return + return filepath.Join(os.TempDir(), url_filename), nil } - diff --git a/config.go b/config.go index 57653d3..62ce0f2 100644 --- a/config.go +++ b/config.go @@ -1,44 +1,45 @@ package main import ( - "launchpad.net/goyaml" - "io/ioutil" + "io/ioutil" + "launchpad.net/goyaml" ) type Config map[string]interface{} func (c *Config) GetBool(option string) (value bool) { - conf := Config{} - conf = *c - switch conf[option] { - default: value = false - case "yes", "on", "true": value = true - } - return + conf := Config{} + conf = *c + switch conf[option] { + default: + value = false + case "yes", "on", "true": + value = true + } + return } func (c *Config) GetString(option string) (value string) { - conf := Config{} - conf = *c - value, _ = conf[option].(string) - return + conf := Config{} + conf = *c + value, _ = conf[option].(string) + return } func ReadConfigFile(filename string) (config Config, err error) { - bytes, err := ioutil.ReadFile(filename) - if (err != nil) { - return - } + bytes, err := ioutil.ReadFile(filename) + if err != nil { + return + } - err = goyaml.Unmarshal(bytes, &config) - if (err != nil) { - return - } + err = goyaml.Unmarshal(bytes, &config) + if err != nil { + return + } - return config, nil + return config, nil } func WriteConfigFile(filename string, data []byte) (err error) { - return + return } - diff --git a/db_fileutil.go b/db_fileutil.go index 9399aae..a5f7806 100644 --- a/db_fileutil.go +++ b/db_fileutil.go @@ -1,60 +1,58 @@ - package main import ( - "labix.org/v2/mgo/bson" + "labix.org/v2/mgo/bson" ) /* gfs is a *mgo.GridFS defined in imgsrv.go */ func GetFileByFilename(filename string) (this_file File, err error) { - err = gfs.Find(bson.M{"filename":filename}).One(&this_file) - if (err != nil) { - return this_file, err - } - return this_file, nil + err = gfs.Find(bson.M{"filename": filename}).One(&this_file) + if err != nil { + return this_file, err + } + return this_file, nil } func GetFileRandom() (this_file File, err error) { - r := Rand64() - err = gfs.Find(bson.M{"random": bson.M{"$gt" : r } }).One(&this_file) - if (err != nil) { - return this_file, err - } - if (len(this_file.Md5) == 0) { - err = gfs.Find(bson.M{"random": bson.M{"$lt" : r } }).One(&this_file) - } - if (err != nil) { - return this_file, err - } - return this_file, nil + r := Rand64() + err = gfs.Find(bson.M{"random": bson.M{"$gt": r}}).One(&this_file) + if err != nil { + return this_file, err + } + if len(this_file.Md5) == 0 { + err = gfs.Find(bson.M{"random": bson.M{"$lt": r}}).One(&this_file) + } + if err != nil { + return this_file, err + } + return this_file, nil } /* Check whether this File filename is on Mongo */ func HasFileByFilename(filename string) (exists bool, err error) { - c, err := gfs.Find(bson.M{"filename": filename}).Count() - if (err != nil) { - return false, err - } - exists = (c > 0) - return exists, nil + c, err := gfs.Find(bson.M{"filename": filename}).Count() + if err != nil { + return false, err + } + exists = (c > 0) + return exists, nil } func HasFileByMd5(md5 string) (exists bool, err error) { - c, err := gfs.Find(bson.M{"md5": md5 }).Count() - if (err != nil) { - return false, err - } - exists = (c > 0) - return exists, nil + c, err := gfs.Find(bson.M{"md5": md5}).Count() + if err != nil { + return false, err + } + exists = (c > 0) + return exists, nil } func HasFileByKeyword(keyword string) (exists bool, err error) { - c, err := gfs.Find(bson.M{"metadata": bson.M{"keywords": keyword} }).Count() - if (err != nil) { - return false, err - } - exists = (c > 0) - return exists, nil + c, err := gfs.Find(bson.M{"metadata": bson.M{"keywords": keyword}}).Count() + if err != nil { + return false, err + } + exists = (c > 0) + return exists, nil } - diff --git a/hash.go b/hash.go index f2b3499..c51bc61 100644 --- a/hash.go +++ b/hash.go @@ -1,38 +1,37 @@ package main import ( - "crypto/md5" - "fmt" - "hash/adler32" - "io" - "math/rand" - "time" + "crypto/md5" + "fmt" + "hash/adler32" + "io" + "math/rand" + "time" ) func Rand64() int64 { - return rand.Int63() + return rand.Int63() } /* Convinience method for getting md5 sum of a string */ func GetMd5FromString(blob string) (sum []byte) { - h := md5.New() - defer h.Reset() - io.WriteString(h,blob) - return h.Sum(nil) + h := md5.New() + defer h.Reset() + io.WriteString(h, blob) + return h.Sum(nil) } /* Convinience method for getting md5 sum of some bytes */ func GetMd5FromBytes(blob []byte) (sum []byte) { - h := md5.New() - defer h.Reset() - h.Write(blob) - return h.Sum(nil) + h := md5.New() + defer h.Reset() + h.Write(blob) + return h.Sum(nil) } /* get a small, decently unique hash */ func GetSmallHash() (small_hash string) { - h := adler32.New() - io.WriteString(h, fmt.Sprintf("%d", time.Now().Unix())) - return fmt.Sprintf("%X", h.Sum(nil)) + h := adler32.New() + io.WriteString(h, fmt.Sprintf("%d", time.Now().Unix())) + return fmt.Sprintf("%X", h.Sum(nil)) } - diff --git a/hash_test.go b/hash_test.go index a4d4849..f3bb0c3 100644 --- a/hash_test.go +++ b/hash_test.go @@ -1,40 +1,39 @@ package main import ( - "fmt" - "testing" + "fmt" + "testing" ) func TestRand64(t *testing.T) { - var i interface{} - i = Rand64() - v, ok := i.(int64) - if (!ok) { - t.Errorf("Rand64 returned wrong type") - } - if (v < 0) { - t.Errorf("Rand64 returned a too small number [%d]", v) - } + var i interface{} + i = Rand64() + v, ok := i.(int64) + if !ok { + t.Errorf("Rand64 returned wrong type") + } + if v < 0 { + t.Errorf("Rand64 returned a too small number [%d]", v) + } } func TestMd5Bytes(t *testing.T) { - var blob = []byte("Hurp til you Derp") - var expected = "3ef08fa896a154eee3c97f037c9d6dfc" - var actual = fmt.Sprintf("%x", GetMd5FromBytes(blob)) - if (actual != expected) { - t.Errorf("Md5FromBytes sum did not match! %s != %s",actual,expected) - } + var blob = []byte("Hurp til you Derp") + var expected = "3ef08fa896a154eee3c97f037c9d6dfc" + var actual = fmt.Sprintf("%x", GetMd5FromBytes(blob)) + if actual != expected { + t.Errorf("Md5FromBytes sum did not match! %s != %s", actual, expected) + } } func TestMd5String(t *testing.T) { - var blob = "Hurp til you Derp" - var expected = "3ef08fa896a154eee3c97f037c9d6dfc" - var actual = fmt.Sprintf("%x", GetMd5FromString(blob)) - if (actual != expected) { - t.Errorf("Md5FromString sum did not match! %s != %s",actual,expected) - } + var blob = "Hurp til you Derp" + var expected = "3ef08fa896a154eee3c97f037c9d6dfc" + var actual = fmt.Sprintf("%x", GetMd5FromString(blob)) + if actual != expected { + t.Errorf("Md5FromString sum did not match! %s != %s", actual, expected) + } } func TestHash(t *testing.T) { } - diff --git a/imgsrv.go b/imgsrv.go index 0821595..cec633b 100644 --- a/imgsrv.go +++ b/imgsrv.go @@ -8,201 +8,200 @@ package main */ import ( - "flag" - "fmt" - "labix.org/v2/mgo" - "log" - "net/url" - "os" - "path/filepath" + "flag" + "fmt" + "labix.org/v2/mgo" + "log" + "net/url" + "os" + "path/filepath" ) var ( - ConfigFile = fmt.Sprintf("%s/.imgsrv.yaml", os.Getenv("HOME")) + ConfigFile = fmt.Sprintf("%s/.imgsrv.yaml", os.Getenv("HOME")) - DefaultRunAsServer = false - RunAsServer = DefaultRunAsServer + DefaultRunAsServer = false + RunAsServer = DefaultRunAsServer - DefaultServerIP = "0.0.0.0" - ServerIP = DefaultServerIP - DefaultServerPort = "7777" - ServerPort = DefaultServerPort - DefaultMongoHost = "localhost" - MongoHost = DefaultMongoHost - DefaultMongoDB = "filesrv" - MongoDB = DefaultMongoDB - DefaultMongoUsername = "" - MongoUsername = DefaultMongoUsername - DefaultMongoPassword = "" - MongoPassword = DefaultMongoPassword + DefaultServerIP = "0.0.0.0" + ServerIP = DefaultServerIP + DefaultServerPort = "7777" + ServerPort = DefaultServerPort + DefaultMongoHost = "localhost" + MongoHost = DefaultMongoHost + DefaultMongoDB = "filesrv" + MongoDB = DefaultMongoDB + DefaultMongoUsername = "" + MongoUsername = DefaultMongoUsername + DefaultMongoPassword = "" + MongoPassword = DefaultMongoPassword - mongo_session *mgo.Session - images_db *mgo.Database - gfs *mgo.GridFS + mongo_session *mgo.Session + images_db *mgo.Database + gfs *mgo.GridFS - DefaultRemoteHost = "" - RemoteHost = DefaultRemoteHost - PutFile = "" - FetchUrl = "" - FileKeywords = "" + DefaultRemoteHost = "" + RemoteHost = DefaultRemoteHost + PutFile = "" + FetchUrl = "" + FileKeywords = "" ) func main() { - flag.Parse() - for _, arg := range flag.Args() { - // What to do with these floating args ... - log.Printf("%s", arg) - } + flag.Parse() + for _, arg := range flag.Args() { + // What to do with these floating args ... + log.Printf("%s", arg) + } - // loads either default or flag specified config - // to override variables - loadConfiguration(ConfigFile) + // loads either default or flag specified config + // to override variables + loadConfiguration(ConfigFile) - if (len(FetchUrl) > 0) { - file, err := FetchFileFromURL(FetchUrl) - if (err != nil) { - log.Println(err) - return - } - log.Println(file) - } else if (RunAsServer) { - log.Printf("%s", ServerIP) - runServer(ServerIP,ServerPort) - } else { - if (len(RemoteHost) == 0) { - log.Println("Please provide a remotehost!") - return - } - if (len(PutFile) == 0 ) { //&& len(flag.Args()) == 0) { - log.Println("Please provide files to be uploaded!") - return - } - _,basename := filepath.Split(PutFile) - queryParams := "?filename=" + basename - if (len(FileKeywords) > 0) { - queryParams = queryParams + "&keywords=" + FileKeywords - } else { - log.Println("WARN: you didn't provide any keywords :-(") - } - url, err := url.Parse(RemoteHost + "/f/" + queryParams) - if (err != nil) { - log.Println(err) - return - } - log.Printf("POSTing: %s\n", url.String()) - url_path, err := PutFileFromPath(url.String(), PutFile) - if (err != nil) { - log.Println(err) - return - } - log.Printf("New Image!: %s%s\n", RemoteHost, url_path) - } + if len(FetchUrl) > 0 { + file, err := FetchFileFromURL(FetchUrl) + if err != nil { + log.Println(err) + return + } + log.Println(file) + } else if RunAsServer { + log.Printf("%s", ServerIP) + runServer(ServerIP, ServerPort) + } else { + if len(RemoteHost) == 0 { + log.Println("Please provide a remotehost!") + return + } + if len(PutFile) == 0 { //&& len(flag.Args()) == 0) { + log.Println("Please provide files to be uploaded!") + return + } + _, basename := filepath.Split(PutFile) + queryParams := "?filename=" + basename + if len(FileKeywords) > 0 { + queryParams = queryParams + "&keywords=" + FileKeywords + } else { + log.Println("WARN: you didn't provide any keywords :-(") + } + url, err := url.Parse(RemoteHost + "/f/" + queryParams) + if err != nil { + log.Println(err) + return + } + log.Printf("POSTing: %s\n", url.String()) + url_path, err := PutFileFromPath(url.String(), PutFile) + if err != nil { + log.Println(err) + return + } + log.Printf("New Image!: %s%s\n", RemoteHost, url_path) + } } /* http://golang.org/doc/effective_go.html#init */ func init() { - flag.StringVar(&ConfigFile, - "config", - ConfigFile, - "Provide alternate configuration file") + flag.StringVar(&ConfigFile, + "config", + ConfigFile, + "Provide alternate configuration file") - /* Server-side */ - flag.BoolVar(&RunAsServer, - "server", - RunAsServer, - "Run as an image server (defaults to client-side)") - flag.StringVar(&ServerIP, - "ip", - ServerIP, - "IP to bind to (if running as a server)('ip' in the config)") - flag.StringVar(&ServerPort, - "port", - ServerPort, - "Port to listen on (if running as a server)('port' in the config)") + /* Server-side */ + flag.BoolVar(&RunAsServer, + "server", + RunAsServer, + "Run as an image server (defaults to client-side)") + flag.StringVar(&ServerIP, + "ip", + ServerIP, + "IP to bind to (if running as a server)('ip' in the config)") + flag.StringVar(&ServerPort, + "port", + ServerPort, + "Port to listen on (if running as a server)('port' in the config)") - /* MongoDB settings */ - flag.StringVar(&MongoHost, - "mongo-host", - MongoHost, - "Mongo Host to connect to ('mongohost' in the config)") - flag.StringVar(&MongoDB, - "mongo-db", - MongoDB, - "Mongo db to connect to ('mongodb' in the config)") - flag.StringVar(&MongoUsername, - "mongo-username", - MongoUsername, - "Mongo username to auth with (if needed) ('mongousername' in the config)") - flag.StringVar(&MongoPassword, - "mongo-password", - MongoPassword, - "Mongo password to auth with (if needed) ('mongopassword' in the config)") + /* MongoDB settings */ + flag.StringVar(&MongoHost, + "mongo-host", + MongoHost, + "Mongo Host to connect to ('mongohost' in the config)") + flag.StringVar(&MongoDB, + "mongo-db", + MongoDB, + "Mongo db to connect to ('mongodb' in the config)") + flag.StringVar(&MongoUsername, + "mongo-username", + MongoUsername, + "Mongo username to auth with (if needed) ('mongousername' in the config)") + flag.StringVar(&MongoPassword, + "mongo-password", + MongoPassword, + "Mongo password to auth with (if needed) ('mongopassword' in the config)") - /* Client-side */ - flag.StringVar(&FetchUrl, - "fetch", - FetchUrl, - "Just fetch the file from this url") + /* Client-side */ + flag.StringVar(&FetchUrl, + "fetch", + FetchUrl, + "Just fetch the file from this url") - flag.StringVar(&RemoteHost, - "remotehost", - RemoteHost, - "Remote host to get/put files on ('remotehost' in the config)") - flag.StringVar(&PutFile, - "put", - PutFile, - "Put file on remote server (needs -remotehost)") - flag.StringVar(&FileKeywords, - "keywords", - FileKeywords, - "Keywords to associate with file. (comma delimited) (needs -put)") + flag.StringVar(&RemoteHost, + "remotehost", + RemoteHost, + "Remote host to get/put files on ('remotehost' in the config)") + flag.StringVar(&PutFile, + "put", + PutFile, + "Put file on remote server (needs -remotehost)") + flag.StringVar(&FileKeywords, + "keywords", + FileKeywords, + "Keywords to associate with file. (comma delimited) (needs -put)") } func loadConfiguration(filename string) (c Config) { - //log.Printf("Attempting to load config file: %s", filename) - c, err := ReadConfigFile(filename) - if (err != nil) { - //log.Println(err) - return Config{} - } + //log.Printf("Attempting to load config file: %s", filename) + c, err := ReadConfigFile(filename) + if err != nil { + //log.Println(err) + return Config{} + } - cRunAsServer := c.GetBool("server") - cServerIp := c.GetString("ip") - cServerPort := c.GetString("port") - cMongoHost := c.GetString("mongohost") - cMongoDB := c.GetString("mongodb") - cMongoUsername := c.GetString("mongousername") - cMongoPassword := c.GetString("mongopassword") - cRemoteHost := c.GetString("remotehost") + cRunAsServer := c.GetBool("server") + cServerIp := c.GetString("ip") + cServerPort := c.GetString("port") + cMongoHost := c.GetString("mongohost") + cMongoDB := c.GetString("mongodb") + cMongoUsername := c.GetString("mongousername") + cMongoPassword := c.GetString("mongopassword") + cRemoteHost := c.GetString("remotehost") - // Only set variables from config file, - // if they weren't passed as flags - if (DefaultRunAsServer == RunAsServer && cRunAsServer) { - RunAsServer = cRunAsServer - } - if (DefaultServerIP == ServerIP && len(cServerIp) > 0) { - ServerIP = cServerIp - } - if (DefaultServerPort == ServerPort && len(cServerPort) > 0) { - ServerPort = cServerPort - } - if (DefaultMongoHost == MongoHost && len(cMongoHost) > 0) { - MongoHost = cMongoHost - } - if (DefaultMongoDB == MongoDB && len(cMongoDB) > 0) { - MongoDB = cMongoDB - } - if (DefaultMongoUsername == MongoUsername && len(cMongoUsername) > 0) { - MongoUsername = cMongoUsername - } - if (DefaultMongoPassword == MongoPassword && len(cMongoPassword) > 0) { - MongoPassword = cMongoPassword - } - if (DefaultRemoteHost == RemoteHost && len(cRemoteHost) > 0) { - RemoteHost = cRemoteHost - } + // Only set variables from config file, + // if they weren't passed as flags + if DefaultRunAsServer == RunAsServer && cRunAsServer { + RunAsServer = cRunAsServer + } + if DefaultServerIP == ServerIP && len(cServerIp) > 0 { + ServerIP = cServerIp + } + if DefaultServerPort == ServerPort && len(cServerPort) > 0 { + ServerPort = cServerPort + } + if DefaultMongoHost == MongoHost && len(cMongoHost) > 0 { + MongoHost = cMongoHost + } + if DefaultMongoDB == MongoDB && len(cMongoDB) > 0 { + MongoDB = cMongoDB + } + if DefaultMongoUsername == MongoUsername && len(cMongoUsername) > 0 { + MongoUsername = cMongoUsername + } + if DefaultMongoPassword == MongoPassword && len(cMongoPassword) > 0 { + MongoPassword = cMongoPassword + } + if DefaultRemoteHost == RemoteHost && len(cRemoteHost) > 0 { + RemoteHost = cRemoteHost + } - return c + return c } - diff --git a/layouts.go b/layouts.go index bbf9bf2..b2e7a03 100644 --- a/layouts.go +++ b/layouts.go @@ -1,14 +1,13 @@ package main import ( - "fmt" - "io" - "text/template" + "fmt" + "io" + "text/template" ) var emptyInterface interface{} - var headTemplate = template.Must(template.New("head").Parse(headTemplateHTML)) var headTemplateHTML = ` @@ -128,86 +127,76 @@ var listTemplateHTML = ` ` func UrliePage(w io.Writer) (err error) { - err = headTemplate.Execute(w, map[string]string{"title" : "FileSrv :: URLie"}) - if (err != nil) { - return err - } - err = navbarTemplate.Execute(w, nil) - if (err != nil) { - return err - } - err = containerBeginTemplate.Execute(w, nil) - if (err != nil) { - return err - } - err = formGetUrlTemplate.Execute(w, &emptyInterface) - if (err != nil) { - return err - } - err = tailTemplate.Execute(w, map[string]string{"footer" : fmt.Sprintf("Version: %s", VERSION)}) - if (err != nil) { - return err - } - return + err = headTemplate.Execute(w, map[string]string{"title": "FileSrv :: URLie"}) + if err != nil { + return err + } + err = navbarTemplate.Execute(w, nil) + if err != nil { + return err + } + err = containerBeginTemplate.Execute(w, nil) + if err != nil { + return err + } + err = formGetUrlTemplate.Execute(w, &emptyInterface) + if err != nil { + return err + } + err = tailTemplate.Execute(w, map[string]string{"footer": fmt.Sprintf("Version: %s", VERSION)}) + if err != nil { + return err + } + return } func UploadPage(w io.Writer) (err error) { - err = headTemplate.Execute(w, map[string]string{"title" : "FileSrv :: Upload"}) - if (err != nil) { - return err - } - err = navbarTemplate.Execute(w, nil) - if (err != nil) { - return err - } - err = containerBeginTemplate.Execute(w, nil) - if (err != nil) { - return err - } - err = formFileUploadTemplate.Execute(w, &emptyInterface) - if (err != nil) { - return err - } - err = tailTemplate.Execute(w, map[string]string{"footer" : fmt.Sprintf("Version: %s", VERSION)}) - if (err != nil) { - return err - } - return + err = headTemplate.Execute(w, map[string]string{"title": "FileSrv :: Upload"}) + if err != nil { + return err + } + err = navbarTemplate.Execute(w, nil) + if err != nil { + return err + } + err = containerBeginTemplate.Execute(w, nil) + if err != nil { + return err + } + err = formFileUploadTemplate.Execute(w, &emptyInterface) + if err != nil { + return err + } + err = tailTemplate.Execute(w, map[string]string{"footer": fmt.Sprintf("Version: %s", VERSION)}) + if err != nil { + return err + } + return } func ListFilesPage(w io.Writer, files []File) (err error) { - err = headTemplate.Execute(w, map[string]string{"title" : "FileSrv"}) - if (err != nil) { - return err - } - err = navbarTemplate.Execute(w, nil) - if (err != nil) { - return err - } - err = containerBeginTemplate.Execute(w, nil) - if (err != nil) { - return err - } - err = listTemplate.Execute(w, files) - if (err != nil) { - return err - } - err = tailTemplate.Execute(w, map[string]string{"footer" : fmt.Sprintf("Version: %s", VERSION)}) - if (err != nil) { - return err - } - return + err = headTemplate.Execute(w, map[string]string{"title": "FileSrv"}) + if err != nil { + return err + } + err = navbarTemplate.Execute(w, nil) + if err != nil { + return err + } + err = containerBeginTemplate.Execute(w, nil) + if err != nil { + return err + } + err = listTemplate.Execute(w, files) + if err != nil { + return err + } + err = tailTemplate.Execute(w, map[string]string{"footer": fmt.Sprintf("Version: %s", VERSION)}) + if err != nil { + return err + } + return } - - - - - - - - - - var bootstrapCSS = ` /*! * Bootstrap v2.2.2 @@ -6249,5 +6238,3 @@ a.badge:hover { position: fixed; } ` - - diff --git a/server.go b/server.go index 34215d1..6707b50 100644 --- a/server.go +++ b/server.go @@ -1,77 +1,114 @@ package main import ( - "fmt" - "io" - "labix.org/v2/mgo" - "labix.org/v2/mgo/bson" - "log" - "mime" - "net/http" - "os" - "path/filepath" - "strings" - "time" + "fmt" + "io" + "labix.org/v2/mgo" + "labix.org/v2/mgo/bson" + "log" + "mime" + "net/http" + "os" + "path/filepath" + "strings" + "time" ) var defaultPageLimit int = 25 +/* Run as the image server */ +func runServer(ip, port string) { + var addr = fmt.Sprintf("%s:%s", ip, port) + + initMongo() + defer mongo_session.Close() + + http.HandleFunc("/", routeRoot) + http.HandleFunc("/assets/", routeAssets) + http.HandleFunc("/upload", routeUpload) + http.HandleFunc("/urlie", routeGetFromUrl) + http.HandleFunc("/all", routeAll) + http.HandleFunc("/f/", routeFiles) + http.HandleFunc("/k/", routeKeywords) + http.HandleFunc("/ip/", routeIPs) + http.HandleFunc("/ext/", routeExt) + http.HandleFunc("/md5/", routeMD5s) + + log.Printf("Serving on %s ...", addr) + log.Fatal(http.ListenAndServe(addr, nil)) +} + +func initMongo() { + mongo_session, err := mgo.Dial(MongoHost) + if err != nil { + log.Panic(err) + } + images_db = mongo_session.DB(MongoDB) + if len(MongoUsername) > 0 && len(MongoPassword) > 0 { + err = images_db.Login(MongoUsername, MongoPassword) + if err != nil { + log.Panic(err) + } + } + gfs = images_db.GridFS("fs") +} + func serverErr(w http.ResponseWriter, r *http.Request, e error) { - log.Printf("Error: %s", e) - LogRequest(r,503) - fmt.Fprintf(w,"Error: %s", e) - http.Error(w, "Service Unavailable", 503) - return + log.Printf("Error: %s", e) + LogRequest(r, 503) + fmt.Fprintf(w, "Error: %s", e) + http.Error(w, "Service Unavailable", 503) + return } /* return a for a given filename and root is the relavtive base of the explicit link. */ func linkToFile(root string, filename string) (html string) { - return fmt.Sprintf("%s", - root, - filename, - filename) + return fmt.Sprintf("%s", + root, + filename, + filename) } /* return the sections of the URI Path. This will disregard the leading '/' */ func chunkURI(uri string) (chunks []string) { - var str string - if (uri[0] == '/') { - str = uri[1:] - } else { - str = uri - } - return strings.Split(str, "/") + var str string + if uri[0] == '/' { + str = uri[1:] + } else { + str = uri + } + return strings.Split(str, "/") } /* kindof a common log type output */ func LogRequest(r *http.Request, statusCode int) { - var addr string - var user_agent string + var addr string + var user_agent string - user_agent = "" - addr = r.RemoteAddr + user_agent = "" + addr = r.RemoteAddr - for k, v := range r.Header { - if k == "User-Agent" { - user_agent = strings.Join(v, " ") - } - if k == "X-Forwarded-For" { - addr = strings.Join(v," ") - } - } + for k, v := range r.Header { + if k == "User-Agent" { + user_agent = strings.Join(v, " ") + } + if k == "X-Forwarded-For" { + addr = strings.Join(v, " ") + } + } - fmt.Printf("%s - - [%s] \"%s %s\" \"%s\" %d %d\n", - addr, - time.Now(), - r.Method, - r.URL.Path, - user_agent, - statusCode, - r.ContentLength ) + fmt.Printf("%s - - [%s] \"%s %s\" \"%s\" %d %d\n", + addr, + time.Now(), + r.Method, + r.URL.Path, + user_agent, + statusCode, + r.ContentLength) } /* @@ -80,47 +117,47 @@ func LogRequest(r *http.Request, statusCode int) { */ // Show a page of most recent images, and tags, and uploaders ... func routeFilesGET(w http.ResponseWriter, r *http.Request) { - uriChunks := chunkURI(r.URL.Path) - if ( len(uriChunks) > 2 ) { - LogRequest(r,404) - http.NotFound(w,r) - return - } + uriChunks := chunkURI(r.URL.Path) + if len(uriChunks) > 2 { + LogRequest(r, 404) + http.NotFound(w, r) + return + } - if (len(uriChunks) == 2 && len(uriChunks[1]) > 0) { - log.Printf("Searching for [%s] ...", uriChunks[1]) - query := gfs.Find(bson.M{"filename": uriChunks[1] }) + if len(uriChunks) == 2 && len(uriChunks[1]) > 0 { + log.Printf("Searching for [%s] ...", uriChunks[1]) + query := gfs.Find(bson.M{"filename": uriChunks[1]}) - c, err := query.Count() - // preliminary checks, if they've passed an image name - if (err != nil) { - serverErr(w,r,err) - return - } - log.Printf("Results for [%s] = %d", uriChunks[1], c) - if (c == 0) { - LogRequest(r,404) - http.NotFound(w,r) - return - } + c, err := query.Count() + // preliminary checks, if they've passed an image name + if err != nil { + serverErr(w, r, err) + return + } + log.Printf("Results for [%s] = %d", uriChunks[1], c) + if c == 0 { + LogRequest(r, 404) + http.NotFound(w, r) + return + } - ext := filepath.Ext(uriChunks[1]) - w.Header().Set("Content-Type", mime.TypeByExtension(ext)) - w.Header().Set("Cache-Control", "max-age=315360000") - w.WriteHeader(http.StatusOK) + ext := filepath.Ext(uriChunks[1]) + w.Header().Set("Content-Type", mime.TypeByExtension(ext)) + w.Header().Set("Cache-Control", "max-age=315360000") + w.WriteHeader(http.StatusOK) - file, err := gfs.Open(uriChunks[1]) - if (err != nil) { - serverErr(w,r,err) - return - } + file, err := gfs.Open(uriChunks[1]) + if err != nil { + serverErr(w, r, err) + return + } - io.Copy(w,file) // send the contents of the file in the body + io.Copy(w, file) // send the contents of the file in the body - } else { - // TODO show a list of recent uploads? ... - } - LogRequest(r,200) + } else { + // TODO show a list of recent uploads? ... + } + LogRequest(r, 200) } /* @@ -130,299 +167,299 @@ func routeFilesGET(w http.ResponseWriter, r *http.Request) { // add keywords from the parameters // look for an image in the r.Body func routeFilesPOST(w http.ResponseWriter, r *http.Request) { - uriChunks := chunkURI(r.URL.Path) - if (len(uriChunks) > 2 && - ((len(uriChunks) == 2 && len(uriChunks[1]) == 0) && - len(r.URL.RawQuery) == 0 )) { - LogRequest(r,403) - http.Error(w, "Not Acceptable", 403) - return - } + uriChunks := chunkURI(r.URL.Path) + if len(uriChunks) > 2 && + ((len(uriChunks) == 2 && len(uriChunks[1]) == 0) && + len(r.URL.RawQuery) == 0) { + LogRequest(r, 403) + http.Error(w, "Not Acceptable", 403) + return + } - var filename string - info := Info{ - Ip: r.RemoteAddr, - Random: Rand64(), - TimeStamp: time.Now(), - } + var filename string + info := Info{ + Ip: r.RemoteAddr, + Random: Rand64(), + TimeStamp: time.Now(), + } - filename = r.FormValue("filename") - if (len(filename) == 0 && len(uriChunks) == 2 && len(uriChunks[1]) != 0) { - filename = uriChunks[1] - } - log.Printf("%s\n", filename) + filename = r.FormValue("filename") + if len(filename) == 0 && len(uriChunks) == 2 && len(uriChunks[1]) != 0 { + filename = uriChunks[1] + } + log.Printf("%s\n", filename) - var p_ext string - p_ext = r.FormValue("ext") - if (len(filename) > 0 && len(p_ext) == 0) { - p_ext = filepath.Ext(filename) - } else if (len(p_ext) > 0 && strings.HasPrefix(p_ext, ".")) { - p_ext = fmt.Sprintf(".%s", p_ext) - } + var p_ext string + p_ext = r.FormValue("ext") + if len(filename) > 0 && len(p_ext) == 0 { + p_ext = filepath.Ext(filename) + } else if len(p_ext) > 0 && strings.HasPrefix(p_ext, ".") { + p_ext = fmt.Sprintf(".%s", p_ext) + } - for _, word := range []string{ - "k", "key", "keyword", - "keys", "keywords", - } { - v := r.FormValue(word) - if (len(v) > 0) { - if (strings.Contains(v, ",")) { - info.Keywords = append(info.Keywords, strings.Split(v,",")...) - } else { - info.Keywords = append(info.Keywords, v) - } - } - } + for _, word := range []string{ + "k", "key", "keyword", + "keys", "keywords", + } { + v := r.FormValue(word) + if len(v) > 0 { + if strings.Contains(v, ",") { + info.Keywords = append(info.Keywords, strings.Split(v, ",")...) + } else { + info.Keywords = append(info.Keywords, v) + } + } + } - if (len(filename) == 0) { - str := GetSmallHash() - if (len(p_ext) == 0) { - filename = fmt.Sprintf("%s.jpg", str) - } else { - filename = fmt.Sprintf("%s%s", str, p_ext) - } - } + if len(filename) == 0 { + str := GetSmallHash() + if len(p_ext) == 0 { + filename = fmt.Sprintf("%s.jpg", str) + } else { + filename = fmt.Sprintf("%s%s", str, p_ext) + } + } - exists, err := HasFileByFilename(filename) - if (err == nil && !exists) { - file, err := gfs.Create(filename) - defer file.Close() - if (err != nil) { - serverErr(w,r,err) - return - } + exists, err := HasFileByFilename(filename) + if err == nil && !exists { + file, err := gfs.Create(filename) + defer file.Close() + if err != nil { + serverErr(w, r, err) + return + } - file.SetMeta(&info) + file.SetMeta(&info) - // copy the request body into the gfs file - n, err := io.Copy(file, r.Body) - if (err != nil) { - serverErr(w,r,err) - return - } + // copy the request body into the gfs file + n, err := io.Copy(file, r.Body) + if err != nil { + serverErr(w, r, err) + return + } - if (n != r.ContentLength) { - log.Printf("WARNING: [%s] content-length (%d), content written (%d)", - filename, - r.ContentLength, - n) - } - } else if (exists) { - if (r.Method == "PUT") { - // TODO nothing will get here presently. Workflow needs more review - file, err := gfs.Open(filename) - defer file.Close() - if (err != nil) { - serverErr(w,r,err) - return - } + if n != r.ContentLength { + log.Printf("WARNING: [%s] content-length (%d), content written (%d)", + filename, + r.ContentLength, + n) + } + } else if exists { + if r.Method == "PUT" { + // TODO nothing will get here presently. Workflow needs more review + file, err := gfs.Open(filename) + defer file.Close() + if err != nil { + serverErr(w, r, err) + return + } - var mInfo Info - err = file.GetMeta(&mInfo) - if (err != nil) { - log.Printf("ERROR: failed to get metadata for %s. %s\n", filename, err) - } - mInfo.Keywords = append(mInfo.Keywords, info.Keywords...) - file.SetMeta(&mInfo) - } else { - log.Printf("[%s] already exists", filename) - } - } else { - serverErr(w,r,err) - return - } + var mInfo Info + err = file.GetMeta(&mInfo) + if err != nil { + log.Printf("ERROR: failed to get metadata for %s. %s\n", filename, err) + } + mInfo.Keywords = append(mInfo.Keywords, info.Keywords...) + file.SetMeta(&mInfo) + } else { + log.Printf("[%s] already exists", filename) + } + } else { + serverErr(w, r, err) + return + } - if (strings.Contains(r.Header.Get("Accept"), "text/html")) { - io.WriteString(w, - fmt.Sprintf("/f/%s\n", filename, filename)) - } else { - io.WriteString(w, fmt.Sprintf("/f/%s\n", filename)) - } + if strings.Contains(r.Header.Get("Accept"), "text/html") { + io.WriteString(w, + fmt.Sprintf("/f/%s\n", filename, filename)) + } else { + io.WriteString(w, fmt.Sprintf("/f/%s\n", filename)) + } - LogRequest(r,200) + LogRequest(r, 200) } func routeFilesPUT(w http.ResponseWriter, r *http.Request) { - // update the file by the name in the path and/or parameter? - // update/add keywords from the parameters - // look for an image in the r.Body - LogRequest(r,200) + // update the file by the name in the path and/or parameter? + // update/add keywords from the parameters + // look for an image in the r.Body + LogRequest(r, 200) } func routeFilesDELETE(w http.ResponseWriter, r *http.Request) { - uriChunks := chunkURI(r.URL.Path) - if ( len(uriChunks) > 2 ) { - LogRequest(r,404) - http.NotFound(w,r) - return - } else if (len(uriChunks) == 2 && len(uriChunks[1]) == 0) { - } - exists, err := HasFileByFilename(uriChunks[1]) - if (err != nil) { - serverErr(w,r,err) - return - } - if (exists) { - err = gfs.Remove(uriChunks[1]) - if (err != nil) { - serverErr(w,r,err) - return - } - LogRequest(r,200) - } else { - LogRequest(r,404) - http.NotFound(w,r) - } - // delete the name in the path and/or parameter? + uriChunks := chunkURI(r.URL.Path) + if len(uriChunks) > 2 { + LogRequest(r, 404) + http.NotFound(w, r) + return + } else if len(uriChunks) == 2 && len(uriChunks[1]) == 0 { + } + exists, err := HasFileByFilename(uriChunks[1]) + if err != nil { + serverErr(w, r, err) + return + } + if exists { + err = gfs.Remove(uriChunks[1]) + if err != nil { + serverErr(w, r, err) + return + } + LogRequest(r, 200) + } else { + LogRequest(r, 404) + http.NotFound(w, r) + } + // delete the name in the path and/or parameter? } func routeFiles(w http.ResponseWriter, r *http.Request) { - switch { - case r.Method == "GET": - routeFilesGET(w,r) - case r.Method == "PUT": - routeFilesPUT(w,r) - case r.Method == "POST": - routeFilesPOST(w,r) - case r.Method == "DELETE": - routeFilesDELETE(w,r) - default: - LogRequest(r,404) - http.NotFound(w,r) - return - } + switch { + case r.Method == "GET": + routeFilesGET(w, r) + case r.Method == "PUT": + routeFilesPUT(w, r) + case r.Method == "POST": + routeFilesPOST(w, r) + case r.Method == "DELETE": + routeFilesDELETE(w, r) + default: + LogRequest(r, 404) + http.NotFound(w, r) + return + } } func routeRoot(w http.ResponseWriter, r *http.Request) { - if (r.Method != "GET") { - LogRequest(r,404) - http.NotFound(w,r) - return - } - // Show a page of most recent images, and tags, and uploaders ... + if r.Method != "GET" { + LogRequest(r, 404) + http.NotFound(w, r) + return + } + // Show a page of most recent images, and tags, and uploaders ... - w.Header().Set("Content-Type", "text/html") - //iter := gfs.Find(bson.M{"uploadDate": bson.M{"$gt": time.Now().Add(-time.Hour)}}).Limit(defaultPageLimit).Iter() - var files []File - err := gfs.Find(nil).Sort("-metadata.timestamp").Limit(defaultPageLimit).All(&files) - if (err != nil) { - serverErr(w,r,err) - return - } - ListFilesPage(w,files) - LogRequest(r,200) + w.Header().Set("Content-Type", "text/html") + //iter := gfs.Find(bson.M{"uploadDate": bson.M{"$gt": time.Now().Add(-time.Hour)}}).Limit(defaultPageLimit).Iter() + var files []File + err := gfs.Find(nil).Sort("-metadata.timestamp").Limit(defaultPageLimit).All(&files) + if err != nil { + serverErr(w, r, err) + return + } + ListFilesPage(w, files) + LogRequest(r, 200) } func routeAll(w http.ResponseWriter, r *http.Request) { - if (r.Method != "GET") { - LogRequest(r,404) - http.NotFound(w,r) - return - } + if r.Method != "GET" { + LogRequest(r, 404) + http.NotFound(w, r) + return + } - w.Header().Set("Content-Type", "text/html") + w.Header().Set("Content-Type", "text/html") - // Show a page of all the images - var files []File - err := gfs.Find(nil).All(&files) - if (err != nil) { - serverErr(w,r,err) - return - } - ListFilesPage(w,files) - LogRequest(r,200) + // Show a page of all the images + var files []File + err := gfs.Find(nil).All(&files) + if err != nil { + serverErr(w, r, err) + return + } + ListFilesPage(w, files) + LogRequest(r, 200) } /* GET /k/ GET /k/:name GET /k/:name/r - + Show a page of all the keyword tags, and then the images If /k/:name/r then show a random image by keyword name Otherwise 404 */ func routeKeywords(w http.ResponseWriter, r *http.Request) { - uriChunks := chunkURI(r.URL.Path) - if (r.Method != "GET" || - len(uriChunks) > 3 || - (len(uriChunks) == 3 && uriChunks[2] != "r")) { - LogRequest(r,404) - http.NotFound(w,r) - return - } else if (len(uriChunks) == 1 || (len(uriChunks) == 2 && len(uriChunks[1]) == 0)) { - routeRoot(w,r) - return - } + uriChunks := chunkURI(r.URL.Path) + if r.Method != "GET" || + len(uriChunks) > 3 || + (len(uriChunks) == 3 && uriChunks[2] != "r") { + LogRequest(r, 404) + http.NotFound(w, r) + return + } else if len(uriChunks) == 1 || (len(uriChunks) == 2 && len(uriChunks[1]) == 0) { + routeRoot(w, r) + return + } - log.Printf("K: %s (%d)", uriChunks, len(uriChunks)) + log.Printf("K: %s (%d)", uriChunks, len(uriChunks)) - var iter *mgo.Iter - if (uriChunks[len(uriChunks)-1] == "r") { - // TODO determine how to show a random image by keyword ... - log.Println("random isn't built yet") - LogRequest(r,404) - return - } else if (len(uriChunks) == 2) { - log.Println(uriChunks[1]) - iter = gfs.Find(bson.M{"metadata.keywords": uriChunks[1] }).Sort("-metadata.timestamp").Limit(defaultPageLimit).Iter() - } + var iter *mgo.Iter + if uriChunks[len(uriChunks)-1] == "r" { + // TODO determine how to show a random image by keyword ... + log.Println("random isn't built yet") + LogRequest(r, 404) + return + } else if len(uriChunks) == 2 { + log.Println(uriChunks[1]) + iter = gfs.Find(bson.M{"metadata.keywords": uriChunks[1]}).Sort("-metadata.timestamp").Limit(defaultPageLimit).Iter() + } - var files []File - err := iter.All(&files) - if (err != nil) { - serverErr(w,r,err) - return - } - log.Println(len(files)) - ListFilesPage(w, files) + var files []File + err := iter.All(&files) + if err != nil { + serverErr(w, r, err) + return + } + log.Println(len(files)) + ListFilesPage(w, files) - LogRequest(r,200) + LogRequest(r, 200) } func routeMD5s(w http.ResponseWriter, r *http.Request) { - uriChunks := chunkURI(r.URL.Path) - if (r.Method != "GET") { - LogRequest(r,404) - http.NotFound(w,r) - return - } else if (len(uriChunks) != 2) { - // they didn't give an MD5, re-route - routeRoot(w,r) - return - } + uriChunks := chunkURI(r.URL.Path) + if r.Method != "GET" { + LogRequest(r, 404) + http.NotFound(w, r) + return + } else if len(uriChunks) != 2 { + // they didn't give an MD5, re-route + routeRoot(w, r) + return + } - var files []File - err := gfs.Find(bson.M{"md5": uriChunks[1]}).Sort("-metadata.timestamp").Limit(defaultPageLimit).All(&files) - if (err != nil) { - serverErr(w,r,err) - return - } - ListFilesPage(w, files) + var files []File + err := gfs.Find(bson.M{"md5": uriChunks[1]}).Sort("-metadata.timestamp").Limit(defaultPageLimit).All(&files) + if err != nil { + serverErr(w, r, err) + return + } + ListFilesPage(w, files) - LogRequest(r,200) + LogRequest(r, 200) } // Show a page of file extensions, and allow paging by ext func routeExt(w http.ResponseWriter, r *http.Request) { - if (r.Method != "GET") { - LogRequest(r,404) - http.NotFound(w,r) - return - } + if r.Method != "GET" { + LogRequest(r, 404) + http.NotFound(w, r) + return + } - LogRequest(r,200) + LogRequest(r, 200) } // Show a page of all the uploader's IPs, and the images func routeIPs(w http.ResponseWriter, r *http.Request) { - if (r.Method != "GET") { - LogRequest(r,404) - http.NotFound(w,r) - return - } + if r.Method != "GET" { + LogRequest(r, 404) + http.NotFound(w, r) + return + } - LogRequest(r,200) + LogRequest(r, 200) } /* @@ -430,78 +467,78 @@ func routeIPs(w http.ResponseWriter, r *http.Request) { POST /urlie */ func routeGetFromUrl(w http.ResponseWriter, r *http.Request) { - if (r.Method == "POST") { - info := Info{ - Ip: r.RemoteAddr, - Random: Rand64(), - TimeStamp: time.Now(), - } - log.Println(info) + if r.Method == "POST" { + info := Info{ + Ip: r.RemoteAddr, + Random: Rand64(), + TimeStamp: time.Now(), + } + log.Println(info) - err := r.ParseMultipartForm(1024*5) - if (err != nil) { - serverErr(w,r,err) - return - } - log.Printf("%q", r.MultipartForm.Value) - var local_filename string - for k, v := range r.MultipartForm.Value { - if (k == "keywords") { - info.Keywords = append(info.Keywords, strings.Split(v[0],",")...) - } else if (k == "url") { - local_filename, err = FetchFileFromURL(v[0]) - if (err != nil) { - serverErr(w,r,err) - return - } else if (len(local_filename) == 0) { - LogRequest(r,404) - http.NotFound(w,r) - return - } - // Yay, hopefully we got an image! - } else { - log.Printf("WARN: not sure what to do with param [%s = %s]", k,v) - } - } - exists, err := HasFileByFilename(local_filename) - if (err == nil && !exists) { - file, err := gfs.Create(filepath.Base(local_filename)) - defer file.Close() - if (err != nil) { - serverErr(w,r,err) - return - } + err := r.ParseMultipartForm(1024 * 5) + if err != nil { + serverErr(w, r, err) + return + } + log.Printf("%q", r.MultipartForm.Value) + var local_filename string + for k, v := range r.MultipartForm.Value { + if k == "keywords" { + info.Keywords = append(info.Keywords, strings.Split(v[0], ",")...) + } else if k == "url" { + local_filename, err = FetchFileFromURL(v[0]) + if err != nil { + serverErr(w, r, err) + return + } else if len(local_filename) == 0 { + LogRequest(r, 404) + http.NotFound(w, r) + return + } + // Yay, hopefully we got an image! + } else { + log.Printf("WARN: not sure what to do with param [%s = %s]", k, v) + } + } + exists, err := HasFileByFilename(local_filename) + if err == nil && !exists { + file, err := gfs.Create(filepath.Base(local_filename)) + defer file.Close() + if err != nil { + serverErr(w, r, err) + return + } - local_fh, err := os.Open(local_filename) - defer local_fh.Close() - if (err != nil) { - serverErr(w,r,err) - return - } + local_fh, err := os.Open(local_filename) + defer local_fh.Close() + if err != nil { + serverErr(w, r, err) + return + } - file.SetMeta(&info) + file.SetMeta(&info) - // copy the request body into the gfs file - n, err := io.Copy(file, local_fh) - if (err != nil) { - serverErr(w,r,err) - return - } - log.Printf("Wrote [%d] bytes from %s", n, local_filename) + // copy the request body into the gfs file + n, err := io.Copy(file, local_fh) + if err != nil { + serverErr(w, r, err) + return + } + log.Printf("Wrote [%d] bytes from %s", n, local_filename) - http.Redirect(w,r,fmt.Sprintf("/f/%s", filepath.Base(local_filename)), 302) - } else { - serverErr(w,r,err) - return - } - } else if (r.Method == "GET") { - UrliePage(w) - } else { - LogRequest(r,404) - http.NotFound(w,r) - return - } - LogRequest(r,200) + http.Redirect(w, r, fmt.Sprintf("/f/%s", filepath.Base(local_filename)), 302) + } else { + serverErr(w, r, err) + return + } + } else if r.Method == "GET" { + UrliePage(w) + } else { + LogRequest(r, 404) + http.NotFound(w, r) + return + } + LogRequest(r, 200) } /* @@ -509,125 +546,87 @@ func routeGetFromUrl(w http.ResponseWriter, r *http.Request) { POST /upload */ func routeUpload(w http.ResponseWriter, r *http.Request) { - if (r.Method == "POST") { - info := Info{ - Ip: r.RemoteAddr, - Random: Rand64(), - TimeStamp: time.Now(), - } + if r.Method == "POST" { + info := Info{ + Ip: r.RemoteAddr, + Random: Rand64(), + TimeStamp: time.Now(), + } - // handle the form posting to this route - err := r.ParseMultipartForm(1024*5) - if (err != nil) { - serverErr(w,r,err) - return - } - log.Printf("%q", r.MultipartForm.Value) - for k, v := range r.MultipartForm.Value { - if (k == "keywords") { - info.Keywords = append(info.Keywords, strings.Split(v[0],",")...) - } else { - log.Printf("WARN: not sure what to do with param [%s = %s]", k,v) - } - } + // handle the form posting to this route + err := r.ParseMultipartForm(1024 * 5) + if err != nil { + serverErr(w, r, err) + return + } + log.Printf("%q", r.MultipartForm.Value) + for k, v := range r.MultipartForm.Value { + if k == "keywords" { + info.Keywords = append(info.Keywords, strings.Split(v[0], ",")...) + } else { + log.Printf("WARN: not sure what to do with param [%s = %s]", k, v) + } + } - filehdr := r.MultipartForm.File["filename"][0] - exists, err := HasFileByFilename(filehdr.Filename) - if (err != nil) { - serverErr(w,r,err) - return - } else if (err == nil && !exists) { - file, err := gfs.Create(filehdr.Filename) - defer file.Close() - if (err != nil) { - serverErr(w,r,err) - return - } - file.SetMeta(&info) + filehdr := r.MultipartForm.File["filename"][0] + exists, err := HasFileByFilename(filehdr.Filename) + if err != nil { + serverErr(w, r, err) + return + } else if err == nil && !exists { + file, err := gfs.Create(filehdr.Filename) + defer file.Close() + if err != nil { + serverErr(w, r, err) + return + } + file.SetMeta(&info) - multiFile, err := filehdr.Open() - if (err != nil) { - log.Println(err) - return - } - n, err := io.Copy(file, multiFile) - if (err != nil) { - serverErr(w,r,err) - return - } - if (n != r.ContentLength) { - log.Printf("WARNING: [%s] content-length (%d), content written (%d)", - filehdr.Filename, - r.ContentLength, - n) - } + multiFile, err := filehdr.Open() + if err != nil { + log.Println(err) + return + } + n, err := io.Copy(file, multiFile) + if err != nil { + serverErr(w, r, err) + return + } + if n != r.ContentLength { + log.Printf("WARNING: [%s] content-length (%d), content written (%d)", + filehdr.Filename, + r.ContentLength, + n) + } - http.Redirect(w,r,fmt.Sprintf("/f/%s", filehdr.Filename), 302) - } else if (exists) { - // print some message about the file already existing - } else { - serverErr(w,r,err) - return - } - } else if (r.Method == "GET") { - // Show the upload form - UploadPage(w) - } else { - LogRequest(r,404) - http.NotFound(w,r) - return - } - LogRequest(r,200) // if we make it this far, then log success + http.Redirect(w, r, fmt.Sprintf("/f/%s", filehdr.Filename), 302) + } else if exists { + // print some message about the file already existing + } else { + serverErr(w, r, err) + return + } + } else if r.Method == "GET" { + // Show the upload form + UploadPage(w) + } else { + LogRequest(r, 404) + http.NotFound(w, r) + return + } + LogRequest(r, 200) // if we make it this far, then log success } func routeAssets(w http.ResponseWriter, r *http.Request) { - path, err := filepath.Rel("/assets", r.URL.Path) - if (err != nil) { - serverErr(w,r,err) - return - } + path, err := filepath.Rel("/assets", r.URL.Path) + if err != nil { + serverErr(w, r, err) + return + } - switch path { - case "bootstrap.css": - fmt.Fprint(w,bootstrapCSS) - w.Header().Set("Content-Type", "text/css") - } + switch path { + case "bootstrap.css": + fmt.Fprint(w, bootstrapCSS) + w.Header().Set("Content-Type", "text/css") + } } - -func initMongo() { - mongo_session, err := mgo.Dial(MongoHost) - if err != nil { - log.Panic(err) - } - images_db = mongo_session.DB(MongoDB) - if (len(MongoUsername) > 0 && len(MongoPassword) > 0) { - err = images_db.Login(MongoUsername, MongoPassword) - if (err != nil) { - log.Panic(err) - } - } - gfs = images_db.GridFS("fs") -} - -/* Run as the image server */ -func runServer(ip, port string) { - var addr = fmt.Sprintf("%s:%s", ip, port) - - initMongo() - defer mongo_session.Close() - - http.HandleFunc("/", routeRoot) - http.HandleFunc("/assets/", routeAssets) - http.HandleFunc("/upload", routeUpload) - http.HandleFunc("/urlie", routeGetFromUrl) - http.HandleFunc("/all", routeAll) - http.HandleFunc("/f/", routeFiles) - http.HandleFunc("/k/", routeKeywords) - http.HandleFunc("/ip/", routeIPs) - http.HandleFunc("/ext/", routeExt) - http.HandleFunc("/md5/", routeMD5s) - - log.Printf("Serving on %s ...", addr) - log.Fatal(http.ListenAndServe(addr, nil)) -} - diff --git a/types.go b/types.go index fe7fb6f..2ce6904 100644 --- a/types.go +++ b/types.go @@ -3,18 +3,18 @@ package main import "time" type Info struct { - Keywords []string // tags - Ip string // who uploaded it - Random int64 - TimeStamp time.Time "timestamp,omitempty" + Keywords []string // tags + Ip string // who uploaded it + Random int64 + TimeStamp time.Time "timestamp,omitempty" } type File struct { - Metadata Info ",omitempty" - Md5 string - ChunkSize int - UploadDate time.Time - Length int64 - Filename string ",omitempty" - ContentType string "contentType,omitempty" + Metadata Info ",omitempty" + Md5 string + ChunkSize int + UploadDate time.Time + Length int64 + Filename string ",omitempty" + ContentType string "contentType,omitempty" } diff --git a/version.go b/version.go index 1833ddf..b087395 100644 --- a/version.go +++ b/version.go @@ -1,12 +1,12 @@ package main import ( - "fmt" + "fmt" ) var ( - MAJOR int = 1 - MINOR int = 0 - TINY int = 0 - VERSION string = fmt.Sprintf("%d.%d.%d", MAJOR, MINOR, TINY) + MAJOR int = 1 + MINOR int = 0 + TINY int = 0 + VERSION string = fmt.Sprintf("%d.%d.%d", MAJOR, MINOR, TINY) )