func runServer(neoURL string, port string, cacheDuration string, env string) {
if duration, durationErr := time.ParseDuration(cacheDuration); durationErr != nil {
log.Fatalf("Failed to parse cache duration string, %v", durationErr)
} else {
organisations.CacheControlHeader = fmt.Sprintf("max-age=%s, public", strconv.FormatFloat(duration.Seconds(), 'f', 0, 64))
}
conf := neoutils.ConnectionConfig{
BatchSize: 1024,
Transactional: false,
HTTPClient: &http.Client{
Transport: &http.Transport{
MaxIdleConnsPerHost: 100,
},
Timeout: 1 * time.Minute,
},
BackgroundConnect: true,
}
db, err := neoutils.Connect(neoURL, &conf)
if err != nil {
log.Fatalf("Error connecting to neo4j %s", err)
}
organisations.OrganisationDriver = organisations.NewCypherDriver(db, env)
servicesRouter := mux.NewRouter()
// Healthchecks and standards first
servicesRouter.HandleFunc("/__health", v1a.Handler("PublicOrganisationsRead Healthchecks",
"Checks for accessing neo4j", organisations.HealthCheck()))
servicesRouter.HandleFunc("/__gtg", organisations.GoodToGo)
// Then API specific ones:
servicesRouter.HandleFunc("/organisations/{uuid}", organisations.GetOrganisation).Methods("GET")
servicesRouter.HandleFunc("/organisations/{uuid}", organisations.MethodNotAllowedHandler)
var monitoringRouter http.Handler = servicesRouter
monitoringRouter = httphandlers.TransactionAwareRequestLoggingHandler(log.StandardLogger(), monitoringRouter)
monitoringRouter = httphandlers.HTTPMetricsHandler(metrics.DefaultRegistry, monitoringRouter)
// The following endpoints should not be monitored or logged (varnish calls one of these every second, depending on config)
// The top one of these build info endpoints feels more correct, but the lower one matches what we have in Dropwizard,
// so it's what apps expect currently same as ping, the content of build-info needs more definition
//using http router here to be able to catch "/"
http.HandleFunc(status.PingPath, status.PingHandler)
http.HandleFunc(status.PingPathDW, status.PingHandler)
http.HandleFunc(status.BuildInfoPath, status.BuildInfoHandler)
http.HandleFunc(status.BuildInfoPathDW, status.BuildInfoHandler)
http.HandleFunc("/__gtg", organisations.GoodToGo)
http.Handle("/", monitoringRouter)
if err := http.ListenAndServe(":"+port, nil); err != nil {
log.Fatalf("Unable to start server: %v", err)
}
}
func getDatabaseConnection(assert *assert.Assertions) neoutils.NeoConnection {
url := os.Getenv("NEO4J_TEST_URL")
if url == "" {
url = "http://localhost:7474/db/data"
}
conf := neoutils.DefaultConnectionConfig()
conf.Transactional = false
db, err := neoutils.Connect(url, conf)
assert.NoError(err, "Failed to connect to Neo4j")
return db
}
func getSubjectsCypherDriver(t *testing.T) service {
url := os.Getenv("NEO4J_TEST_URL")
if url == "" {
url = "http://localhost:7474/db/data"
}
conf := neoutils.DefaultConnectionConfig()
conf.Transactional = false
db, err := neoutils.Connect(url, conf)
assert.NoError(t, err, "Failed to connect to Neo4j")
return NewCypherSubjectsService(db)
}
func getIndustryClassificationService(t *testing.T) service {
assert := assert.New(t)
url := os.Getenv("NEO4J_TEST_URL")
if url == "" {
url = "http://localhost:7474/db/data"
}
conf := neoutils.DefaultConnectionConfig()
conf.Transactional = false
db, err := neoutils.Connect(url, conf)
assert.NoError(err, "Failed to connect to Neo4j")
return NewCypherIndustryClassifcationService(db)
}
func getRolesCypherDriver(t *testing.T) CypherDriver {
url := os.Getenv("NEO4J_TEST_URL")
if url == "" {
url = "http://localhost:7474/db/data"
}
conf := neoutils.DefaultConnectionConfig()
conf.Transactional = false
db, err := neoutils.Connect(url, conf)
assert.NoError(t, err, "Failed to connect to Neo4j")
cr := NewCypherDriver(db)
cr.Initialise()
return cr
}
func getAnnotationsService(t *testing.T, platformVersion string) service {
assert := assert.New(t)
url := os.Getenv("NEO4J_TEST_URL")
if url == "" {
url = "http://localhost:7474/db/data"
}
conf := neoutils.DefaultConnectionConfig()
conf.Transactional = false
db, err := neoutils.Connect(url, conf)
assert.NoError(err, "Failed to connect to Neo4j")
return NewCypherAnnotationsService(db, platformVersion)
}
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)
}