func main() {
configFile, err := ioutil.ReadFile("config.json")
if err != nil {
panic("Error opening config file: " + err.Error())
}
var c config
err = json.Unmarshal(configFile, &c)
if err != nil {
panic(err)
}
var db *dropbox.Dropbox
// 1. Create a new dropbox object.
db = dropbox.NewDropbox()
// 2. Provide your clientid and clientsecret (see prerequisite).
db.SetAppInfo(c.Clientid, c.Clientsecret)
// 3. Provide the user token.
db.SetAccessToken(c.Token)
fmt.Println(c.DropboxPath)
err = db.DownloadToFile(c.DropboxPath, c.Destination, "")
if err != nil {
panic(err)
}
}
// New creates a client to connect to Dropbox.
func New(key, secret, token string) (db *Dropbox, err error) {
if key == "" {
err = errors.New("empty key")
return
}
if secret == "" {
err = errors.New("empty secret")
return
}
if token == "" {
err = errors.New("empty token")
return
}
var (
client *dropbox.Dropbox
)
client = dropbox.NewDropbox()
client.SetAppInfo(key, secret)
client.SetAccessToken(token)
db = &Dropbox{
client: client,
cwd: "/",
}
return
}
func main() {
err := rpio.Open()
if err != nil {
fmt.Println("rpio.Open()")
fmt.Println(err)
}
// Unmap gpio memory when done
defer rpio.Close()
toggleLight(9)
var db *dropbox.Dropbox
db = dropbox.NewDropbox()
db.SetAppInfo(clientid, clientsecret)
db.SetAccessToken(token)
toggleLight(10)
shoot(db)
toggleLight(11)
}
func dropboxClient(context context.Context, accessToken string) *dropbox.Dropbox {
db := dropbox.NewDropbox()
db.SetContext(context)
db.SetAppInfo(clientId, clientSecret)
db.SetAccessToken(accessToken)
return db
}
func handler(w http.ResponseWriter, r *http.Request) {
var err error
var db *dropbox.Dropbox
var input io.ReadCloser
var length int64
var ok bool
var cachedItem interface{}
var s string
if r.URL.Path[1:] == "favicon.ico" {
return
}
cachedItem, ok = Lru.Get(r.URL.Path[1:])
if ok {
item := cachedItem.(cacheItem)
s = item.Value
length = item.Length
} else {
var clientid, clientsecret string
var token string
clientid = os.Getenv("CLIENTID")
clientsecret = os.Getenv("CLIENTSECRET")
token = os.Getenv("TOKEN")
// 1. Create a new dropbox object.
db = dropbox.NewDropbox()
// 2. Provide your clientid and clientsecret (see prerequisite).
db.SetAppInfo(clientid, clientsecret)
// 3. Provide the user token.
db.SetAccessToken(token)
// 4. Send your commands.
// In this example, you will create a new folder named "demo".
if input, length, _, err = db.Thumbnails("/"+r.URL.Path[2:], "jpeg", r.URL.Path[1:2]); err != nil {
fmt.Printf("Error: %s Url: %s Size: \n", err, r.URL.Path[2:], r.URL.Path[1:2])
} else {
//fmt.Printf("Error %s\n", input)
buf := new(bytes.Buffer)
buf.ReadFrom(input)
s = buf.String()
Lru.Add(r.URL.Path[1:], cacheItem{Value: s, Length: length})
}
}
w.Header().Set("Content-Length", strconv.FormatInt(length, 10))
fmt.Fprintf(w, "%s", s)
}
// NewDropboxBackend returns a new Dropbox backend to read JSON from.
// You must provide an accessToken, which you can get by creating an app
// in the Dropbox API and then pressing Generate.
// Access tokens do not expire.
// If a storageLocation isn't provided, the default location is
// /Apps/Reporter-App/
func NewDropboxBackend(accessToken, storageLocation string) (*DropboxBackend, error) {
if accessToken == "" {
return nil, errors.New("No access token provided for Dropbox backend")
}
db := dropbox.NewDropbox()
db.SetAccessToken(accessToken)
if storageLocation == "" {
storageLocation = "/Apps/Reporter-App/"
}
return &DropboxBackend{db, storageLocation}, nil
}
func WriteFile(config *DropboxConfig, file string, content string) error {
var db *dropbox.Dropbox
db = dropbox.NewDropbox()
db.SetAppInfo(config.AppKey, config.AppSecret)
db.SetAccessToken(config.Token)
in := ioutil.NopCloser(bytes.NewBufferString(content))
_, err := db.UploadByChunk(in, 1024, file, true, "")
return err
}
// Makes a new dropbox from the config
func newDropbox(name string) (*dropbox.Dropbox, error) {
db := dropbox.NewDropbox()
appKey := fs.ConfigFileGet(name, "app_key")
if appKey == "" {
appKey = rcloneAppKey
}
appSecret := fs.ConfigFileGet(name, "app_secret")
if appSecret == "" {
appSecret = fs.MustReveal(rcloneEncryptedAppSecret)
}
err := db.SetAppInfo(appKey, appSecret)
return db, err
}
// Makes a new dropbox from the config
func newDropbox(name string) *dropbox.Dropbox {
db := dropbox.NewDropbox()
appKey := fs.ConfigFile.MustValue(name, "app_key")
if appKey == "" {
appKey = rcloneAppKey
}
appSecret := fs.ConfigFile.MustValue(name, "app_secret")
if appSecret == "" {
appSecret = rcloneAppSecret
}
db.SetAppInfo(appKey, appSecret)
return db
}
func uploadFile(file multipart.File) string {
clientid := os.Getenv("DROPBOX_KEY")
clientsecret := os.Getenv("DROPBOX_TOKEN")
token := os.Getenv("DROPBOX_ACCESS_TOKEN")
DB := dropbox.NewDropbox()
DB.SetAppInfo(clientid, clientsecret)
DB.SetAccessToken(token)
filename := fmt.Sprintf("%s.png", strconv.FormatInt(rand.Int63(), 32))
filepath := fmt.Sprintf("/Public/Screenshots/%s", filename)
var tmpstr []byte
length, _ := file.Read(tmpstr)
DB.FilesPut(file, int64(length), filepath, true, "")
account, _ := DB.GetAccountInfo()
uid := strconv.FormatInt(int64(account.UID), 10)
return fmt.Sprintf("https://dl.dropbox.com/u/%s/Screenshots/%s", uid, filename)
}
func ReadFile(config *DropboxConfig, file string) (string, error) {
var err error
var db *dropbox.Dropbox
var s string
db = dropbox.NewDropbox()
db.SetAppInfo(config.AppKey, config.AppSecret)
db.SetAccessToken(config.Token)
rd, _, err := db.Download(file, "", 0)
if err != nil {
return s, err
}
buf := new(bytes.Buffer)
buf.ReadFrom(rd)
s = buf.String()
return s, nil
}
func build(config map[string]string) (gofile.Driver, error) {
var clientID, clientSecret, token string
var ok bool
if clientID, ok = config["client_id"]; !ok {
return nil, fmt.Errorf("godropbox: Client ID not specified")
}
if clientSecret, ok = config["client_secret"]; !ok {
return nil, fmt.Errorf("godropbox: Client Secret not specified")
}
if token, ok = config["token"]; !ok {
return nil, fmt.Errorf("godropbox: Token not specified")
}
db := dropbox.NewDropbox()
db.SetAppInfo(clientID, clientSecret)
db.SetAccessToken(token)
return dropboxDriver{db: db}, nil
}
func main() {
//Set our environment
martini.Env = martini.Prod
//Load our config information and start our web server.
config := LoadConfiguration("./config.json")
auth, encrypt := securecookie.GenerateRandomKey(64), securecookie.GenerateRandomKey(32)
store := sessions.NewCookieStore(auth, encrypt)
server := martini.New()
db := dropbox.NewDropbox()
router := martini.NewRouter()
r := render.New()
oAuthConf := &oauth2.Config{
ClientID: config.Dropbox.AppKey,
ClientSecret: config.Dropbox.AppSecret,
RedirectURL: config.Server.HostName + "/auth/response",
Endpoint: oauth2.Endpoint{
AuthURL: "https://www.dropbox.com/1/oauth2/authorize",
TokenURL: "https://api.dropbox.com/1/oauth2/token",
},
}
//Configure our Dropbox access
db.SetAppInfo(config.Dropbox.AppKey, config.Dropbox.AppSecret)
//Set our public web root and our session storage.
server.Use(martini.Logger())
server.Use(martini.Recovery())
server.Use(sessions.Sessions("ynawb", store))
server.Use(martini.Static(config.Server.WebRoot))
//Configure the Martini router
server.MapTo(router, (*martini.Routes)(nil))
server.Action(router.Handle)
//Redirects the users over to Dropbox for authentication
router.Get("/auth", func(res http.ResponseWriter, req *http.Request) {
/* So, this is a weird edge case. Because we're serving most
* of our app via the static files handler and the HTTPS redirect
* in the martinin-contrib/secure package only works for defined routes,
* any of our main files own't get redirected. Because of that, we're
* going to redirect people when they go to auth their Dropbox
* accounts. This should fix the issue. */
if strings.ToLower(req.URL.Scheme) == "http" && strings.ToLower(req.URL.Host) != "localhost" {
url := req.URL
url.Scheme = "https"
url.Host = req.Host
http.Redirect(res, req, url.String(), http.StatusFound)
} else {
// Redirect user to consent page to ask for permission
// for the scopes specified above.
url := oAuthConf.AuthCodeURL("state")
http.Redirect(res, req, url, http.StatusFound)
}
})
/* Accepts the response after authorizing with Dropbox. */
router.Get("/auth/response", func(res http.ResponseWriter, req *http.Request) {
//If they cancelled their login, redirect them back to the home page.
if authError := req.FormValue("error"); authError != "" {
http.Redirect(res, req, config.Server.HostName, http.StatusFound)
return
}
code := req.FormValue("code")
//If we didn't somehow get an authentication code, take them back home.
if code == "" {
http.Redirect(res, req, config.Server.HostName, http.StatusFound)
return
}
fmt.Printf("Exchanging code '%v'\n", code)
//token, err := oAuthConf.Exchange(nil, code)
token, err := oAuthConf.Exchange(oauth2.NoContext, code)
//If our token exchange doesn't work, throw an error and go to our error page.
if err != nil {
handleError(err, res, req, config)
return
}
session, err := store.Get(req, "ynawb")
//If we can't get our session store, throw an error and go to our error page.
if err != nil {
handleError(err, res, req, config)
return
}
//Set our dropbox session token and save.
session.Options.HttpOnly = true
//Sets the max age of our cookie. Defaults is fifteen minutes.
session.Options.MaxAge = config.Server.SessionMaxAge
//Set our token
session.Values["token"] = token.AccessToken
//Save our token and its settings
session.Save(req, res)
url := config.Server.HostName + "/budgets"
//Redirect them to a page where they can select their needed budget
http.Redirect(res, req, url, http.StatusFound)
})
/* Retrieves a list of the users YNAB budgets and devices from
* their Dropbox account. Redirects them back to the home page if
* their cookie has expired. */
router.Get("/api/budgets", func(res http.ResponseWriter, req *http.Request) {
session, _ := store.Get(req, "ynawb")
cookie := session.Values["token"]
if token, ok := cookie.(string); ok {
db.SetAccessToken(token)
if file, err := loadDropboxFile("/.ynabSettings.yroot", db); err != nil && err.Error() != "EOF" {
handleError(err, res, req, config)
} else {
settings := LoadYNABSettings(file)
results := make(map[string][]map[string]string)
for _, setting := range settings.RelativeKnownBudgets {
bm, err := loadDropboxFile(setting+"/Budget.ymeta", db)
if err != nil && err.Error() != "EOF" {
handleError(err, res, req, config)
return
}
metadata := LoadYNABBudgetMetadata(bm)
devicesPath := setting + "/" + metadata.RelativeDataFolderName + "/devices"
entries, err := db.Search(devicesPath, ".ydevice", 0, false)
if err != nil && err.Error() != "EOF" {
handleError(err, res, req, config)
return
}
devicesCollection := make([]map[string]string, len(entries))
for j, entry := range entries {
dev, err := loadDropboxFile(entry.Path, db)
if err != nil && err.Error() != "EOF" {
handleError(err, res, req, config)
}
device := LoadYNABDevice(dev)
devicesCollection[j] = map[string]string{
"name": device.FriendlyName,
"guid": device.DeviceGUID,
}
}
results[setting] = devicesCollection
}
res.Header().Set("Content-Type", "application/json")
r.JSON(res, http.StatusOK, results)
}
} else {
http.Redirect(res, req, config.Server.HostName, http.StatusUnauthorized)
return
}
})
/* Retrieves the users YNAB budget data from their Dropbox account.
* Redirects them back to the home page if their cookie has expired. */
router.Get("/api/budgetdata/:budget/:path", func(res http.ResponseWriter, req *http.Request, params martini.Params) string {
//Do some checks on our parameters
if params["budget"] == "" || params["budget"] == "undefined" {
return ""
}
if params["path"] == "" || params["path"] == "undefined" {
return ""
}
session, _ := store.Get(req, "ynawb")
cookie := session.Values["token"]
if token, ok := cookie.(string); ok {
db.SetAccessToken(token)
s, err := loadDropboxFile(".ynabSettings.yroot", db)
if err != nil && err.Error() != "EOF" {
handleError(err, res, req, config)
}
settings := LoadYNABSettings(s)
relativePath := ""
for _, p := range settings.RelativeKnownBudgets {
if strings.Contains(p, params["budget"]) {
relativePath = p
}
}
path := "/" + relativePath + "/"
m, err := loadDropboxFile(path+"Budget.ymeta", db)
if err != nil && err.Error() != "EOF" {
handleError(err, res, req, config)
}
metadata := LoadYNABBudgetMetadata(m)
budget := path + metadata.RelativeDataFolderName + "/" + params["path"] + "/Budget.yfull"
b, err := loadDropboxFile(budget, db)
if err != nil && err.Error() != "EOF" {
handleError(err, res, req, config)
}
res.Header().Set("Content-Type", "application/json")
return string(b)
} else {
http.Redirect(res, req, config.Server.HostName, http.StatusUnauthorized)
return ""
}
})
// HTTP
go func() {
if err := http.ListenAndServe(":"+strconv.Itoa(config.Server.Port), server); err != nil {
log.Fatal(err)
} else {
fmt.Printf("Listing on port :%v\n", config.Server.Port)
}
}()
server.RunOnAddr(":" + strconv.Itoa(config.Server.PortSSL))
server.Run()
}
func handleOriginalFile(w http.ResponseWriter, r *http.Request) {
var err error
var db *dropbox.Dropbox
// var input io.ReadCloser
var length int64
var ok bool
var cachedItem interface{}
var s string
if r.URL.Path[1:] == "favicon.ico" {
return
}
cachedItem, ok = Lru.Get(r.URL.Path[5:])
if ok {
item := cachedItem.(cacheItem)
s = item.Value
length = item.Length
} else {
var clientid, clientsecret string
var token, rev string
clientid = os.Getenv("CLIENTID")
clientsecret = os.Getenv("CLIENTSECRET")
token = os.Getenv("TOKEN")
// 1. Create a new dropbox object.
db = dropbox.NewDropbox()
// 2. Provide your clientid and clientsecret (see prerequisite).
db.SetAppInfo(clientid, clientsecret)
// 3. Provide the user token.
db.SetAccessToken(token)
rev = ""
//h := md5.New()
//io.WriteString(h, r.URL.Path[5:])
//b := h.Sum(nil)
str := strings.Replace(r.URL.Path[5:], "/", "-", -1)
err = db.DownloadToFile("/"+r.URL.Path[5:], "/tmp/"+str, rev)
if err != nil {
fmt.Printf("123 Error: %s Url: %s Size: \n", err, r.URL.Path[5:], r.URL.Path[1:2])
} else {
dat, err := ioutil.ReadFile("/tmp/" + str)
if err != nil {
} else {
f, err := os.Open("/tmp/" + str)
if err != nil {
}
fi, err := f.Stat()
if err != nil {
// Could not obtain stat, handle error
}
length = fi.Size()
s = string(dat[:])
// w.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
fmt.Fprintf(w, "%s", dat)
Lru.Add(r.URL.Path[5:], cacheItem{Value: s, Length: length})
}
}
}
w.Header().Set("Content-Length", strconv.FormatInt(length, 10))
fmt.Fprintf(w, "%s", s)
}
func main() {
flag.Parse()
setFromEnv()
if *appID == "" || *appSecret == "" {
fatalf("Application ID and Secret is required.")
}
dbox := dropbox.NewDropbox()
dbox.SetAppInfo(*appID, *appSecret)
if *appToken == "" {
if err := dbox.Auth(); err != nil {
fmt.Println(err)
return
}
} else {
dbox.SetAccessToken(*appToken)
}
if *fileName == "" && *inputFile == "" {
fmt.Println("Filename is required.")
os.Exit(1)
return
} else if *fileName == "" {
*fileName = *inputFile
}
if *doMkdir && *dirName != "" {
if _, err := dbox.CreateFolder(*dirName); err != nil && strings.Contains(err.Error(), "already exists") {
fmt.Printf("Folder %s already exists\n", *dirName)
} else if err != nil {
fatalf("Error creating folder %s: %s", *dirName, err)
}
fmt.Printf("Folder %s successfully created\n", *dirName)
}
fname := strings.Trim(strings.Join([]string{*dirName, *fileName}, "/"), "/")
fmt.Printf("Uploading file %s => %s\n", *inputFile, fname)
var input io.ReadCloser
if *inputFile != "" {
// _, err = dbox.UploadFile(*inputFile, fname, true, "")
info, err := os.Stat(*inputFile)
if err != nil {
fatalf("%v", err)
}
file, err := os.Open(*inputFile)
if err != nil {
fatalf("Error opening file %q: %v", *inputFile, err)
}
defer file.Close()
bar := pb.StartNew(int(info.Size()))
bar.Units = pb.U_BYTES
input = ioutil.NopCloser(&ioprogress.Reader{
Reader: file,
Size: info.Size(),
DrawFunc: func(progress int64, total int64) error {
bar.Set(int(progress))
if progress >= total {
bar.FinishPrint("Done")
}
return nil
},
})
} else {
input = os.Stdin
}
_, err := dbox.UploadByChunk(input, *chunkSize*1024, fname, false, "")
if err != nil {
fatalf("Error uploading file %s: %v", fname, err)
}
fmt.Printf("File %s successfully created\n", fname)
}
func main() {
var err error
do_not_include = []string{}
// Ignore all .txt files
do_not_include = append(do_not_include, ".txt")
config = Config{}
cache_instance = cache.New(12*time.Hour, 15*time.Minute)
db = dropbox.NewDropbox()
data, read_err := ioutil.ReadFile("config.yml")
if read_err != nil {
log.Fatal(read_err)
}
yaml_err := yaml.Unmarshal(data, &config)
if yaml_err != nil {
log.Fatal("error: %v", yaml_err)
}
fmt.Printf("--- config_file dump:\n%s\n\n", data)
fmt.Printf("--- config dump:\n%s\n\n", config)
db.SetAppInfo(config.Api_key, config.Api_secret)
if len(config.Client_token) >= 1 {
db.SetAccessToken(config.Client_token)
} else {
if err = db.Auth(); err != nil {
fmt.Println(err)
return
}
config.Client_token = db.AccessToken()
db.SetAccessToken(config.Client_token)
d, marshal_err := yaml.Marshal(&config)
if marshal_err != nil {
log.Fatal("error: %v", marshal_err)
}
ioutil.WriteFile("config.yml", []byte(d), 0644)
}
// root_paths := get_directories(cache, db, "")
// fmt.Printf("--- paths dump:\n%s\n\n", root_paths)
// nightly_files := get_files(cache, db, "ARMv7")
// fmt.Printf("--- paths dump:\n%s\n\n", nightly_files)
// setup server to link
api := rest.NewApi()
statusMw := &rest.StatusMiddleware{}
api.Use(statusMw)
api.Use(rest.DefaultDevStack...)
router, err := rest.MakeRouter(
// Status endpoint for monitoring
rest.Get("/status", func(w rest.ResponseWriter, r *rest.Request) {
w.WriteJson(statusMw.GetStatus())
}),
// The JSON endpoints for data about the next endpoint
rest.Get("/", list_arches),
rest.Get("/#arch", list_softwares),
rest.Get("/#arch/#software", list_versions),
rest.Get("/#arch/#software/#version", list_targets),
// Endpoint that redirects the client
rest.Get("/#arch/#software/#version/#target", link_target),
)
if err != nil {
log.Fatal(err)
}
api.SetApp(router)
s := []string{}
s = append(s, config.Server_listen)
s = append(s, config.Server_port)
server_listen := strings.Join(s, ":")
http.Handle(strings.Join([]string{config.Context_root, "/"}, ""), http.StripPrefix(config.Context_root, api.MakeHandler()))
log.Fatal(http.ListenAndServe(server_listen, nil))
}