func main() {
usr, err := user.Current()
if err != nil {
log.Fatal(err)
}
cache := filepath.Join(usr.HomeDir, ".ak", "news")
flag.Parse()
if flag.NArg() > 0 {
idx, e := strconv.ParseInt(flag.Arg(0), 0, 0)
if e != nil {
// not int
}
item := getItem(cache, idx)
if comment {
open.Start(fmt.Sprintf("%s%s%d", HACKERWEB, "/#/item/", item.ID))
} else {
open.Start(item.URL)
}
} else {
if next {
var news []Item
res, err := http.Get(NEWS2)
if err != nil {
log.Fatal(err)
}
bytes, err := ioutil.ReadAll(res.Body)
if err != nil {
log.Fatal(err)
}
res.Body.Close()
populateCache(cache, bytes)
contents := string(bytes)
err = json.NewDecoder(strings.NewReader(contents)).Decode(&news)
if err != nil {
log.Fatal(err)
}
showNewsList(news)
} else {
var news []Item
res, err := http.Get(NEWS)
if err != nil {
log.Fatal(err)
}
bytes, err := ioutil.ReadAll(res.Body)
if err != nil {
log.Fatal(err)
}
res.Body.Close()
populateCache(cache, bytes)
contents := string(bytes)
err = json.NewDecoder(strings.NewReader(contents)).Decode(&news)
showNewsList(news)
}
}
}
// Our programs starts executing here
func main() {
// We need exactly 2 parameters: the first one is the program name,
// the second one should be the photo we want to operate on
if len(os.Args) != 2 {
fmt.Println("Please give a single file name as an argument!")
os.Exit(1)
}
// Retrieve the photo file name from the arguments array
fileName := os.Args[1]
// Try to opern the given file, error out on failure
file, err := os.Open(fileName)
exitOnError(err, "Couldn't open file")
// Try to extract the EXIF data, error out on failure
exifData, err := exif.Decode(file)
exitOnError(err, "Couldn't find EXIF data")
// Try to find a GPS coordinates entry in the EXIF data structure.
// Error out on failure
lat, long, err := exifData.LatLong()
exitOnError(err, "Couldn't read GPS coordinates")
// Create the final URL by using the Google Maps URL template
url := fmt.Sprintf(googleMapsURLTemplate, lat, long)
// Try to start the default browser for the current OS.
// Show the computer URL on error, so that the user can still
// access it manually
err = open.Start(url)
exitOnError(err, fmt.Sprintf(
"Couldn't start the default browser, please visit %v manually", url))
}
func (g *Commands) QR(byId bool) error {
kvChan := g.urler(byId, g.opts.Sources)
address := DefaultQRShareServer
if g.opts.Meta != nil {
meta := *(g.opts.Meta)
if retrAddress, ok := meta[AddressKey]; ok && len(retrAddress) >= 1 {
address = retrAddress[0]
}
}
address = strings.TrimRight(address, "/")
if envKeySet.PublicKey == "" {
envKeySet.PublicKey = "5160897b3586461e83e7279c10352ac4"
}
if envKeySet.PrivateKey == "" {
envKeySet.PrivateKey = "5a3451dadab74f75b16f754c0a931949"
}
for kv := range kvChan {
switch kv.value.(type) {
case error:
g.log.LogErrf("%s: %s\n", kv.key, kv.value)
continue
}
fileURI, ok := kv.value.(string)
if !ok {
continue
}
curTime := time.Now()
pl := meddler.Payload{
URI: fileURI,
RequestTime: curTime.Unix(),
Payload: fmt.Sprintf("%v%v", rand.Float64(), curTime),
PublicKey: envKeySet.PublicKey,
ExpiryTime: curTime.Add(time.Hour).Unix(),
}
plainTextToSign := pl.RawTextForSigning()
pl.Signature = fmt.Sprintf("%s", envKeySet.Sign([]byte(plainTextToSign)))
uv := pl.ToUrlValues()
encodedValues := uv.Encode()
fullUrl := fmt.Sprintf("%s/qr?%s", address, encodedValues)
if g.opts.Verbose {
g.log.Logf("%q => %q\n", kv.key, fullUrl)
}
if err := open.Start(fullUrl); err != nil {
g.log.Logf("qr: err %v %q\n", err, fullUrl)
}
}
return nil
}
func showQRImage(uuid string) (err error) {
qrUrl := `https://login.weixin.qq.com/qrcode/` + uuid
params := url.Values{}
params.Set("t", "webwx")
params.Set("_", strconv.FormatInt(time.Now().Unix(), 10))
req, err := http.NewRequest("POST", qrUrl, strings.NewReader(params.Encode()))
if err != nil {
return
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Cache-Control", "no-cache")
resp, err := Client.Do(req)
if err != nil {
return
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return
}
if err = createFile(QRImagePath, data, false); err != nil {
return
}
return open.Start(QRImagePath)
}
func (g *Commands) Open(ot OpenType) error {
byId := (ot & IdOpen) != 0
kvChan := g.urler(byId)
for kv := range kvChan {
switch kv.value.(type) {
case error:
g.log.LogErrf("%s: %s\n", kv.key, kv.value)
continue
}
openArgs := []string{}
canAddUrl := (ot & BrowserOpen) != 0
if byId {
canAddUrl = true
} else if (ot & FileManagerOpen) != 0 {
openArgs = append(openArgs, g.context.AbsPathOf(kv.key))
}
if canAddUrl {
if castKey, ok := kv.value.(string); ok {
openArgs = append(openArgs, castKey)
}
}
for _, arg := range openArgs {
open.Start(arg)
}
}
return nil
}
func run(dir, port, host string) {
open.Start(host)
fmt.Println("-> Listening on ", host)
fmt.Println("-> Press ctrl-c to kill process")
http.CloseIdleConnections()
log.Fatal(http.ListenAndServe(port, http.FileServer(http.Dir(dir))))
}
func setupSysTrayReal() {
systray.SetIcon(icon.Data)
mUrl := systray.AddMenuItem("Go to Arduino Create (staging)", "Arduino Create")
mDebug := systray.AddMenuItem("Open debug console", "Debug console")
menuVer := systray.AddMenuItem("Agent version "+version+"-"+git_revision, "")
mPause := systray.AddMenuItem("Pause Plugin", "")
//mQuit := systray.AddMenuItem("Quit Plugin", "")
menuVer.Disable()
go func() {
<-mPause.ClickedCh
ports, _ := serial.GetPortsList()
for _, element := range ports {
spClose(element)
}
systray.Quit()
*hibernate = true
log.Println("Restart becayse setup went wrong?")
restart("")
}()
// go func() {
// <-mQuit.ClickedCh
// systray.Quit()
// exit()
// }()
go func() {
for {
<-mDebug.ClickedCh
logAction("log on")
open.Start("http://localhost" + port)
}
}()
// We can manipulate the systray in other goroutines
go func() {
for {
<-mUrl.ClickedCh
open.Start("http://create-staging.arduino.cc")
}
}()
}
func main() {
nc, _ := nats.Connect("nats://yourhost:4222")
defer nc.Close()
nc.QueueSubscribe(TOPIC, QUEUE, func(m *nats.Msg) {
fmt.Println(string(m.Data))
open.Start(string(m.Data))
})
select {}
}
func main() {
flag.Parse()
url := template.URLQueryEscaper(flag.Args())
url = fmt.Sprintf("http://52.68.184.19:8080/search/%s", url)
fmt.Printf("open %s\n", url)
open.Start(url)
}
func webui() {
goji.Get("/", index)
goji.Get("/result/diff.txt", generateResult)
goji.Post("/diff", PostDiff)
//Fully backwards compatible with net/http's Handlers
//goji.Get("/result", http.RedirectHandler("/", 301))
if os.Getenv("DEBUG") == "" {
time.AfterFunc(500*time.Millisecond, func() {
open.Start("http://localhost:8000")
})
}
goji.Serve()
}
func docPlugin(c *cli.Context) {
if len(c.Args()) != 1 {
fmt.Printf("Which documentation do you want to open? Try 'apiplexy plugin-doc <plugin-name>'.\n")
os.Exit(1)
}
plugin, ok := apiplexy.AvailablePlugins()[c.Args()[0]]
if !ok {
fmt.Printf("Plugin '%s' not found. Try 'apiplexy plugins' to list available ones.\n", c.Args()[0])
os.Exit(1)
}
fmt.Printf("Opening documentation for '%s' at: %s\n", plugin.Name, plugin.Link)
open.Start(plugin.Link)
}
func doOpen(flags *flag.FlagSet) {
args := flags.Args()
branch, err := getBranchFromArgs(args)
checkError(err)
remote, err := git.GetRemoteURL("origin")
checkError(err)
cr, err := circle.GetTree(remote.Path, remote.RepoName, branch)
checkError(err)
if len(*cr) == 0 {
fmt.Printf("No results, are you sure there are tests for %s/%s?\n",
remote.Path, remote.RepoName)
return
}
latestBuild := (*cr)[0]
open.Start(latestBuild.BuildURL)
}
func main() {
title := flag.String("title", "", "Optional Title")
script := flag.String("script", "", "lua script to filter/enrich data")
laddr := flag.String("addr", "", "Address on which to serve up the map")
flag.Usage = func() {
fmt.Fprintln(os.Stderr, usage)
flag.PrintDefaults()
}
flag.Parse()
if *script != "" {
if _, err := os.Stat(*script); os.IsNotExist(err) {
log.Fatal(err)
}
}
http.HandleFunc("/gidata", handleGIData)
http.Handle("/resources/", http.FileServer(rice.MustFindBox("public").HTTPBox()))
http.HandleFunc("/", serveIndex(*title))
/* Get the address from the command line or the environment */
address := *laddr
if "" == address {
address = os.Getenv("GIM_ADDR")
}
/* Failing that, use an ephemeral port on loopback */
if "" == address {
address = "127.0.0.1:0"
}
/* If it's a single port, prepend a localhost */
if _, err := strconv.Atoi(address); nil == err {
address = "127.0.0.1:" + address
}
go readStdin(*script)
l, err := net.Listen("tcp", address)
if err != nil {
log.Fatal(err)
}
go func() {
addr := fmt.Sprintf("http://%s", l.Addr())
log.Printf("Listening on %v\n", addr)
open.Start(addr)
}()
log.Fatal(http.Serve(l, nil))
}
func execCmd(c *cli.Context) {
if len(c.Args()) < 1 {
fmt.Println("Specify Markdown file")
return
}
/* open webbrowser */
open.Start("http://0.0.0.0:8089")
ch := make(chan string)
gChan = make(chan string)
targetFileName = c.Args()[0]
go fileWatcher(ch)
/* for static files */
staticFilePath := path.Join(os.Getenv("GOPATH"), "src/github.com/hhatto/ftcat/static")
fs := http.FileServer(http.Dir(staticFilePath))
http.Handle("/static/", http.StripPrefix("/static/", fs))
/* index */
http.HandleFunc("/", indexHandler)
/* server sent events */
es := eventsource.New(nil, nil)
defer es.Close()
http.Handle("/events", es)
/* message broker */
go func() {
id := 1
for {
select {
case n := <-ch:
es.SendEventMessage(n, "cre", strconv.Itoa(id))
id++
case n := <-gChan:
es.SendEventMessage(n, "cre", strconv.Itoa(id))
id++
}
}
}()
log.Fatal(http.ListenAndServe(":8089", nil))
}
func DoOpen(c *cli.Context) {
useOptions(c)
dest := c.Args().First()
log.Debugf("Open destination: %s", dest)
url := ""
message := ""
switch dest {
default:
fallthrough
case "deployed":
app, err := account.GetCurrentApp()
if err != nil {
message = "Sorry, could not find a deployed app to open."
}
url = "http://" + app.HostingSubdomain + ".appstax.io"
break
case "admin":
url = "http://appstax.com/admin/#/dashboard"
break
case "local":
url = "http://localhost:9000/"
break
}
if url != "" {
term.Printf("Opening %s in your browser.\n", url)
err := open.Start(url)
if err != nil {
message = "Ooops! Something went wrong."
}
}
if message != "" {
term.Section()
term.Println(message)
}
}
func openBrowser() {
url := "http://" + host + "/tour.html"
tries := 0
for {
if tries > 100 {
fmt.Println("giving up after ", time.Duration(tries)*100*time.Microsecond)
os.Exit(1)
}
<-time.After(10 * time.Microsecond)
if _, err := http.Get(url); err == nil {
println("Opening " + url)
fmt.Println(open.Start(url))
return
}
tries++
}
}
// Auth user against selected provider and return AccessToken
func Auth(provider string) AccessToken {
port := "7777"
go func() {
log.Infof("Starting HTTP server on 0.0.0.0:%s...", port)
http.HandleFunc("/oauth2", processOAuth)
http.HandleFunc("/store", persistToken)
if err := http.ListenAndServe(":"+port, nil); err != nil {
log.WithField("error", err).Fatal("Unable to create listener")
}
}()
if provider == "bitbucket.org" {
log.Infof("Please authenticate yourself within [%s] provider in opened browser window ...", provider)
wg.Add(1)
open.Start("https://bitbucket.org/site/oauth2/authorize?client_id=FUGTa554rDNASAzdBg&response_type=token")
}
wg.Wait()
return accessToken
}
// OpenInBrowser stores the html under "<name><date>.html" in the current
// directory and opens it in the browser
func OpenInBrowser(name string, html string) error {
pwd, err := os.Getwd()
if err != nil {
fmt.Println(err)
}
fmt.Println("PWD", pwd)
//path := "file://" + pwd + "/" + "diff.html"
path := pwd + "/" + "diff-" + name + "_" + GetFormattedTimeShort(time.Now()) + ".html"
fmt.Println("PATH", path)
tmpFile, err := os.Create(path)
if err != nil {
return err
}
tmpFile.WriteString(html)
tmpFile.Close()
err = open.Start(path)
if err != nil {
log.Println(err)
}
return err
}
func main() {
flag.StringVar(&presently.Dir, "d", "", "Directory of the repository")
flag.StringVar(&presently.Port, "p", "8080", "Port to listen")
flag.Parse()
var args = flag.Args()
if presently.Dir == "" {
if len(args) == 0 {
fmt.Println("You need to specify -dir")
flag.PrintDefaults()
os.Exit(0)
} else {
presently.Dir = args[0]
}
}
go func() {
url := "http://localhost:" + presently.Port
time.Sleep(400 * time.Millisecond)
open.Start(url)
}()
presently.Serve()
}
func (b Bopen) Open(url string) {
open.Start(url)
}
// Config does the initial creation of the token
//
// It may run an internal webserver to receive the results
func Config(name string, config *oauth2.Config) error {
overrideCredentials(name, config)
// See if already have a token
tokenString := fs.ConfigFile.MustValue(name, "token")
if tokenString != "" {
fmt.Printf("Already have a token - refresh?\n")
if !fs.Confirm() {
return nil
}
}
// Detect whether we should use internal web server
useWebServer := false
switch config.RedirectURL {
case RedirectURL, RedirectPublicURL, RedirectLocalhostURL:
useWebServer = true
case TitleBarRedirectURL:
fmt.Printf("Use auto config?\n")
fmt.Printf(" * Say Y if not sure\n")
fmt.Printf(" * Say N if you are working on a remote or headless machine or Y didn't work\n")
useWebServer = fs.Confirm()
if useWebServer {
// copy the config and set to use the internal webserver
configCopy := *config
config = &configCopy
config.RedirectURL = RedirectURL
}
}
// Make random state
stateBytes := make([]byte, 16)
_, err := rand.Read(stateBytes)
if err != nil {
return err
}
state := fmt.Sprintf("%x", stateBytes)
authURL := config.AuthCodeURL(state)
// Prepare webserver
server := authServer{
state: state,
bindAddress: bindAddress,
authURL: authURL,
}
if useWebServer {
server.code = make(chan string, 1)
go server.Start()
defer server.Stop()
authURL = "http://" + bindAddress + "/auth"
}
// Generate a URL for the user to visit for authorization.
_ = open.Start(authURL)
fmt.Printf("If your browser doesn't open automatically go to the following link: %s\n", authURL)
fmt.Printf("Log in and authorize rclone for access\n")
var authCode string
if useWebServer {
// Read the code, and exchange it for a token.
fmt.Printf("Waiting for code...\n")
authCode = <-server.code
if authCode != "" {
fmt.Printf("Got code\n")
} else {
return fmt.Errorf("Failed to get code")
}
} else {
// Read the code, and exchange it for a token.
fmt.Printf("Enter verification code> ")
authCode = fs.ReadLine()
}
token, err := config.Exchange(oauth2.NoContext, authCode)
if err != nil {
return fmt.Errorf("Failed to get token: %v", err)
}
return putToken(name, token)
}
func (u *fireflyUI) open(url string) {
open.Start(url)
}
func (u *fireflyUI) show() {
open.Start(u.settingsUrl)
}
// OpenUrl will open a file, directory, or URI using the OS's default application
// for that object type.
//
// See github.com/skratchdot/open-golang
func OpenUrl(url string) {
open.Start(url)
}
func main() {
flag.Usage = func() {
usage()
}
flag.Parse()
util.InitLogs()
defer util.FlushLogs()
verflag.PrintAndExitIfRequested()
// Initialize the client
if clientConfig.Host == "" {
clientConfig.Host = os.Getenv("KUBERNETES_MASTER")
}
// Load namespace information for requests
// Check if the namespace was overriden by the -ns argument
ctx := api.NewDefaultContext()
if len(*ns) > 0 {
ctx = api.WithNamespace(ctx, *ns)
} else {
nsInfo, err := kubecfg.LoadNamespaceInfo(*nsFile)
if err != nil {
glog.Fatalf("Error loading current namespace: %v", err)
}
ctx = api.WithNamespace(ctx, nsInfo.Namespace)
}
if clientConfig.Host == "" {
// TODO: eventually apiserver should start on 443 and be secure by default
// TODO: don't specify http or https in Host, and infer that from auth options.
clientConfig.Host = "http://localhost:8080"
}
if client.IsConfigTransportTLS(*clientConfig) {
auth, err := kubecfg.LoadClientAuthInfoOrPrompt(*authConfig, os.Stdin)
if err != nil {
glog.Fatalf("Error loading auth: %v", err)
}
clientConfig.Username = auth.User
clientConfig.Password = auth.Password
if auth.CAFile != "" {
clientConfig.CAFile = auth.CAFile
}
if auth.CertFile != "" {
clientConfig.CertFile = auth.CertFile
}
if auth.KeyFile != "" {
clientConfig.KeyFile = auth.KeyFile
}
if auth.BearerToken != "" {
clientConfig.BearerToken = auth.BearerToken
}
if auth.Insecure != nil {
clientConfig.Insecure = *auth.Insecure
}
}
kubeClient, err := client.New(clientConfig)
if err != nil {
glog.Fatalf("Can't configure client: %v", err)
}
if *serverVersion != verflag.VersionFalse {
got, err := kubeClient.ServerVersion()
if err != nil {
fmt.Printf("Couldn't read version from server: %v\n", err)
os.Exit(1)
}
if *serverVersion == verflag.VersionRaw {
fmt.Printf("%#v\n", *got)
os.Exit(0)
} else {
fmt.Printf("Server: Kubernetes %s\n", got)
os.Exit(0)
}
}
if *preventSkew {
got, err := kubeClient.ServerVersion()
if err != nil {
fmt.Printf("Couldn't read version from server: %v\n", err)
os.Exit(1)
}
if c, s := version.Get(), *got; !reflect.DeepEqual(c, s) {
fmt.Printf("Server version (%#v) differs from client version (%#v)!\n", s, c)
os.Exit(1)
}
}
if *proxy {
glog.Info("Starting to serve on localhost:8001")
if *openBrowser {
go func() {
time.Sleep(2 * time.Second)
open.Start("http://localhost:8001/static/")
}()
}
server, err := kubecfg.NewProxyServer(*www, clientConfig)
if err != nil {
glog.Fatalf("Error creating proxy server: %v", err)
}
glog.Fatal(server.Serve())
}
if len(flag.Args()) < 1 {
usage()
os.Exit(1)
}
method := flag.Arg(0)
matchFound := executeAPIRequest(ctx, method, kubeClient) || executeControllerRequest(ctx, method, kubeClient) || executeNamespaceRequest(method, kubeClient)
if matchFound == false {
glog.Fatalf("Unknown command %s", method)
}
}
// RunInspect is the handler for 'scw inspect'
func RunInspect(ctx CommandContext, args InspectArgs) error {
nbInspected := 0
ci := make(chan api.ScalewayResolvedIdentifier)
cj := make(chan api.InspectIdentifierResult)
go api.ResolveIdentifiers(ctx.API, args.Identifiers, ci)
go api.InspectIdentifiers(ctx.API, ci, cj)
if args.Browser {
// --browser will open links in the browser
for {
data, isOpen := <-cj
if !isOpen {
break
}
switch data.Type {
case api.IdentifierServer:
err := open.Start(fmt.Sprintf("https://cloud.scaleway.com/#/servers/%s", data.Object.(*api.ScalewayServer).Identifier))
if err != nil {
return fmt.Errorf("cannot open browser: %v", err)
}
nbInspected++
case api.IdentifierImage:
err := open.Start(fmt.Sprintf("https://cloud.scaleway.com/#/images/%s", data.Object.(*api.ScalewayImage).Identifier))
if err != nil {
return fmt.Errorf("cannot open browser: %v", err)
}
nbInspected++
case api.IdentifierVolume:
err := open.Start(fmt.Sprintf("https://cloud.scaleway.com/#/volumes/%s", data.Object.(*api.ScalewayVolume).Identifier))
if err != nil {
return fmt.Errorf("cannot open browser: %v", err)
}
nbInspected++
case api.IdentifierSnapshot:
logrus.Errorf("Cannot use '--browser' option for snapshots")
case api.IdentifierBootscript:
logrus.Errorf("Cannot use '--browser' option for bootscripts")
}
}
} else {
// without --browser option, inspect will print object info to the terminal
res := "["
for {
data, isOpen := <-cj
if !isOpen {
break
}
if args.Format == "" {
dataB, err := json.MarshalIndent(data.Object, "", " ")
if err == nil {
if nbInspected != 0 {
res += ",\n"
}
res += string(dataB)
nbInspected++
}
} else {
tmpl, err := template.New("").Funcs(api.FuncMap).Parse(args.Format)
if err != nil {
return fmt.Errorf("format parsing error: %v", err)
}
err = tmpl.Execute(ctx.Stdout, data.Object)
if err != nil {
return fmt.Errorf("format execution error: %v", err)
}
fmt.Fprint(ctx.Stdout, "\n")
nbInspected++
}
}
res += "]"
if args.Format == "" {
if ctx.Getenv("SCW_SENSITIVE") != "1" {
res = ctx.API.HideAPICredentials(res)
}
fmt.Fprintln(ctx.Stdout, res)
}
}
if len(args.Identifiers) != nbInspected {
return fmt.Errorf("at least 1 item failed to be inspected")
}
return nil
}
port int
)
var serverCmd = &cobra.Command{
Use: "server",
Short: "host the generated site locally",
Long: `host the generated site locally so that you could look and feel it before pushing`,
Run: func(cmd *cobra.Command, args []string) {
addr := fmt.Sprintf(":%d", port)
url := fmt.Sprintf("http://localhost:%d/index.html", port)
go func() {
time.Sleep(1)
log.Printf("Starting your default browser with %s\n", url)
open.Start(url)
}()
processSignal(watchFiles())
log.Printf("Serving static content on %s\n", addr)
http.ListenAndServe(addr, http.FileServer(http.Dir("./build")))
},
}
func init() {
serverCmd.Flags().IntVarP(&port, "port", "p", DEFAULT_PORT, "port to listen")
}
func processSignal(watcher *fsnotify.Watcher) {
func OpenBrowser(args []string) {
err := open.Start(args[0])
if err != nil {
fatal("Can't open browser: '" + err.Error())
}
}
func main() {
port := info.Port()
log.Println("Listening on port " + port)
open.Start("http://127.0.0.1:" + port)
http.ListenAndServe(":"+port, router.Routes())
}
// Config does the initial creation of the token
//
// It may run an internal webserver to receive the results
func Config(id, name string, config *oauth2.Config) error {
changed := overrideCredentials(name, config)
automatic := fs.ConfigFile.MustValue(name, fs.ConfigAutomatic) != ""
// See if already have a token
tokenString := fs.ConfigFile.MustValue(name, "token")
if tokenString != "" {
fmt.Printf("Already have a token - refresh?\n")
if !fs.Confirm() {
return nil
}
}
// Detect whether we should use internal web server
useWebServer := false
switch config.RedirectURL {
case RedirectURL, RedirectPublicURL, RedirectLocalhostURL:
useWebServer = true
if automatic {
break
}
fmt.Printf("Use auto config?\n")
fmt.Printf(" * Say Y if not sure\n")
fmt.Printf(" * Say N if you are working on a remote or headless machine\n")
auto := fs.Confirm()
if !auto {
fmt.Printf("For this to work, you will need rclone available on a machine that has a web browser available.\n")
fmt.Printf("Execute the following on your machine:\n")
if changed {
fmt.Printf("\trclone authorize %q %q %q\n", id, config.ClientID, config.ClientSecret)
} else {
fmt.Printf("\trclone authorize %q\n", id)
}
fmt.Println("Then paste the result below:")
code := ""
for code == "" {
fmt.Printf("result> ")
code = strings.TrimSpace(fs.ReadLine())
}
token := &oauth2.Token{}
err := json.Unmarshal([]byte(code), token)
if err != nil {
return err
}
return putToken(name, token)
}
case TitleBarRedirectURL:
useWebServer = automatic
if !automatic {
fmt.Printf("Use auto config?\n")
fmt.Printf(" * Say Y if not sure\n")
fmt.Printf(" * Say N if you are working on a remote or headless machine or Y didn't work\n")
useWebServer = fs.Confirm()
}
if useWebServer {
// copy the config and set to use the internal webserver
configCopy := *config
config = &configCopy
config.RedirectURL = RedirectURL
}
}
// Make random state
stateBytes := make([]byte, 16)
_, err := rand.Read(stateBytes)
if err != nil {
return err
}
state := fmt.Sprintf("%x", stateBytes)
authURL := config.AuthCodeURL(state)
// Prepare webserver
server := authServer{
state: state,
bindAddress: bindAddress,
authURL: authURL,
}
if useWebServer {
server.code = make(chan string, 1)
go server.Start()
defer server.Stop()
authURL = "http://" + bindAddress + "/auth"
}
// Generate a URL for the user to visit for authorization.
_ = open.Start(authURL)
fmt.Printf("If your browser doesn't open automatically go to the following link: %s\n", authURL)
fmt.Printf("Log in and authorize rclone for access\n")
var authCode string
if useWebServer {
// Read the code, and exchange it for a token.
fmt.Printf("Waiting for code...\n")
authCode = <-server.code
if authCode != "" {
fmt.Printf("Got code\n")
} else {
return errors.New("failed to get code")
}
} else {
// Read the code, and exchange it for a token.
fmt.Printf("Enter verification code> ")
authCode = fs.ReadLine()
}
token, err := config.Exchange(oauth2.NoContext, authCode)
if err != nil {
return errors.Wrap(err, "failed to get token")
}
// Print code if we do automatic retrieval
if automatic {
result, err := json.Marshal(token)
if err != nil {
return errors.Wrap(err, "failed to marshal token")
}
fmt.Printf("Paste the following into your remote machine --->\n%s\n<---End paste", result)
}
return putToken(name, token)
}