https://github.com/sirherobrine23/drivefs
Implements google drive to go fs.FS
https://github.com/sirherobrine23/drivefs
fs go golang google-drive
Last synced: 3 months ago
JSON representation
Implements google drive to go fs.FS
- Host: GitHub
- URL: https://github.com/sirherobrine23/drivefs
- Owner: Sirherobrine23
- License: mit
- Created: 2024-08-29T22:18:09.000Z (11 months ago)
- Default Branch: main
- Last Pushed: 2025-03-19T02:37:52.000Z (4 months ago)
- Last Synced: 2025-04-10T01:13:19.554Z (3 months ago)
- Topics: fs, go, golang, google-drive
- Language: Go
- Homepage: https://sirherobrine23.com.br/Sirherobrine23/drivefs
- Size: 87.9 KB
- Stars: 2
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# drivefs
Implements google drive to [fs.FS](https://pkg.go.dev/io/fs)
## Path resolve
Google drive does not implement the file system in the unix filepath format, so we have to resolve this path, this can become costly for the API, we have to make a call for each separator (N+MS+1), so this will end up becoming slow to resolve (This path being `/Frog/Google/files`, it would be the same as 3 + 0.5ms + 1, total of 2.5ms), for this we have a cache of files in the folder that reduces this time but leaves it undone with the time
## Example
```go
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"net"
"net/http"
"net/netip"
"os"
"golang.org/x/oauth2"
"google.golang.org/api/drive/v2"
"sirherobrine23.com.br/Sirherobrine23/drivefs"
)
var (
configPath = flag.String("config", "./config.json", "Config file path")
serverPort = flag.Uint("port", 8081, "server to listen")
setupAuth = flag.Bool("auth", false, "Listen server and Auth")
client = flag.String("client", "", "installed.client_id")
secret = flag.String("secret", "", "installed.client_secret")
project = flag.String("project", "", "installed.project_id")
auth_uri = flag.String("auth_uri", "", "installed.auth_uri")
token_uri = flag.String("token_uri", "", "installed.token_uri")
redirect = flag.String("redirect", "", "installed.redirect_uris[]")
access_token = flag.String("access_token", "", "token.access_token")
refresh_token = flag.String("refresh_token", "", "token.refresh_token")
token_type = flag.String("token_type", "", "token.token_type")
root_folder = flag.String("root_folder", "", "Google drive folder id (gdrive:) or path to folder")
gdriveConfig drivefs.GoogleOauthConfig
)
func main() {
flag.Parse()
gdriveConfig.Client = *client
gdriveConfig.Secret = *secret
gdriveConfig.Project = *project
gdriveConfig.AuthURI = *auth_uri
gdriveConfig.TokenURI = *token_uri
gdriveConfig.Redirect = *redirect
gdriveConfig.AccessToken = *access_token
gdriveConfig.RefreshToken = *refresh_token
gdriveConfig.TokenType = *token_type
gdriveConfig.RootFolder = *root_folder
fileConfig, err := os.ReadFile(*configPath)
if err == nil {
if err = json.Unmarshal(fileConfig, &gdriveConfig); err != nil {
fmt.Fprintf(os.Stderr, "Cannot unmarshall config: %s\n", err)
os.Exit(1)
return
}
} else if os.IsNotExist(err) {
} else {
fmt.Fprintf(os.Stderr, "Cannot open %q: %s\n", *configPath, err)
os.Exit(1)
return
}
if *setupAuth {
ln, err := net.Listen("tcp", ":0")
if err != nil {
panic(err)
}
P, _ := netip.ParseAddrPort(ln.Addr().String())
ln.Close()
config := &oauth2.Config{
ClientID: gdriveConfig.Client,
ClientSecret: gdriveConfig.Secret,
RedirectURL: fmt.Sprintf("http://localhost:%d/callback", P.Port()),
Scopes: []string{drive.DriveScope, drive.DriveFileScope},
Endpoint: oauth2.Endpoint{
AuthURL: gdriveConfig.AuthURI,
TokenURL: gdriveConfig.TokenURI,
},
}
var (
server *http.Server
GoogleToken *oauth2.Token
)
mux := http.NewServeMux()
mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
http.Redirect(w, r, authURL, http.StatusTemporaryRedirect)
})
mux.HandleFunc("/callback", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/plain")
if code := r.URL.Query().Get("code"); code != "" {
if GoogleToken, err = config.Exchange(context.TODO(), code); err != nil {
panic(fmt.Errorf("unable to retrieve token from web %v", err))
}
defer server.Close()
w.WriteHeader(200)
fmt.Fprintf(w, "Code: %q", code)
fmt.Printf("Code: %q\n", code)
return
}
w.WriteHeader(400)
w.Write([]byte("Wait to code\n"))
})
fmt.Printf("Go to the following link in your browser then type the authorization code: \nhttp://%s/token\n", P.String())
server = &http.Server{Addr: P.String(), Handler: mux}
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
panic(err)
}
gdriveConfig.AccessToken = GoogleToken.AccessToken
gdriveConfig.RefreshToken = GoogleToken.RefreshToken
gdriveConfig.TokenType = GoogleToken.TokenType
gdriveConfig.Expire = GoogleToken.Expiry
data, err := json.MarshalIndent(gdriveConfig, "", " ")
if err != nil {
panic(err)
} else if err = os.WriteFile(*configPath, data, 0666); err != nil {
panic(err)
}
}
gdrive, err := drivefs.NewGoogleDrive(gdriveConfig)
if err != nil {
fmt.Fprintf(os.Stderr, "Cannot open gdrive client: %s\n", err)
os.Exit(1)
return
}
fmt.Printf("server listening on :%d\n", *serverPort)
if err := http.ListenAndServe(fmt.Sprintf(":%d", *serverPort), http.FileServerFS(gdrive)); err != nil {
fmt.Fprintln(os.Stderr, err.Error())
os.Exit(1)
}
}
```