func main() { fmt.Println("Download Start.") client := &http.Client{} service, err := drive.New(client) if err != nil { log.Fatalf("Unable to create Drive service: %v", err) return } if err := os.MkDirAll(filepath.Dir(*outputPath), 0755); err != nil { log.Fatalf("Unable to make Directory: %v", err) return } fd, err := os.Create(*outputPath) if err != nil { log.Fatalf("Unable to create File: %v", err) return } defer fd.Close() res, err := service.Files.Get(*fileId).Download() if err != nil { log.Fatalf("Unable to download File: %v", err) return } defer res.Body.Close() bytes, err := io.Copy(fd, res.Body) if err != nil { log.Fatalf("Unable to io Copy: %v", err) return } fmt.Println("Download Finish.") }
func NewRemoteContext(context *config.Context) *Remote { client := newOAuthClient(context) service, _ := drive.New(client) progressChan := make(chan int) return &Remote{ progressChan: progressChan, service: service, client: client, } }
// New initiates a new DriveService. parentId is the ID of the directory // that will be used as the current directory in methods on the returned // DriveService (such as Get). If empty, it defaults to the root of the // drive. func New(oauthClient *http.Client, parentId string) (*DriveService, error) { apiservice, err := client.New(oauthClient) if err != nil { return nil, err } if parentId == "" { // because "root" is known as a special alias for the root directory in drive. parentId = "root" } service := &DriveService{client: oauthClient, apiservice: apiservice, parentId: parentId} return service, err }
func setupClients(client *http.Client) { var err error loginClient = client oauthSvc, err = oauth.New(client) if err != nil { log.Fatalf("Unable to create OAuth service: %v", err) } drvSvc, err = drive.New(client) if err != nil { log.Fatalf("Unable to create Drive service: %v", err) } }
func driveMain(client *http.Client, argv []string) { if len(argv) != 1 { fmt.Fprintln(os.Stderr, "Usage: drive filename (to upload a file)") return } service, _ := drive.New(client) filename := argv[0] goFile, err := os.Open(filename) if err != nil { log.Fatalf("error opening %q: %v", filename, err) } driveFile, err := service.Files.Insert(&drive.File{Title: filename}).Media(goFile).Do() log.Printf("Got drive.File, err: %#v, %v", driveFile, err) }
func AppendLog(msg string) { ctx := context.Background() b, err := ioutil.ReadFile("client_secret.json") if err != nil { log.Fatalf("Unable to read client secret file: %v", err) } config, err := google.ConfigFromJSON(b, drive.DriveScope) if err != nil { log.Fatalf("Unable to parse client secret file to config: %v", err) } client := getClient(ctx, config) srv, err := drive.New(client) if err != nil { log.Fatalf("Unable to retrieve drive Client %v", err) } children, err := GetLog(srv, "0B14gQeVTanyZfnhwalk2OG9UVHVucHhLOE44ZHlySnpIM0FvdmYzMjNiOUZVVjEySzBzZk0") if err != nil { fmt.Println(err) } if children != nil { fileId := children.Id content, err := GetFile(srv, client, fileId) if err != nil { fmt.Println(err) return } content = content + "\n" + msg // remove redundant empty line reBlank := regexp.MustCompile(`([ \t]*\n){2,}`) output := reBlank.ReplaceAllLiteralString(content, "\n") UpdateFile(srv, fileId, output) } else { // create a new file f := &drive.File{Title: ThisWeek(), MimeType: "text/plain"} p := &drive.ParentReference{Id: "0B14gQeVTanyZfnhwalk2OG9UVHVucHhLOE44ZHlySnpIM0FvdmYzMjNiOUZVVjEySzBzZk0"} f.Parents = []*drive.ParentReference{p} _, err := srv.Files.Insert(f).Media(bytes.NewReader([]byte(msg))).Do() if err != nil { fmt.Printf("An error occurred: %v\n", err) } } }
// NewDriveDB creates a new DriveDB and starts syncing metadata. func NewDriveDB(client *http.Client, dbPath, cachePath string, pollInterval time.Duration, rootId string) (*DriveDB, error) { svc, _ := gdrive.New(client) _, err := svc.About.Get().Do() if err != nil { log.Fatalf("drive.service.About.Get().Do: %v\n", err) } if *debugDriveDB { debug = true } ldbPath := path.Join(dbPath, "meta") log.Printf("using db path: %q", ldbPath) err = os.MkdirAll(ldbPath, 0700) if err != nil { return nil, fmt.Errorf("could not create directory %q", ldbPath) } log.Printf("using cache path: %q", cachePath) err = os.MkdirAll(cachePath, 0700) if err != nil { return nil, fmt.Errorf("could not create directory %q", cachePath) } db, err := openLevelDB(ldbPath) if err != nil { return nil, err } d := &DriveDB{ client: client, service: svc, db: db, dbpath: ldbPath, data: cachePath, lruCache: lru.New(*inodeCacheSize), changes: make(chan *gdrive.ChangeList, 200), pollInterval: pollInterval, rootId: rootId, driveSize: (*driveCacheChunk) * (*driveCacheChunks), // ensure drive reads are always a multiple of cache size cacheBlocks: (*cacheSize) * ((*driveCacheChunks) * (*prefetchMultiplier)), // enough blocks for readahead pfetchq: make(chan DownloadSpec, 20000), pfetchmap: make(map[string]bool), } log.Printf("%d cache blocks of %d bytes", d.cacheBlocks, *driveCacheChunk) // Get saved checkpoint. err = d.get(internalKey("checkpoint"), &d.cpt) if err != nil { log.Printf("error reading checkpoint: %v", err) d.cpt = NewCheckpoint() } if d.cpt.Version != checkpointVersion { log.Printf("checkpoint version invalid, require %v but found %v", checkpointVersion, d.cpt.Version) err = d.reinit() if err != nil { log.Printf("Failed to reinitialize the database: %v", err) log.Fatal("You should probably run: rm -rf %v", ldbPath) } } err = d.writeCheckpoint(nil) if err != nil { return nil, fmt.Errorf("could not write checkpoint: %v", err) } debug.Printf("Recovered from checkpoint: %+v", d.cpt) if err := d.createRoot(); err != nil { return nil, fmt.Errorf("could not create root inode entry: %v", err) } d.synced = sync.NewCond(&d.syncmu) go d.sync() go d.pollForChanges() if debug { registerDebugHandles(*d) // in http_handlers.go } for i := 0; i < *prefetchWorkers; i++ { go d.prefetcher() } return d, nil }
func main() { runtime.GOMAXPROCS(runtime.NumCPU()) runtime.SetBlockProfileRate(1) ctx := context.Background() flag.Usage = Usage flag.Parse() if flag.NArg() != 1 { Usage() os.Exit(2) } mountpoint := flag.Arg(0) if *debugGdrive { debug = true } userCurrent, err := user.Current() if err != nil { log.Fatalf("unable to get UID/GID of current user: %v", err) } uidInt, err := strconv.Atoi(userCurrent.Uid) if err != nil { log.Fatalf("unable to get UID/GID of current user: %v", err) } uid := uint32(uidInt) gidInt, err := strconv.Atoi(userCurrent.Gid) if err != nil { log.Fatalf("unable to get UID/GID of current user: %v", err) } gid := uint32(gidInt) if err = sanityCheck(mountpoint); err != nil { log.Fatalf("sanityCheck failed: %s\n", err) } http.HandleFunc("/", RootHandler) go http.ListenAndServe(fmt.Sprintf("localhost:%s", *port), nil) var client *http.Client if *readOnly { client = getClient(ctx, drive.DriveReadonlyScope) } else { client = getClient(ctx, drive.DriveScope) } driveCache := cache.NewCache("/tmp", client) // TODO: move into drivedb, so we don't create a service twice service, _ := drive.New(client) about, err := service.About.Get().Do() if err != nil { log.Fatalf("drive.service.About.Get().Do: %v\n", err) } // fileId of the root of the FS (aka "My Drive") rootId := about.RootFolderId // email address of the mounted google drive account account := about.User.EmailAddress // Ensure the token's always fresh // TODO: Remove this once goauth2 changes are accepted upstream // https://code.google.com/p/goauth2/issues/detail?id=47 // go tokenKicker(client, 59*time.Minute) // Create and start the drive metadata syncer. db, err := drive_db.NewDriveDB(client, *dbDir, *cacheDir, *driveMetadataLatency, rootId) if err != nil { log.Fatalf("could not open leveldb: %v", err) } defer db.Close() db.WaitUntilSynced() log.Printf("synced!") options := []fuse.MountOption{ fuse.FSName("GoogleDrive"), fuse.Subtype("gdrive"), fuse.VolumeName(account), } if *allowOther { options = append(options, fuse.AllowOther()) } if *readOnly { options = append(options, fuse.ReadOnly()) } c, err := fuse.Mount(mountpoint, options...) if err != nil { log.Fatal(err) } defer c.Close() // Trap control-c (sig INT) and unmount sig := make(chan os.Signal, 1) signal.Notify(sig, os.Interrupt) go func() { for _ = range sig { if err := fuse.Unmount(mountpoint); err != nil { log.Printf("fuse.Unmount failed: %v", err) } } }() sc := serveConn{db: db, driveCache: driveCache, service: service, uid: uid, gid: gid, writers: make(map[int]io.PipeWriter), conn: c, } err = sc.Serve() if err != nil { log.Fatalln("fuse server failed: ", err) } // check if the mount process has an error to report <-c.Ready if err := c.MountError; err != nil { log.Fatal(err) } }