func main() { app := cli.App("public-organisations-api-neo4j", "A public RESTful API for accessing organisations in neo4j") neoURL := app.String(cli.StringOpt{ Name: "neo-url", Value: "http://localhost:7474/db/data", Desc: "neo4j endpoint URL", EnvVar: "NEO_URL", }) port := app.String(cli.StringOpt{ Name: "port", Value: "8080", Desc: "Port to listen on", EnvVar: "APP_PORT", }) graphiteTCPAddress := app.String(cli.StringOpt{ Name: "graphiteTCPAddress", Value: "", Desc: "Graphite TCP address, e.g. graphite.ft.com:2003. Leave as default if you do NOT want to output to graphite (e.g. if running locally)", EnvVar: "GRAPHITE_ADDRESS", }) graphitePrefix := app.String(cli.StringOpt{ Name: "graphitePrefix", Value: "", Desc: "Prefix to use. Should start with content, include the environment, and the host name. e.g. content.test.public.content.by.concept.api.ftaps59382-law1a-eu-t", EnvVar: "GRAPHITE_PREFIX", }) logMetrics := app.Bool(cli.BoolOpt{ Name: "logMetrics", Value: false, Desc: "Whether to log metrics. Set to true if running locally and you want metrics output", EnvVar: "LOG_METRICS", }) env := app.String(cli.StringOpt{ Name: "env", Value: "local", Desc: "environment this app is running in", }) cacheDuration := app.String(cli.StringOpt{ Name: "cache-duration", Value: "30s", Desc: "Duration Get requests should be cached for. e.g. 2h45m would set the max-age value to '7440' seconds", EnvVar: "CACHE_DURATION", }) app.Action = func() { baseftrwapp.OutputMetricsIfRequired(*graphiteTCPAddress, *graphitePrefix, *logMetrics) log.Infof("public-organisations-api will listen on port: %s, connecting to: %s", *port, *neoURL) runServer(*neoURL, *port, *cacheDuration, *env) } log.SetFormatter(&log.TextFormatter{DisableColors: true}) log.SetLevel(log.InfoLevel) log.Infof("Application started with args %s", os.Args) app.Run(os.Args) }
func main() { app := cli.App("people-api-neo", "A RESTful API for managing People in neo4j") neoURL := app.StringOpt("neo-url", "http://localhost:7474/db/data", "neo4j endpoint URL") port := app.IntOpt("port", 8080, "Port to listen on") batchSize := app.IntOpt("batchSize", 1024, "Maximum number of statements to execute per batch") graphiteTCPAddress := app.StringOpt("graphiteTCPAddress", "", "Graphite TCP address, e.g. graphite.ft.com:2003. Leave as default if you do NOT want to output to graphite (e.g. if running locally)") graphitePrefix := app.StringOpt("graphitePrefix", "", "Prefix to use. Should start with content, include the environment, and the host name. e.g. content.test.people.rw.neo4j.ftaps58938-law1a-eu-t") logMetrics := app.BoolOpt("logMetrics", false, "Whether to log metrics. Set to true if running locally and you want metrics output") app.Action = func() { db, err := neoism.Connect(*neoURL) if err != nil { log.Fatal(err) } batchRunner := neoutils.NewBatchCypherRunner(neoutils.StringerDb{db}, *batchSize) peopleDriver := people.NewCypherPeopleService(batchRunner, db) peopleDriver.Initialise() baseftrwapp.OutputMetricsIfRequired(*graphiteTCPAddress, *graphitePrefix, *logMetrics) engs := map[string]baseftrwapp.Service{ "people": peopleDriver, } var checks []v1a.Check for _, e := range engs { checks = append(checks, makeCheck(e, batchRunner)) } baseftrwapp.RunServer(engs, v1a.Handler("ft-people_rw_neo4j ServiceModule", "Writes 'people' to Neo4j, usually as part of a bulk upload done on a schedule", checks...), *port, "ft-people_rw_neo4j", "local") } app.Run(os.Args) }
func main() { app := cli.App("subjetcs-rw-neo4j", "A RESTful API for managing Subjects in neo4j") neoURL := app.String(cli.StringOpt{ Name: "neo-url", Value: "http://localhost:7474/db/data", Desc: "neo4j endpoint URL", EnvVar: "NEO_URL", }) graphiteTCPAddress := app.String(cli.StringOpt{ Name: "graphite-tcp-address", Value: "", Desc: "Graphite TCP address, e.g. graphite.ft.com:2003. Leave as default if you do NOT want to output to graphite (e.g. if running locally", EnvVar: "GRAPHITE_TCP_ADDRESS", }) graphitePrefix := app.String(cli.StringOpt{ Name: "graphite-prefix", Value: "", Desc: "Prefix to use. Should start with content, include the environment, and the host name. e.g. coco.pre-prod.subjects-rw-neo4j.1", EnvVar: "GRAPHITE_PREFIX", }) port := app.Int(cli.IntOpt{ Name: "port", Value: 8080, Desc: "Port to listen on", EnvVar: "PORT", }) batchSize := app.Int(cli.IntOpt{ Name: "batch-size", Value: 1024, Desc: "Maximum number of statements to execute per batch", EnvVar: "BATCH_SIZE", }) logMetrics := app.Bool(cli.BoolOpt{ Name: "log-metrics", Value: false, Desc: "Whether to log metrics. Set to true if running locally and you want metrics output", EnvVar: "LOG_METRICS", }) app.Action = func() { conf := neoutils.DefaultConnectionConfig() conf.BatchSize = *batchSize db, err := neoutils.Connect(*neoURL, conf) if err != nil { log.Errorf("Could not connect to neo4j, error=[%s]\n", err) } subjectsDriver := subjects.NewCypherSubjectsService(db) subjectsDriver.Initialise() baseftrwapp.OutputMetricsIfRequired(*graphiteTCPAddress, *graphitePrefix, *logMetrics) endpoints := map[string]baseftrwapp.Service{ "subjects": subjectsDriver, } var checks []v1a.Check for _, e := range endpoints { checks = append(checks, makeCheck(e, db)) } baseftrwapp.RunServer(endpoints, v1a.Handler("ft-subjects_rw_neo4j ServiceModule", "Writes 'subjects' to Neo4j, usually as part of a bulk upload done on a schedule", checks...), *port, "subjects-rw-neo4j", "local") } app.Run(os.Args) }
func main() { app := cli.App("roles-rw-neo4j", "A RESTful API for managing Membership Roles in neo4j") neoURL := app.String(cli.StringOpt{ Name: "neo-url", Value: "http://localhost:7474/db/data", Desc: "neo4j endpoint URL", EnvVar: "NEO_URL", }) graphiteTCPAddress := app.String(cli.StringOpt{ Name: "graphiteTCPAddress", Value: "", Desc: "Graphite TCP address, e.g. graphite.ft.com:2003. Leave as default if you do NOT want to output to graphite (e.g. if running locally", EnvVar: "GRAPHITE_ADDRESS", }) graphitePrefix := app.String(cli.StringOpt{ Name: "graphitePrefix", Value: "", Desc: "Prefix to use. Should start with content, include the environment, and the host name. e.g. coco.pre-prod.roles-rw-neo4j.1 or content.test.roles.rw.neo4j.ftaps58938-law1a-eu-t", EnvVar: "GRAPHITE_PREFIX", }) port := app.Int(cli.IntOpt{ Name: "port", Value: 8080, Desc: "Port to listen on", EnvVar: "APP_PORT", }) batchSize := app.Int(cli.IntOpt{ Name: "batchSize", Value: 1024, Desc: "Maximum number of statements to execute per batch", EnvVar: "BATCH_SIZE", }) logMetrics := app.Bool(cli.BoolOpt{ Name: "logMetrics", Value: false, Desc: "Whether to log metrics. Set to true if running locally and you want metrics output", EnvVar: "LOG_METRICS", }) env := app.String(cli.StringOpt{ Name: "env", Value: "local", Desc: "environment this app is running in", }) app.Action = func() { conf := neoutils.DefaultConnectionConfig() conf.BatchSize = *batchSize db, err := neoutils.Connect(*neoURL, conf) if err != nil { log.Errorf("Could not connect to neo4j, error=[%s]\n", err) } rolesDriver := roles.NewCypherDriver(db) rolesDriver.Initialise() baseftrwapp.OutputMetricsIfRequired(*graphiteTCPAddress, *graphitePrefix, *logMetrics) services := map[string]baseftrwapp.Service{ "roles": rolesDriver, } var checks []v1a.Check for _, service := range services { checks = append(checks, makeCheck(service, db)) } baseftrwapp.RunServerWithConf(baseftrwapp.RWConf{ Services: services, HealthHandler: v1a.Handler("ft-roles_rw_neo4j ServiceModule", "Writes 'roles' to Neo4j, usually as part of a bulk upload done on a schedule", checks...), Port: *port, ServiceName: "roles-rw-neo4j", Env: *env, EnableReqLog: false, }) } log.SetLevel(log.InfoLevel) log.Infof("Application started with args %s", os.Args) app.Run(os.Args) }
func main() { app := cli.App("annotations-rw-neo4j", "A RESTful API for managing Annotations in neo4j") neoURL := app.String(cli.StringOpt{ Name: "neo-url", Value: "http://localhost:7474/db/data", Desc: "neo4j endpoint URL", EnvVar: "NEO_URL", }) graphiteTCPAddress := app.String(cli.StringOpt{ Name: "graphiteTCPAddress", Value: "", Desc: "Graphite TCP address, e.g. graphite.ft.com:2003. Leave as default if you do NOT want to output to graphite (e.g. if running locally", EnvVar: "GRAPHITE_ADDRESS", }) graphitePrefix := app.String(cli.StringOpt{ Name: "graphitePrefix", Value: "", Desc: "Prefix to use. Should start with content, include the environment, and the host name. e.g. coco.pre-prod.roles-rw-neo4j.1 or content.test.people.rw.neo4j.ftaps58938-law1a-eu-t", EnvVar: "GRAPHITE_PREFIX", }) port := app.Int(cli.IntOpt{ Name: "port", Value: 8080, Desc: "Port to listen on", EnvVar: "APP_PORT", }) batchSize := app.Int(cli.IntOpt{ Name: "batchSize", Value: 1024, Desc: "Maximum number of statements to execute per batch", EnvVar: "BATCH_SIZE", }) logMetrics := app.Bool(cli.BoolOpt{ Name: "logMetrics", Value: false, Desc: "Whether to log metrics. Set to true if running locally and you want metrics output", EnvVar: "LOG_METRICS", }) logLevel := app.String(cli.StringOpt{ Name: "log-level", Value: "INFO", Desc: "Logging level (DEBUG, INFO, WARN, ERROR)", EnvVar: "LOG_LEVEL", }) platformVersion := app.String(cli.StringOpt{ Name: "platformVersion", Value: "", Desc: "Annotation source platform. Possible values are: v1 or v2.", EnvVar: "PLATFORM_VERSION", }) app.Action = func() { parsedLogLevel, err := log.ParseLevel(*logLevel) if err != nil { log.WithFields(log.Fields{"logLevel": logLevel, "err": err}).Fatal("Incorrect log level") } log.SetLevel(parsedLogLevel) log.Infof("annotations-rw-neo4j will listen on port: %d, connecting to: %s", *port, *neoURL) conf := neoutils.DefaultConnectionConfig() conf.BatchSize = *batchSize db, err := neoutils.Connect(*neoURL, conf) if err != nil { log.Fatalf("Error connecting to neo4j %s", err) } annotationsService := annotations.NewCypherAnnotationsService(db, *platformVersion) httpHandlers := httpHandlers{annotationsService} // Healthchecks and standards first http.HandleFunc("/__health", v1a.Handler("Annotations RW Healthchecks", "Checks for accessing neo4j", httpHandlers.HealthCheck())) http.HandleFunc(status.PingPath, status.PingHandler) http.HandleFunc(status.PingPathDW, status.PingHandler) http.HandleFunc(status.BuildInfoPath, status.BuildInfoHandler) http.HandleFunc(status.BuildInfoPathDW, status.BuildInfoHandler) gtgChecker := make([]gtg.StatusChecker, 0) gtgChecker = append(gtgChecker, func() gtg.Status { if err := httpHandlers.AnnotationsService.Check(); err != nil { return gtg.Status{GoodToGo: false, Message: err.Error()} } return gtg.Status{GoodToGo: true} }) http.HandleFunc(status.GTGPath, status.NewGoodToGoHandler(gtg.FailFastParallelCheck(gtgChecker))) r := router(httpHandlers) http.Handle("/", r) baseftrwapp.OutputMetricsIfRequired(*graphiteTCPAddress, *graphitePrefix, *logMetrics) if err := http.ListenAndServe(fmt.Sprintf(":%d", *port), nil); err != nil { log.Fatalf("Unable to start server: %v", err) } } log.Infof("Application started with args %s", os.Args) app.Run(os.Args) }