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)
}
}