func Setup() { var err error cfg := config.Read() connectionString := cfg.DB.ConnectionString if cfg.DB.Type == "sqlite3" { connectionString = config.ConfigFile(connectionString) log.Println("Using SQLite DB at", connectionString) } for { db, err = gorm.Open(cfg.DB.Type, connectionString) if err == nil { break } else { log.Println("Cannot connect to DB. Will try again in 2 seconds:", err) time.Sleep(time.Duration(2) * time.Second) } } db.AutoMigrate( &User{}, &CredRecord{}, &Peer{}, &SentMessage{}, ) db.Model(&CredRecord{}).AddUniqueIndex("idx_cred_hash", "cred_hash") db.Model(&CredRecord{}).AddIndex("idx_statement_hash", "statement_hash") db.Model(&SentMessage{}).AddUniqueIndex("idx_message_hash", "message_hash") db.Model(&User{}).AddUniqueIndex("idx_fingerprint", "fingerprint") }
func StartWeb(wg sync.WaitGroup) { defer wg.Done() cfg := config.Read() listenUri := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port) mux := http.NewServeMux() mux.HandleFunc("/creds/info", web.RawCredHandler) mux.HandleFunc("/creds/info/", web.InfoCredHandler) mux.HandleFunc("/creds", CredHandler) mux.HandleFunc("/users/", UsersHandler) mux.HandleFunc("/connect", ConnectHandler) mux.HandleFunc("/ping", PingHandler) mux.HandleFunc("/protocol-handler", ProtocolHandlerHandler) static := http.FileServer(http.Dir(config.AssetDir("htdocs"))) mux.Handle("/", static) server := &http.Server{ Addr: listenUri, Handler: mux, } log.Println("Webservice will start on", listenUri) if cfg.Application.OpenWebUIOnStart { log.Println("Opening web browser…") // TODO: Create proper welcome page webbrowser.Open(fmt.Sprintf("%s", listenUri)) } panic(server.ListenAndServe()) }
func Setup() { config := config.Read() broadcastUri := fmt.Sprintf("tcp://%s:%d", config.Broadcaster.Host, config.Broadcaster.Port) var err error broadcaster, err = goczmq.NewPub(broadcastUri) if err != nil { panic(err) } log.Println("Broadcaster will start on", broadcastUri) pitcher = goczmq.NewSock(goczmq.Push) receiver, err = goczmq.NewPull("inproc://broadcast") if err != nil { panic(err) } helpers.ConnectToPeers(true, ConnectToBroadcatcher) }
// Return: whether or not to rebroadcast the message func ProcessInboundSearchRequest(searchRequest *credence.SearchRequest) bool { config := config.Read() // TODO: Store search request if searchRequest.Proximity <= config.SearchRequests.ForwardProximityLimit { searchRequest.Proximity += 1 for _, key := range searchRequest.Keys { for _, cred := range models.SearchCreds(key) { credMsg := &credence.Message{ Type: &credence.Message_Cred{ Cred: cred, }, } BroadcastMessage(credMsg) } } return true } return false }
func SearchCredsBreakdown(key string) []*credence.SearchResult_SourceBreakdown { var results []*credence.SearchResult_SourceBreakdown cfg := config.Read() var dbSpecificSelect string switch cfg.DB.Type { case "postgres": dbSpecificSelect = "source_uri, statement_hash, cred_bytes, sum(no_comment::int * coalesce(a.weight, 1)), sum(is_true::int * coalesce(a.weight, 1)), sum(is_false::int * coalesce(a.weight, 1)), sum(is_ambiguous::int * coalesce(a.weight, 1)), sum(coalesce(a.weight, 0))" case "sqlite3": dbSpecificSelect = "source_uri, statement_hash, cred_bytes, sum(no_comment * coalesce(a.weight, 1)), sum(is_true * coalesce(a.weight, 1)), sum(is_false * coalesce(a.weight, 1)), sum(is_ambiguous * coalesce(a.weight, 1)), sum(coalesce(a.weight, 0))" } rows, err := db. Table("cred_records"). Select(dbSpecificSelect). Joins("left join users a on author_id = a.id"). Where("source_uri LIKE ?", key). Group("source_uri, statement_hash, cred_bytes"). Rows() if err != nil { panic(err) } for rows.Next() { var ( sourceUri string breakdown credence.SearchResult_AssertionBreakdown credBytes []byte ) rows.Scan( &sourceUri, &breakdown.StatementHash, &credBytes, &breakdown.NoComment, &breakdown.IsTrue, &breakdown.IsFalse, &breakdown.IsAmbiguous, &breakdown.Recognised, ) cred := &credence.Cred{} err := proto.Unmarshal(credBytes, cred) if err != nil { panic(err) } // So much hack! The statement fields are in the same place, so we can convert by doing // lots of marshalling and unmarshalling… justCredStatement := &credence.Cred{ Statement: cred.Statement, } statementBytes, err := proto.Marshal(justCredStatement) justBreakdownStatement := &credence.SearchResult_AssertionBreakdown{} err = proto.Unmarshal(statementBytes, justBreakdownStatement) breakdown.Statement = justBreakdownStatement.Statement // </hack> assertions := []*credence.SearchResult_AssertionBreakdown{&breakdown} sourceBreakdown := credence.SearchResult_SourceBreakdown{ SourceUri: sourceUri, Assertions: assertions, } results = append(results, &sourceBreakdown) } return results }