func (t *Terminal) output() bool {
if t.printQuery {
fmt.Println(string(t.input))
}
if len(t.expect) > 0 {
fmt.Println(t.pressed)
}
found := len(t.selected) > 0
if !found {
cnt := t.merger.Length()
if cnt > 0 && cnt > t.cy {
desc := t.merger.Get(t.cy).AsString(t.ansi)
pair := strings.Split(desc, " - ")
err := open.Run(pair[1])
if err != nil {
println(err)
}
found = true
}
} else {
sels := make([]selectedItem, 0, len(t.selected))
for _, sel := range t.selected {
sels = append(sels, sel)
}
sort.Sort(byTimeOrder(sels))
for _, sel := range sels {
open.Run(*sel.text)
//fmt.Println(*sel.text)
}
}
return found
}
func display(plan string) {
handler := func(w http.ResponseWriter, r *http.Request) {
defer func() {
if recover_string := recover(); recover_string != nil {
error_handler(w, r, http.StatusNotFound)
}
}()
var fileName string
if r.URL.Path == "/" {
fileName = "2048/index.html"
} else {
fileName = "2048/" + r.URL.Path[1:]
}
if _, err := os.Stat(fileName); err == nil {
// File exists
http.ServeFile(w, r, fileName)
} else {
panic(fmt.Sprintf("File not found %s", fileName))
}
}
http.HandleFunc("/", handler)
wg := &sync.WaitGroup{}
wg.Add(1)
go http.ListenAndServe("localhost:8080", nil)
open.Run("http://localhost:8080")
wg.Wait()
}
func (l *Login) HelpCreateToken(e *Env) (string, error) {
for i := 0; i < 4; i++ {
fmt.Fprintf(e.Out, `
Input your account key or press ENTER to generate a new one.
NOTE: on pressing ENTER we'll try to open the url:
%q
in default browser.
`,
keysURL,
)
fmt.Fprintf(e.Out, `Account Key: `)
var token string
fmt.Fscanf(e.In, "%s\n", &token)
token = strings.TrimSpace(token)
if token != "" {
return token, nil
}
err := open.Run(keysURL)
if err != nil {
fmt.Fprintf(e.Err,
`Sorry, we couldn’t open the browser for you.
Go here to generate an account key: %q
`,
keysURL,
)
}
}
return "", stackerr.New("Account key cannot be empty. Please try again.")
}
// openExternalUrl opens an external URL of one of our partners automatically
// at startup if configured to do so. It should only open the first time in
// a given session that Lantern is opened.
func openExternalUrl() {
if openedExternal {
log.Debugf("Not opening external URL again")
return
}
defer func() {
openedExternal = true
}()
path, s, err := packaged.ReadSettings()
if err != nil {
// Let packaged itself log errors as necessary.
log.Debugf("Could not read yaml from %v: %v", path, err)
return
}
var url string
if s.StartupUrl == "" {
return
} else if strings.HasPrefix(s.StartupUrl, "https://www.facebook.com/manototv") {
// Here we make sure to override any old manoto URLs with the latest.
url = "https://www.facebook.com/manototv/app_128953167177144"
} else {
url = s.StartupUrl
}
time.Sleep(4 * time.Second)
err = open.Run(url)
if err != nil {
log.Errorf("Error opening external page to `%v`: %v", uiaddr, err)
}
}
// Show opens the UI in a browser. Note we know the UI server is
// *listening* at this point as long as Start is correctly called prior
// to this method. It may not be reading yet, but since we're the only
// ones reading from those incoming sockets the fact that reading starts
// asynchronously is not a problem.
func Show() {
go func() {
err := open.Run(uiaddr)
if err != nil {
log.Errorf("Error opening page to `%v`: %v", uiaddr, err)
}
if externalUrl != "NO"+"_URL" && !openedExternal {
time.Sleep(4 * time.Second)
err = open.Run(externalUrl)
if err != nil {
log.Errorf("Error opening external page to `%v`: %v", uiaddr, err)
}
openedExternal = true
}
}()
}
func getAccessToken(consumerKey, consumerSecret string) (a AccessToken, err error) {
c := oauth.NewConsumer(
consumerKey,
consumerSecret,
oauth.ServiceProvider{
RequestTokenUrl: "https://api.twitter.com/oauth/request_token",
AuthorizeTokenUrl: "https://api.twitter.com/oauth/authorize",
AccessTokenUrl: "https://api.twitter.com/oauth/access_token",
})
requestToken, url, err := c.GetRequestTokenAndUrl("oob")
if err != nil {
log.Fatal(err)
}
fmt.Println("(1) Go to: " + url)
fmt.Println("(2) Grant access, you should get back a verification code.")
open.Run(url)
fmt.Print("(3) Enter that verification code here: ")
verificationCode := ""
fmt.Scanln(&verificationCode)
authToken, err := c.AuthorizeToken(requestToken, verificationCode)
if err != nil {
log.Fatal(err)
}
a.Token = authToken.Token
a.Secret = authToken.Secret
err = saveAccessToken(a)
return
}
func main() {
err := open.Run(DuckDuckGo + strings.Join(os.Args[1:], Sep))
if err != nil {
log.Panic(err)
}
}
func readDropBoxAppConfig(appName string) (*DropBoxAppConfig, error) {
s := scan.CliScan{
Scans: []scan.Scan{
{Name: "token",
Value: "",
Usage: "please your dropbox accessToken",
Env: "",
},
},
}
ac := appConfig.NewDefaultAppConfig(appName)
data, err := ac.ReadAppConfig()
accessToken := string(data)
if err != nil || accessToken == "" {
// OAuth jump
open.Run(accessTokenURL)
// Scan accessToken
accessToken = s.Scan("token")
// config write
if err := ac.WriteAppConfig([]byte(accessToken)); err != nil {
return nil, err
}
}
return &DropBoxAppConfig{*ac}, nil
}
func main() {
flag.Parse()
if flag.NArg() != 1 {
print_usage(os.Args[0])
os.Exit(1)
}
remotes, err := DetectRemote(flag.Arg(0))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
os.Exit(1)
}
for _, r := range remotes {
url, err := MangleURL(r.Url)
if err != nil {
fmt.Fprintf(os.Stderr, "remote:%s, %s\n", r.Name, err.Error())
continue
}
open.Run(url)
break
}
}
func (plugin OpenPlugin) runServiceOpen(cliConnection plugin.CliConnection, args []string) {
output, err := cliConnection.CliCommandWithoutTerminalOutput("service", args[1], "--guid")
if err != nil {
fmt.Fprintln(os.Stdout, "error: service does not exist")
os.Exit(1)
}
serviceInstanceGUID := strings.TrimSpace(output[0])
output, err = cliConnection.CliCommandWithoutTerminalOutput("curl", fmt.Sprintf("/v2/service_instances/%s", serviceInstanceGUID))
if err != nil {
fmt.Fprintln(os.Stdout, "error: service does not exist")
os.Exit(1)
}
jsonStr := ""
for _, line := range output {
jsonStr += line + "\n"
}
response := serviceInstanceResponse{}
json.Unmarshal([]byte(jsonStr), &response)
url := response.Entity.DashboardURL
if url == "" {
fmt.Println("No dashboard available")
} else {
open.Run(url)
}
}
func init() {
// Filters is the default set of global filters.
revel.Filters = []revel.Filter{
revel.PanicFilter, // Recover from panics and display an error page instead.
revel.RouterFilter, // Use the routing table to select the right Action
revel.FilterConfiguringFilter, // A hook for adding or removing per-Action filters.
revel.ParamsFilter, // Parse parameters into Controller.Params.
revel.SessionFilter, // Restore and write the session cookie.
revel.FlashFilter, // Restore and write the flash cookie.
revel.ValidationFilter, // Restore kept validation errors and save new ones from cookie.
revel.I18nFilter, // Resolve the requested language
HeaderFilter, // Add some security based headers
revel.InterceptorFilter, // Run interceptors around the action.
revel.CompressFilter, // Compress the result.
revel.ActionInvoker, // Invoke the action.
}
// register startup functions with OnAppStart
// ( order dependent )
// revel.OnAppStart(InitDB)
// revel.OnAppStart(FillCache)
// Create a link back to node-webkit using the environment variable
// populated by golang-nw's node-webkit code
revel.OnAppStart(func() { open.Run("http://localhost:9000") })
}
func main() {
var path string
flag.Parse()
if flag.NArg() != 1 {
path = "./"
// print_usage(os.Args[0])
// os.Exit(1)
} else {
path = flag.Arg(0)
}
// remotes, err := DetectRemote(flag.Arg(0))
remotes, err := DetectRemote(path)
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
os.Exit(1)
}
for _, r := range remotes {
url, err := MangleURL(r.Url)
if err != nil {
fmt.Fprintf(os.Stderr, "remote:%s, %s\n", r.Name, err.Error())
continue
}
open.Run(url)
break
}
}
func main() {
input := bufio.NewScanner(os.Stdin)
config := Config{}
config_source, err := ioutil.ReadFile("config.json")
if err != nil {
fmt.Fprintf(os.Stderr, "Can't read config.json: %v\n", err.Error())
os.Exit(1)
}
if err := json.Unmarshal([]byte(config_source), &config); err != nil {
fmt.Fprintf(os.Stderr, "Can't decode config.json: %v\n", err.Error())
os.Exit(1)
}
if config.ClientId == "" {
fmt.Fprintf(os.Stderr, "Invalid client_id in config.json\n")
os.Exit(1)
}
open.Run(fmt.Sprintf("https://oauth.vk.com/authorize?client_id=%s&scope=audio"+
"&redirect_uri=https://oauth.vk.com/blank.html&display=page&response_type=token", config.ClientId))
fmt.Printf("Enter url from browser window:\n")
input.Scan()
oauthResponse := input.Text()
if access_token, err := parseOauthResponse(oauthResponse); err == nil {
downloadMusic(access_token)
} else {
fmt.Fprintf(os.Stderr, "Error: %v\n", err.Error())
os.Exit(1)
}
}
func (ui *tatui) openInTatwebui() {
msg := ui.currentListMessages[ui.selectedPaneMessages][ui.uilists[uiMessages][ui.selectedPaneMessages].position]
base := strings.TrimSpace(viper.GetString("tatwebui-url"))
if base == "" {
ui.msg.Text = "You need to set TatWebui URL in your config file, see /set-tatwebui-url"
ui.render()
return
}
view := "standardview"
// search view setted on topic parameters
for _, p := range ui.currentTopic.Parameters {
if p.Key == "tatwebui.view.restricted" && p.Value != "" {
view = strings.TrimSpace(strings.Replace(p.Value, "-list", "", 1))
break
} else if p.Key == "tatwebui.view.default" && p.Value != "" {
view = strings.TrimSpace(strings.Replace(p.Value, "-list", "", 1))
}
}
if !strings.HasSuffix(base, "/") {
view = "/" + view
}
url := fmt.Sprintf("%s%s/list%s?idMessage=%s", base, view, ui.currentTopic.Topic, msg.ID)
open.Run(url)
}
func handle(conn net.Conn) {
defer conn.Close()
log.Printf("Request from %s", conn.RemoteAddr())
if !firewall.IsAllowed(conn.RemoteAddr()) {
fmt.Fprintf(conn, "Connect is not allowed from %s", conn.RemoteAddr())
return
}
line, err := bufio.NewReader(conn).ReadString('\000')
if err != nil {
log.Println(err)
conn.Write([]byte(err.Error()))
return
}
body := line[:len(line)-1]
err = open.Run(string(body))
if err != nil {
log.Println(err)
conn.Write([]byte(err.Error()))
return
}
}
func doOpen(c *cli.Context) {
remote := c.Args().Get(0)
tree := c.Args().Get(1)
gitconfig, configErr := NewGitConfig()
if configErr != nil {
fmt.Println(configErr)
return
}
if remote == "" {
result, currentBranchErr := gitconfig.RemoteURLFromCurrentBranch()
if currentBranchErr != nil {
fmt.Println(currentBranchErr)
return
}
remote = result
}
githubUrl, remoteURLErr := gitconfig.RemoteURL(remote)
if remoteURLErr != nil {
fmt.Println(remoteURLErr)
}
var openURL string
if tree != "" {
openURL = fmt.Sprintf("%s/tree/%s", githubUrl, tree)
} else {
openURL = githubUrl
}
openErr := open.Run(openURL)
if openErr != nil {
fmt.Println(openErr)
}
}
func main() {
port := flag.Int("p", 8080, "port to listen on")
cache := flag.Bool("c", false, "enable caching")
browser := flag.Bool("b", false, "open browser")
flag.Parse()
directory := flag.Arg(0)
dirPath, err := filepath.Abs(directory)
if err != nil {
panic(err)
}
address := fmt.Sprintf(":%d", *port)
ip, err := externalIP()
if err != nil {
fmt.Println(err)
ip = "0.0.0.0"
}
url := fmt.Sprintf("http://%s%s", ip, address)
fmt.Printf("Serving '%s/' on '%s'\n", dirPath, url)
if *browser {
open.Run(url)
}
// Blocks here
log.Fatal(ServeDir(dirPath, address, *cache))
}
func main() {
flag.Parse()
data := Data{
"SVG -> PDF",
time.Now().Format("_2 Jan 2006 15:04:05"),
20150803,
"Строка кириллицей",
true,
}
var err error
// Load template from file
template, err := template.ParseFiles(*inputFile)
chk(err)
// Store template to buffer
buf := new(bytes.Buffer)
err = template.Execute(buf, data)
chk(err)
// Convert via external application
// Install before use
// # apt-get install librsvg2-bin
// or
// # apt-get install inkscape
var cmd *exec.Cmd
if *converter == "inkscape" {
fmt.Println("Generate via inkscape")
cmd = exec.Command("inkscape", "--without-gui", "/dev/stdin", "--export-pdf=/dev/stdout")
if *outputPng != "" {
cmd.Args = append(cmd.Args, "--export-png", *outputPng)
}
} else {
fmt.Println("Generate via rsvg-convert")
cmd = exec.Command("rsvg-convert", "-f", "pdf")
}
cmd.Stdin = bytes.NewReader(buf.Bytes())
// Write pdf to file
out, err := os.OpenFile(*outputFile, os.O_CREATE|os.O_WRONLY, 0666)
chk(err)
defer out.Close()
cmd.Stdout = out
timeStart := time.Now().UnixNano()
err = cmd.Run() // Syncronous run external application
chk(err)
timeEnd := time.Now().UnixNano()
fmt.Println("Conversion time (ms)", (timeEnd-timeStart)/1000000)
// Open output file using the OS's default application
open.Run(*outputFile)
}
func main() {
cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
out, e := cmd.Output()
failOnError(e)
val := strings.Trim(string(out), "f/#")
open.Run("https://192.168.100.1/redmine/issues/" + val)
}
func (u *URI) Open(param *param.OpenParam, _ *struct{}) error {
conn := <-connCh
uri := param.URI
if param.TransLoopback {
uri = u.translateLoopbackIP(param.URI, conn)
}
return open.Run(uri)
}
// Show opens the UI in a browser. Note we know the UI server is
// *listening* at this point as long as Start is correctly called prior
// to this method. It may not be reading yet, but since we're the only
// ones reading from those incoming sockets the fact that reading starts
// asynchronously is not a problem.
func Show() {
go func() {
err := open.Run(uiaddr)
if err != nil {
log.Errorf("Error opening page to `%v`: %v", uiaddr, err)
}
openExternalUrl()
}()
}
func main() {
if len(os.Args) != 2 {
fmt.Fprintln(os.Stderr, "qiita-go [word]")
os.Exit(1)
}
word := os.Args[1]
url := "http://qiita.com/search?utf8=✓&sort=rel&q=" + word
open.Run(url)
}
func configureOA() {
oa_url := base_url + "?scope=" + scope + "&client_id=" + client_id
output("Creating token request for Slackcat")
err := open.Run(oa_url)
if err != nil {
output("Please open the below URL in your browser to authorize SlackCat")
output(oa_url)
}
}
func AuthUser(entity string, postType string) (client *tent.Client, err error) {
var meta *tent.MetaPost
// meta post
meta, err = tent.Discover(entity)
if err != nil {
return
}
client = &tent.Client{Servers: meta.Servers}
// app post
post := tent.NewAppPost(&tent.App{
Name: "Tent Scrobbler",
URL: "https://app.example.com",
Types: tent.AppTypes{
Write: []string{postType},
},
RedirectURI: "https://app.example.com/oauth",
Scopes: []string{"permissions"},
})
err = client.CreatePost(post)
if err != nil {
return
}
// credentials
client.Credentials, _, err = post.LinkedCredentials()
if err != nil {
return
}
// redirect url
oauthURL := meta.Servers[0].URLs.OAuthURL(post.ID, "randomState")
fmt.Println("accept the authorisation request and paste the code back in")
err = open.Run(oauthURL)
if err != nil {
return
}
// input code
var code string
_, err = fmt.Scanf("%s", &code)
if err != nil {
return
}
// request access token
client.Credentials, err = client.RequestAccessToken(code)
if err != nil {
return
}
return client, nil
}
func (this *DbDumperManager) ShowDumpFromInstanceName(serviceInstance string, recent bool, dumpDateOrNumber string, seeAllDumps bool, tags string) error {
selectedDump, err := this.selectDump(serviceInstance, recent, dumpDateOrNumber, seeAllDumps, tags)
if err != nil {
return err
}
if selectedDump.ShowURL == "" {
return errors.New("This dump cannot be showed, generally this mean that the file is only in binary.")
}
return open.Run(selectedDump.ShowURL)
}
func (o *Orange) Run(files ...string) {
o.httpServer = NewHTTPServer(o.port)
o.httpServer.Listen()
for _, file := range files {
addr := fmt.Sprintf("http://localhost:%d/%s", o.port, file)
open.Run(addr)
}
<-o.stop
}
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("Quit 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
restart("")
}()
// go func() {
// <-mQuit.ClickedCh
// systray.Quit()
// exit()
// }()
go func() {
<-mDebug.ClickedCh
open.Run("http://localhost:8989")
logAction("log on")
}()
// We can manipulate the systray in other goroutines
go func() {
<-mUrl.ClickedCh
open.Run("http://create-staging.arduino.cc")
}()
}
func Authorize(tokenDir, tokenFile string) {
err := os.MkdirAll(tokenDir, 0777)
if err != nil {
fmt.Printf("Failed to create directory for the token at %s\n", tokenDir)
}
cachefile := filepath.Join(tokenDir, tokenFile)
if clientId == "" {
clientId = productionClientId
}
if clientSecret == "" {
clientSecret = productionClientSecret
}
config := &oauth.Config{
ClientId: clientId,
ClientSecret: clientSecret,
RedirectURL: redirectURL,
Scope: scope,
AuthURL: authURL,
TokenURL: tokenURL,
TokenCache: oauth.CacheFile(cachefile),
}
transport := &oauth.Transport{Config: config}
_, err = config.TokenCache.Token()
// do we already have access?
if err != nil {
url := config.AuthCodeURL("")
e := open.Run(url)
if e != nil {
fmt.Printf("Counldn't open the browser because %s\n", e.Error())
fmt.Println("Please open the following URL in your browser and paste the access code here:")
fmt.Println(url)
} else {
fmt.Println("Openning the browser so you can approve the client access")
}
var s string
fmt.Println("Authorization Code:")
fmt.Scan(&s)
_, err := transport.Exchange(s)
if err != nil {
log.Fatal("Exchange:", err)
}
fmt.Printf("Token is cached in %v\n", config.TokenCache)
os.Exit(1)
}
}
func openSnippetWithEditor(s *Snippet) {
if len(conf.Editor) > 0 {
err := open.RunWith(s.Path, conf.Editor)
if err != nil {
log.Fatalf("can't open %s with %s. please check your settings.", s.Path, conf.Editor)
}
} else {
err := open.Run(s.Path)
if err != nil {
log.Fatalf("can't open %s. please check your settings.", s.Path)
}
}
}
func configureOA() {
oa_url := base_url + "?scope=" + scope + "&client_id=" + client_id
output("Creating token request for Slackcat")
err := open.Run(oa_url)
if err != nil {
output("Please open the below URL in your browser to authorize SlackCat")
output(oa_url)
}
// _, err := fmt.Scanf("%s", &i)
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
failOnError(err, "", true)
fmt.Println(dir)
os.Exit(0)
}