func pullInit() { hostname, err := os.Hostname() if err != nil { // Never call glog before common.Init*. os.Exit(1) } common.InitWithMetrics("pulld."+hostname, graphiteServer) glog.Infof("Running with hostname: %s", hostname) client, err := auth.NewDefaultJWTServiceAccountClient(storage.DevstorageFullControlScope, compute.ComputeReadonlyScope) if err != nil { glog.Fatalf("Failed to create authenticated HTTP client: %s", err) } glog.Info("Got authenticated client.") store, err = storage.New(client) if err != nil { glog.Fatalf("Failed to create storage service client: %s", err) } step(client, store, hostname) timeCh := time.Tick(time.Second * 60) go func() { for { select { case <-timeCh: case <-httpTriggerCh: } step(client, store, hostname) } }() }
func setupOAuth() error { client, err := auth.NewDefaultJWTServiceAccountClient(auth.SCOPE_READ_WRITE) if err != nil { return fmt.Errorf("Problem setting up client OAuth: %v", err) } if storageClient, err = storage.NewClient(context.Background(), cloud.WithBaseHTTP(client)); err != nil { return fmt.Errorf("Problem authenticating: %v", err) } return nil }
func setupOAuth() error { client, err := auth.NewDefaultJWTServiceAccountClient(auth.SCOPE_READ_WRITE) if err != nil { return fmt.Errorf("Problem setting up client OAuth: %v", err) } if storageService, err = storage.New(client); err != nil { return fmt.Errorf("Problem authenticating: %v", err) } return nil }
func main() { defer common.LogPanic() common.InitWithMetrics("probeserver", graphiteServer) client, err := auth.NewDefaultJWTServiceAccountClient("https://www.googleapis.com/auth/userinfo.email") if err != nil { glog.Fatalf("Failed to create client for talking to the issue tracker: %s", err) } go monitorIssueTracker(client) glog.Infoln("Looking for Graphite server.") addr, err := net.ResolveTCPAddr("tcp", *graphiteServer) if err != nil { glog.Fatalln("Failed to resolve the Graphite server: ", err) } glog.Infoln("Found Graphite server.") liveness := imetrics.NewLiveness("probes") // We have two sets of metrics, one for the probes and one for the probe // server itself. The server's metrics are handled by common.Init() probeRegistry := metrics.NewRegistry() go graphite.Graphite(probeRegistry, common.SAMPLE_PERIOD, *prefix, addr) // TODO(jcgregorio) Monitor config file and reload if it changes. cfg, err := readConfigFiles(*config) if err != nil { glog.Fatalln("Failed to read config file: ", err) } glog.Infoln("Successfully read config file.") // Register counters for each probe. for name, probe := range cfg { probe.failure = metrics.NewRegisteredGauge(name+".failure", probeRegistry) probe.latency = metrics.NewRegisteredGauge(name+".latency", probeRegistry) } // Create a client that uses our dialer with a timeout. c := &http.Client{ Transport: &http.Transport{ Dial: dialTimeout, }, } probeOneRound(cfg, c) for _ = range time.Tick(*runEvery) { probeOneRound(cfg, c) liveness.Update() } }
// Start kicks off a go routine the periodically refreshes the current alerting clusters. func Start(tb *tracedb.Builder) { tileBuilder = tb client, err := auth.NewDefaultJWTServiceAccountClient("https://www.googleapis.com/auth/userinfo.email") if err != nil { glog.Errorf("Not updating bugs, not able to construct an authenticated client: %s", err) } var issueTracker issues.IssueTracker = nil if client != nil { issueTracker = issues.NewMonorailIssueTracker(client) } go func() { for _ = range time.Tick(config.RECLUSTER_DURATION) { singleStep(issueTracker) } }() }
func setupOAuth() error { var useRedirectURL = fmt.Sprintf("http://localhost%s/oauth2callback/", *port) if !*local { useRedirectURL = *redirectURL } if err := login.InitFromMetadataOrJSON(useRedirectURL, login.DEFAULT_SCOPE, *authWhiteList); err != nil { return fmt.Errorf("Problem setting up server OAuth: %s", err) } client, err := auth.NewDefaultJWTServiceAccountClient(auth.SCOPE_READ_ONLY) if err != nil { return fmt.Errorf("Problem setting up client OAuth: %s", err) } storageClient, err = storage.NewClient(context.Background(), cloud.WithBaseHTTP(client)) if err != nil { return fmt.Errorf("Problem authenticating: %s", err) } return nil }
func Init() { if *resourcesDir == "" { _, filename, _, _ := runtime.Caller(0) *resourcesDir = filepath.Join(filepath.Dir(filename), "../..") } loadTemplates() // Read toml config file. if _, err := toml.DecodeFile(*configFilename, &config); err != nil { glog.Fatalf("Failed to decode config file: %s", err) } serverNames = make([]string, 0, len(config.Servers)) for k, _ := range config.Servers { serverNames = append(serverNames, k) } var err error if client, err = auth.NewDefaultJWTServiceAccountClient(auth.SCOPE_FULL_CONTROL, auth.SCOPE_GCE); err != nil { glog.Fatalf("Failed to create authenticated HTTP client: %s", err) } fastClient = NewFastTimeoutClient() if store, err = storage.New(client); err != nil { glog.Fatalf("Failed to create storage service client: %s", err) } if comp, err = compute.New(client); err != nil { glog.Fatalf("Failed to create compute service client: %s", err) } ip, err = NewIPAddresses(comp) if err != nil { glog.Fatalf("Failed to load IP addresses at startup: %s", err) } packages.SetBucketName(*bucketName) packageInfo, err = packages.NewAllInfo(client, store, serverNames) if err != nil { glog.Fatalf("Failed to create packages.AllInfo at startup: %s", err) } }
func main() { if len(os.Args) < 2 { fmt.Println("Usage: query_issues <query> [OPTIONS]") return } query := os.Args[1] os.Args = append([]string{os.Args[0]}, os.Args[2:]...) common.Init() client, err := auth.NewDefaultJWTServiceAccountClient("https://www.googleapis.com/auth/userinfo.email") if err != nil { glog.Fatalf("Unable to create installed app oauth client:%s", err) } tracker := issues.NewMonorailIssueTracker(client) iss, err := tracker.FromQuery(query) if err != nil { fmt.Printf("Failed to retrieve issues: %s\n", err) return } fmt.Printf("Found: %d\n", len(iss)) for _, issue := range iss { fmt.Printf("%20d %10s %s\n", issue.ID, issue.State, issue.Title) } }