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