func main() { ticker := time.NewTicker(50 * time.Millisecond) hystrixStreamHandler := hystrix.NewStreamHandler() hystrixStreamHandler.Start() go http.ListenAndServe(net.JoinHostPort("", "9090"), hystrixStreamHandler) for { select { case <-ticker.C: err := hystrix.Do("Localhost 8080", func() error { resp, err := http.Get("http://localhost:8080/") if resp != nil { resp.Body.Close() } return err }, nil) if err != nil { log.Printf("Error: %v", err) } } } }
func main() { hystrixStreamHandler := hystrix.NewStreamHandler() hystrixStreamHandler.Start() router := mux.NewRouter().StrictSlash(true) router.HandleFunc("/", index) router.HandleFunc("/stream", hystrixStreamHandler.ServeHTTP) log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", os.Getenv("PORT")), router)) }
func main() { // hystrix.ConfigureCommand("my_command", hystrix.CommandConfig{ // Timeout: 100, // MaxConcurrentRequests: 100, // ErrorPercentThreshold: 50, // }) // Launch streamHandler for Hystrix dashboard hystrixStreamHandler := hystrix.NewStreamHandler() hystrixStreamHandler.Start() go http.ListenAndServe(net.JoinHostPort("", "8222"), hystrixStreamHandler) http.HandleFunc("/start", startHandler) http.HandleFunc("/configure", configureHandler) http.HandleFunc("/toggleOpen", toggleOpenHandler) http.HandleFunc("/close", closeHandler) http.HandleFunc("/status", statusHandler) http.ListenAndServe(":8221", nil) output := make(chan bool, 1) <-output }
func main() { flag.Parse() stats, err := initStatsd(*stats_prefix, os.Getenv("STATSD_HOSTPORT")) if err != nil { log.Fatalf("Statsd configuration error: %v", err) } auth, err := aws.GetAuth("", "", "", time.Now()) if err != nil { log.Fatalln("Failed to recieve auth from env") } awsConnection := s3.New( auth, aws.USWest2, ) auditBucket := awsConnection.Bucket(auditBucketName + "-" + CLOUD_ENV) auditBucket.PutBucket(s3.BucketOwnerFull) eventBucket := awsConnection.Bucket(eventBucketName + "-" + CLOUD_ENV) eventBucket.PutBucket(s3.BucketOwnerFull) auditInfo := gen.BuildInstanceInfo(&gen.EnvInstanceFetcher{}, "spade_edge_audit", *logging_dir) loggingInfo := gen.BuildInstanceInfo(&gen.EnvInstanceFetcher{}, "spade_edge", *logging_dir) auditRotateCoordinator := gologging.NewRotateCoordinator(auditMaxLogLines, auditMaxLogAge) loggingRotateCoordinator := gologging.NewRotateCoordinator(maxLogLines, maxLogAge) auditLogger, err := gologging.StartS3Logger( auditRotateCoordinator, auditInfo, &DummyNotifierHarness{}, &uploader.S3UploaderBuilder{ Bucket: auditBucket, KeyNameGenerator: &gen.EdgeKeyNameGenerator{Info: auditInfo}, }, BuildSQSErrorHarness(), 2, ) if err != nil { log.Fatalf("Got Error while building audit: %s\n", err) } spadeEventLogger, err := gologging.StartS3Logger( loggingRotateCoordinator, loggingInfo, BuildSQSNotifierHarness(), &uploader.S3UploaderBuilder{ Bucket: eventBucket, KeyNameGenerator: &gen.EdgeKeyNameGenerator{Info: loggingInfo}, }, BuildSQSErrorHarness(), 2, ) if err != nil { log.Fatalf("Got Error while building logger: %s\n", err) } // Initialize Loggers. // AuditLogger writes to the audit log, for analysis of system success rate. // SpadeLogger writes requests to a file for processing by the spade processor. // K(afka)Logger writes produces messages for kafka, currently in dark launch. // We allow the klogger to be null incase we boot up with an unresponsive kafka cluster. var logger *request_handler.EventLoggers brokerList := ParseBrokerList(*brokers) klogger, err := kafka_logger.NewKafkaLogger(*clientId, brokerList) if err == nil { klogger.(*kafka_logger.KafkaLogger).Init() logger = &request_handler.EventLoggers{ AuditLogger: auditLogger, SpadeLogger: spadeEventLogger, KLogger: klogger, } } else { log.Printf("Got Error while building logger: %s + %v\nUsing Nop Logger\n", err, brokerList) logger = &request_handler.EventLoggers{ AuditLogger: auditLogger, SpadeLogger: spadeEventLogger, KLogger: &request_handler.NoopLogger{}, } } // Trigger close on receipt of SIGINT sigc := make(chan os.Signal, 1) signal.Notify(sigc, syscall.SIGINT) go func() { <-sigc // Cause flush logger.Close() os.Exit(0) }() hystrixStreamHandler := hystrix.NewStreamHandler() hystrixStreamHandler.Start() go http.ListenAndServe(net.JoinHostPort("", "81"), hystrixStreamHandler) // setup server and listen server := &http.Server{ Addr: *listen_port, Handler: &request_handler.SpadeHandler{ StatLogger: stats, EdgeLogger: logger, Assigner: request_handler.Assigner, }, ReadTimeout: 5 * time.Second, WriteTimeout: 5 * time.Second, MaxHeaderBytes: 1 << 20, // 0.5MB } if err := server.ListenAndServe(); err != nil { log.Fatalln(err) } }
func main() { index := resource.NewIndex() index.Bind("posts", post, restrix.Wrap("posts", mem.NewHandler()), resource.Conf{ AllowedModes: resource.ReadWrite, }) // Create API HTTP handler for the resource graph api, err := rest.NewHandler(index) if err != nil { log.Fatalf("Invalid API configuration: %s", err) } // Setup logger c := alice.New() c = c.Append(xlog.NewHandler(xlog.Config{})) c = c.Append(xaccess.NewHandler()) resource.LoggerLevel = resource.LogLevelDebug resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) { xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields) } // Bind the API under the root path http.Handle("/", c.Then(api)) // Configure hystrix commands hystrix.Configure(map[string]hystrix.CommandConfig{ "posts.MultiGet": { Timeout: 500, MaxConcurrentRequests: 200, ErrorPercentThreshold: 25, }, "posts.Find": { Timeout: 1000, MaxConcurrentRequests: 100, ErrorPercentThreshold: 25, }, "posts.Insert": { Timeout: 1000, MaxConcurrentRequests: 50, ErrorPercentThreshold: 25, }, "posts.Update": { Timeout: 1000, MaxConcurrentRequests: 50, ErrorPercentThreshold: 25, }, "posts.Delete": { Timeout: 1000, MaxConcurrentRequests: 10, ErrorPercentThreshold: 10, }, "posts.Clear": { Timeout: 10000, MaxConcurrentRequests: 5, ErrorPercentThreshold: 10, }, }) // Start the metrics stream handler hystrixStreamHandler := hystrix.NewStreamHandler() hystrixStreamHandler.Start() log.Print("Serving Hystrix metrics on http://localhost:8081") go http.ListenAndServe(net.JoinHostPort("", "8081"), hystrixStreamHandler) // Inject some fixtures fixtures := [][]string{ {"POST", "/posts", `{"title": "First Post", "body": "This is my first post"}`}, {"POST", "/posts", `{"title": "Second Post", "body": "This is my second post"}`}, {"POST", "/posts", `{"title": "Third Post", "body": "This is my third post"}`}, } for _, fixture := range fixtures { req, err := http.NewRequest(fixture[0], fixture[1], strings.NewReader(fixture[2])) if err != nil { log.Fatal(err) } w := httptest.NewRecorder() api.ServeHTTP(w, req) if w.Code >= 400 { log.Fatalf("Error returned for `%s %s`: %v", fixture[0], fixture[1], w) } } // Serve it log.Print("Serving API on http://localhost:8080") if err := http.ListenAndServe(":8080", nil); err != nil { log.Fatal(err) } }