"Fossies" - the Fresh Open Source Software Archive 
Member "gdrive-2.1.1/handlers_drive.go" (28 May 2021, 12521 Bytes) of package /linux/misc/gdrive-2.1.1.tar.gz:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
1 package main
2
3 import (
4 "fmt"
5 "io"
6 "io/ioutil"
7 "net/http"
8 "os"
9 "path/filepath"
10 "time"
11
12 "github.com/prasmussen/gdrive/auth"
13 "github.com/prasmussen/gdrive/cli"
14 "github.com/prasmussen/gdrive/drive"
15 )
16
17 const ClientId = "367116221053-7n0vf5akeru7on6o2fjinrecpdoe99eg.apps.googleusercontent.com"
18 const ClientSecret = "1qsNodXNaWq1mQuBjUjmvhoO"
19 const TokenFilename = "token_v2.json"
20 const DefaultCacheFileName = "file_cache.json"
21
22 func listHandler(ctx cli.Context) {
23 args := ctx.Args()
24 err := newDrive(args).List(drive.ListFilesArgs{
25 Out: os.Stdout,
26 MaxFiles: args.Int64("maxFiles"),
27 NameWidth: args.Int64("nameWidth"),
28 Query: args.String("query"),
29 SortOrder: args.String("sortOrder"),
30 SkipHeader: args.Bool("skipHeader"),
31 SizeInBytes: args.Bool("sizeInBytes"),
32 AbsPath: args.Bool("absPath"),
33 })
34 checkErr(err)
35 }
36
37 func listChangesHandler(ctx cli.Context) {
38 args := ctx.Args()
39 err := newDrive(args).ListChanges(drive.ListChangesArgs{
40 Out: os.Stdout,
41 PageToken: args.String("pageToken"),
42 MaxChanges: args.Int64("maxChanges"),
43 Now: args.Bool("now"),
44 NameWidth: args.Int64("nameWidth"),
45 SkipHeader: args.Bool("skipHeader"),
46 })
47 checkErr(err)
48 }
49
50 func downloadHandler(ctx cli.Context) {
51 args := ctx.Args()
52 checkDownloadArgs(args)
53 err := newDrive(args).Download(drive.DownloadArgs{
54 Out: os.Stdout,
55 Id: args.String("fileId"),
56 Force: args.Bool("force"),
57 Skip: args.Bool("skip"),
58 Path: args.String("path"),
59 Delete: args.Bool("delete"),
60 Recursive: args.Bool("recursive"),
61 Stdout: args.Bool("stdout"),
62 Progress: progressWriter(args.Bool("noProgress")),
63 Timeout: durationInSeconds(args.Int64("timeout")),
64 })
65 checkErr(err)
66 }
67
68 func downloadQueryHandler(ctx cli.Context) {
69 args := ctx.Args()
70 err := newDrive(args).DownloadQuery(drive.DownloadQueryArgs{
71 Out: os.Stdout,
72 Query: args.String("query"),
73 Force: args.Bool("force"),
74 Skip: args.Bool("skip"),
75 Recursive: args.Bool("recursive"),
76 Path: args.String("path"),
77 Progress: progressWriter(args.Bool("noProgress")),
78 })
79 checkErr(err)
80 }
81
82 func downloadSyncHandler(ctx cli.Context) {
83 args := ctx.Args()
84 cachePath := filepath.Join(args.String("configDir"), DefaultCacheFileName)
85 err := newDrive(args).DownloadSync(drive.DownloadSyncArgs{
86 Out: os.Stdout,
87 Progress: progressWriter(args.Bool("noProgress")),
88 Path: args.String("path"),
89 RootId: args.String("fileId"),
90 DryRun: args.Bool("dryRun"),
91 DeleteExtraneous: args.Bool("deleteExtraneous"),
92 Timeout: durationInSeconds(args.Int64("timeout")),
93 Resolution: conflictResolution(args),
94 Comparer: NewCachedMd5Comparer(cachePath),
95 })
96 checkErr(err)
97 }
98
99 func downloadRevisionHandler(ctx cli.Context) {
100 args := ctx.Args()
101 err := newDrive(args).DownloadRevision(drive.DownloadRevisionArgs{
102 Out: os.Stdout,
103 FileId: args.String("fileId"),
104 RevisionId: args.String("revId"),
105 Force: args.Bool("force"),
106 Stdout: args.Bool("stdout"),
107 Path: args.String("path"),
108 Progress: progressWriter(args.Bool("noProgress")),
109 Timeout: durationInSeconds(args.Int64("timeout")),
110 })
111 checkErr(err)
112 }
113
114 func uploadHandler(ctx cli.Context) {
115 args := ctx.Args()
116 checkUploadArgs(args)
117 err := newDrive(args).Upload(drive.UploadArgs{
118 Out: os.Stdout,
119 Progress: progressWriter(args.Bool("noProgress")),
120 Path: args.String("path"),
121 Name: args.String("name"),
122 Description: args.String("description"),
123 Parents: args.StringSlice("parent"),
124 Mime: args.String("mime"),
125 Recursive: args.Bool("recursive"),
126 Share: args.Bool("share"),
127 Delete: args.Bool("delete"),
128 ChunkSize: args.Int64("chunksize"),
129 Timeout: durationInSeconds(args.Int64("timeout")),
130 })
131 checkErr(err)
132 }
133
134 func uploadStdinHandler(ctx cli.Context) {
135 args := ctx.Args()
136 err := newDrive(args).UploadStream(drive.UploadStreamArgs{
137 Out: os.Stdout,
138 In: os.Stdin,
139 Name: args.String("name"),
140 Description: args.String("description"),
141 Parents: args.StringSlice("parent"),
142 Mime: args.String("mime"),
143 Share: args.Bool("share"),
144 ChunkSize: args.Int64("chunksize"),
145 Timeout: durationInSeconds(args.Int64("timeout")),
146 Progress: progressWriter(args.Bool("noProgress")),
147 })
148 checkErr(err)
149 }
150
151 func uploadSyncHandler(ctx cli.Context) {
152 args := ctx.Args()
153 cachePath := filepath.Join(args.String("configDir"), DefaultCacheFileName)
154 err := newDrive(args).UploadSync(drive.UploadSyncArgs{
155 Out: os.Stdout,
156 Progress: progressWriter(args.Bool("noProgress")),
157 Path: args.String("path"),
158 RootId: args.String("fileId"),
159 DryRun: args.Bool("dryRun"),
160 DeleteExtraneous: args.Bool("deleteExtraneous"),
161 ChunkSize: args.Int64("chunksize"),
162 Timeout: durationInSeconds(args.Int64("timeout")),
163 Resolution: conflictResolution(args),
164 Comparer: NewCachedMd5Comparer(cachePath),
165 })
166 checkErr(err)
167 }
168
169 func updateHandler(ctx cli.Context) {
170 args := ctx.Args()
171 err := newDrive(args).Update(drive.UpdateArgs{
172 Out: os.Stdout,
173 Id: args.String("fileId"),
174 Path: args.String("path"),
175 Name: args.String("name"),
176 Description: args.String("description"),
177 Parents: args.StringSlice("parent"),
178 Mime: args.String("mime"),
179 Progress: progressWriter(args.Bool("noProgress")),
180 ChunkSize: args.Int64("chunksize"),
181 Timeout: durationInSeconds(args.Int64("timeout")),
182 })
183 checkErr(err)
184 }
185
186 func infoHandler(ctx cli.Context) {
187 args := ctx.Args()
188 err := newDrive(args).Info(drive.FileInfoArgs{
189 Out: os.Stdout,
190 Id: args.String("fileId"),
191 SizeInBytes: args.Bool("sizeInBytes"),
192 })
193 checkErr(err)
194 }
195
196 func importHandler(ctx cli.Context) {
197 args := ctx.Args()
198 err := newDrive(args).Import(drive.ImportArgs{
199 Mime: args.String("mime"),
200 Out: os.Stdout,
201 Path: args.String("path"),
202 Parents: args.StringSlice("parent"),
203 Progress: progressWriter(args.Bool("noProgress")),
204 })
205 checkErr(err)
206 }
207
208 func exportHandler(ctx cli.Context) {
209 args := ctx.Args()
210 err := newDrive(args).Export(drive.ExportArgs{
211 Out: os.Stdout,
212 Id: args.String("fileId"),
213 Mime: args.String("mime"),
214 PrintMimes: args.Bool("printMimes"),
215 Force: args.Bool("force"),
216 })
217 checkErr(err)
218 }
219
220 func listRevisionsHandler(ctx cli.Context) {
221 args := ctx.Args()
222 err := newDrive(args).ListRevisions(drive.ListRevisionsArgs{
223 Out: os.Stdout,
224 Id: args.String("fileId"),
225 NameWidth: args.Int64("nameWidth"),
226 SizeInBytes: args.Bool("sizeInBytes"),
227 SkipHeader: args.Bool("skipHeader"),
228 })
229 checkErr(err)
230 }
231
232 func mkdirHandler(ctx cli.Context) {
233 args := ctx.Args()
234 err := newDrive(args).Mkdir(drive.MkdirArgs{
235 Out: os.Stdout,
236 Name: args.String("name"),
237 Description: args.String("description"),
238 Parents: args.StringSlice("parent"),
239 })
240 checkErr(err)
241 }
242
243 func shareHandler(ctx cli.Context) {
244 args := ctx.Args()
245 err := newDrive(args).Share(drive.ShareArgs{
246 Out: os.Stdout,
247 FileId: args.String("fileId"),
248 Role: args.String("role"),
249 Type: args.String("type"),
250 Email: args.String("email"),
251 Domain: args.String("domain"),
252 Discoverable: args.Bool("discoverable"),
253 })
254 checkErr(err)
255 }
256
257 func shareListHandler(ctx cli.Context) {
258 args := ctx.Args()
259 err := newDrive(args).ListPermissions(drive.ListPermissionsArgs{
260 Out: os.Stdout,
261 FileId: args.String("fileId"),
262 })
263 checkErr(err)
264 }
265
266 func shareRevokeHandler(ctx cli.Context) {
267 args := ctx.Args()
268 err := newDrive(args).RevokePermission(drive.RevokePermissionArgs{
269 Out: os.Stdout,
270 FileId: args.String("fileId"),
271 PermissionId: args.String("permissionId"),
272 })
273 checkErr(err)
274 }
275
276 func deleteHandler(ctx cli.Context) {
277 args := ctx.Args()
278 err := newDrive(args).Delete(drive.DeleteArgs{
279 Out: os.Stdout,
280 Id: args.String("fileId"),
281 Recursive: args.Bool("recursive"),
282 })
283 checkErr(err)
284 }
285
286 func listSyncHandler(ctx cli.Context) {
287 args := ctx.Args()
288 err := newDrive(args).ListSync(drive.ListSyncArgs{
289 Out: os.Stdout,
290 SkipHeader: args.Bool("skipHeader"),
291 })
292 checkErr(err)
293 }
294
295 func listRecursiveSyncHandler(ctx cli.Context) {
296 args := ctx.Args()
297 err := newDrive(args).ListRecursiveSync(drive.ListRecursiveSyncArgs{
298 Out: os.Stdout,
299 RootId: args.String("fileId"),
300 SkipHeader: args.Bool("skipHeader"),
301 PathWidth: args.Int64("pathWidth"),
302 SizeInBytes: args.Bool("sizeInBytes"),
303 SortOrder: args.String("sortOrder"),
304 })
305 checkErr(err)
306 }
307
308 func deleteRevisionHandler(ctx cli.Context) {
309 args := ctx.Args()
310 err := newDrive(args).DeleteRevision(drive.DeleteRevisionArgs{
311 Out: os.Stdout,
312 FileId: args.String("fileId"),
313 RevisionId: args.String("revId"),
314 })
315 checkErr(err)
316 }
317
318 func aboutHandler(ctx cli.Context) {
319 args := ctx.Args()
320 err := newDrive(args).About(drive.AboutArgs{
321 Out: os.Stdout,
322 SizeInBytes: args.Bool("sizeInBytes"),
323 })
324 checkErr(err)
325 }
326
327 func aboutImportHandler(ctx cli.Context) {
328 args := ctx.Args()
329 err := newDrive(args).AboutImport(drive.AboutImportArgs{
330 Out: os.Stdout,
331 })
332 checkErr(err)
333 }
334
335 func aboutExportHandler(ctx cli.Context) {
336 args := ctx.Args()
337 err := newDrive(args).AboutExport(drive.AboutExportArgs{
338 Out: os.Stdout,
339 })
340 checkErr(err)
341 }
342
343 func getOauthClient(args cli.Arguments) (*http.Client, error) {
344 if args.String("refreshToken") != "" && args.String("accessToken") != "" {
345 ExitF("Access token not needed when refresh token is provided")
346 }
347
348 if args.String("refreshToken") != "" {
349 return auth.NewRefreshTokenClient(ClientId, ClientSecret, args.String("refreshToken")), nil
350 }
351
352 if args.String("accessToken") != "" {
353 return auth.NewAccessTokenClient(ClientId, ClientSecret, args.String("accessToken")), nil
354 }
355
356 configDir := getConfigDir(args)
357
358 if args.String("serviceAccount") != "" {
359 serviceAccountPath := ConfigFilePath(configDir, args.String("serviceAccount"))
360 serviceAccountClient, err := auth.NewServiceAccountClient(serviceAccountPath)
361 if err != nil {
362 return nil, err
363 }
364 return serviceAccountClient, nil
365 }
366
367 tokenPath := ConfigFilePath(configDir, TokenFilename)
368 return auth.NewFileSourceClient(ClientId, ClientSecret, tokenPath, authCodePrompt)
369 }
370
371 func getConfigDir(args cli.Arguments) string {
372 // Use dir from environment var if present
373 if os.Getenv("GDRIVE_CONFIG_DIR") != "" {
374 return os.Getenv("GDRIVE_CONFIG_DIR")
375 }
376 return args.String("configDir")
377 }
378
379 func newDrive(args cli.Arguments) *drive.Drive {
380 oauth, err := getOauthClient(args)
381 if err != nil {
382 ExitF("Failed getting oauth client: %s", err.Error())
383 }
384
385 client, err := drive.New(oauth)
386 if err != nil {
387 ExitF("Failed getting drive: %s", err.Error())
388 }
389
390 return client
391 }
392
393 func authCodePrompt(url string) func() string {
394 return func() string {
395 fmt.Println("Authentication needed")
396 fmt.Println("Go to the following url in your browser:")
397 fmt.Printf("%s\n\n", url)
398 fmt.Print("Enter verification code: ")
399
400 var code string
401 if _, err := fmt.Scan(&code); err != nil {
402 fmt.Printf("Failed reading code: %s", err.Error())
403 }
404 return code
405 }
406 }
407
408 func progressWriter(discard bool) io.Writer {
409 if discard {
410 return ioutil.Discard
411 }
412 return os.Stderr
413 }
414
415 func durationInSeconds(seconds int64) time.Duration {
416 return time.Second * time.Duration(seconds)
417 }
418
419 func conflictResolution(args cli.Arguments) drive.ConflictResolution {
420 keepLocal := args.Bool("keepLocal")
421 keepRemote := args.Bool("keepRemote")
422 keepLargest := args.Bool("keepLargest")
423
424 if (keepLocal && keepRemote) || (keepLocal && keepLargest) || (keepRemote && keepLargest) {
425 ExitF("Only one conflict resolution flag can be given")
426 }
427
428 if keepLocal {
429 return drive.KeepLocal
430 }
431
432 if keepRemote {
433 return drive.KeepRemote
434 }
435
436 if keepLargest {
437 return drive.KeepLargest
438 }
439
440 return drive.NoResolution
441 }
442
443 func checkUploadArgs(args cli.Arguments) {
444 if args.Bool("recursive") && args.Bool("delete") {
445 ExitF("--delete is not allowed for recursive uploads")
446 }
447
448 if args.Bool("recursive") && args.Bool("share") {
449 ExitF("--share is not allowed for recursive uploads")
450 }
451 }
452
453 func checkDownloadArgs(args cli.Arguments) {
454 if args.Bool("recursive") && args.Bool("delete") {
455 ExitF("--delete is not allowed for recursive downloads")
456 }
457 }