about summary refs log blame commit diff stats
path: root/arc/buffered-stdin.mu
blob: 9a7bc7ae8934454945591890f2b460ddeab77a37 (plain) (tree) 
4ca73eb6 ^

3a0be565 ^



d1f57fa1 ^

3a0be565 ^



3a0be565 ^

09e2e533 ^

8ab4b12c ^

3a0be565 ^

4ca73eb6 ^




5b698455 ^

4ca73eb6 ^

7d2c2d55 ^



4ca73eb6 ^




3a0be565 ^



1

2
3
4

5

6
7
8

9

10

11

12

13
14
15
16

17

18

19
20
21

22
23
24
25

26
27
28

                                                    


                                                               
                    


                                                                                                                      
                
                                                            
                                                                                                                          
         



                                                                
                                                                                                  
                                                                    


                                         



                                                                     


          
; reads lines, prints them back when you hit 'enter'
; dies if you wait a while, because so far we never free memory
(function main [
  (default-space:space-address <- new space:literal 30:literal)
  (cursor-mode) ;? 1
  ; hook up stdin
  (stdin:channel-address <- init-channel 1:literal)
  (fork-helper send-keys-to-stdin:fn nil:literal/globals nil:literal/limit nil:literal/keyboard stdin:channel-address)
  ; buffer stdin
  (buffered-stdin:channel-address <- init-channel 1:literal)
  (fork-helper buffer-lines:fn nil:literal/globals nil:literal/limit stdin:channel-address buffered-stdin:channel-address)
  { begin
    ; now read characters from the buffer until 'enter' is typed
    (s:string-address <- new "? ")
    (print-string nil:literal/terminal s:string-address)
    { begin
      (x:tagged-value buffered-stdin:channel-address/deref <- read buffered-stdin:channel-address)
      (c:character <- maybe-coerce x:tagged-value character:literal)
;?       ($print (("AAA " literal))) ;? 1
;?       ($print c:character) ;? 1
;?       ($print (("\n" literal))) ;? 1
      (print-character nil:literal/terminal c:character)
      (line-done?:boolean <- equal c:character ((#\newline literal)))
      (loop-unless line-done?:boolean)
    }
    (loop)
  }
])
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-12-02 19:21:24 +0000
-0400 simplified indexHandler to reference staticCache' href='/gbmor/getwtxt/commit/query.go?h=v0.5.0&id=a6f47c07100be337f32325792990e58f5f4a3506'>a6f47c0 ^ 
efa99ed ^

fc49c57 ^

bce5265 ^

efa99ed ^

90638ac ^






90638ac ^

eca8525 ^

90638ac ^



5bfffe1 ^






90638ac ^

5bfffe1 ^




90638ac ^


5bfffe1 ^




90638ac ^


5bfffe1 ^







90638ac ^

5bfffe1 ^


90638ac ^

5bfffe1 ^

90638ac ^

1

2
3

4

5

6
7

8

9

10

11

12

13
14
15
16
17
18

19

20
21
22

23
24
25
26
27
28
29
30
31
32
33
34
35
36

37
38
39
40
41
42
43

44

45
46

47

48
49

50

51
52

53
54

55

56
57
58

59

60
61

62

63

64
65

66
67

68

69

70
71
72
73
74
75
76
77
78
79

80

81

82

83
84

85

86

87
88
89

90
91
92

93

94

95
96
97
98
99

100
101
102

103

104

105

106

107
108

109

110

111

112
113

114

115

116

117

118

119

120
121
122
123
124
125

126

127

128
129
130

131
132
133
134
135
136

137

138
139
140
141

142
143

144
145
146
147

148
149

150
151
152
153
154
155
156

157

158
159

160

161

162

                                                      

        
                       
             

                  
                 
                 
              
 
                                     





                                                
                                                                                        


         













                                            






                                                    
                               

                                                 
                                                                   

                                                       
         

                   

 
                                                         


                                                             
                                                                     

                                  
                                      
                        

                     

                                            
                       
 









                                                                
                                 
                                
                                                              

                                           
                               
                                                              


                                           


                                                 
 
                        




                                                                         


                                   
                                                    
 
                
                                                                   

         
                                              
                                  
 

                                                      
                                               
 
                              
 
                  
 





                                               
 
                             


                                                                   





                                    
                                      



                                                          

                                    



                                                            

                                      






                                                            
                           

                            
 
                                             
 
package svc // import "github.com/getwtxt/getwtxt/svc"

import (
	"crypto/sha256"
	"fmt"
	"log"
	"net/http"
	"strconv"
	"strings"
	"sync"

	"github.com/getwtxt/registry"
	"github.com/gorilla/mux"
)

func apiErrCheck(err error, r *http.Request) {
	if err != nil {
		uip := getIPFromCtx(r.Context())
		log.Printf("*** %v :: %v %v :: %v\n", uip, r.Method, r.URL, err.Error())
	}
}

func dedupe(list []string) []string {
	out := []string{}
	seen := make(map[string]bool)

	for _, e := range list {
		if !seen[e] {
			out = append(out, e)
			seen[e] = true
		}
	}

	return out
}

// Takes the output of queries and formats it for
// an HTTP response. Iterates over the string slice,
// appending each entry to a byte slice, and adding
// newlines where appropriate.
func parseQueryOut(out []string) []byte {
	var data []byte

	for i, e := range out {
		data = append(data, []byte(e)...)

		if !strings.HasSuffix(e, "\n") && i != len(out)-1 {
			data = append(data, byte('\n'))
		}
	}

	return data
}

// apiEndpointQuery is called via apiEndpointHandler when
// the endpoint is "users" and r.FormValue("q") is not empty.
// It queries the registry cache for users or user URLs
// matching the term supplied via r.FormValue("q")
func apiEndpointQuery(w http.ResponseWriter, r *http.Request) error {
	query := r.FormValue("q")
	urls := r.FormValue("url")
	pageVal := r.FormValue("page")
	var out []string
	var err error

	pageVal = strings.TrimSpace(pageVal)
	page, err := strconv.Atoi(pageVal)
	errLog("", err)

	vars := mux.Vars(r)
	endpoint := vars["endpoint"]

	// Handle user URL queries first, then nickname queries.
	// Concatenate both outputs if they're both set.
	// Also handle mention queries and status queries.
	// If we made it this far and 'default' is matched,
	// something went very wrong.
	switch endpoint {
	case "users":
		var out2 []string
		if query != "" {
			out, err = twtxtCache.QueryUser(query)
			apiErrCheck(err, r)
		}
		if urls != "" {
			out2, err = twtxtCache.QueryUser(urls)
			apiErrCheck(err, r)
		}

		if query != "" && urls != "" {
			out = joinQueryOuts(out2)
		}

	case "mentions":
		if urls == "" {
			return fmt.Errorf("missing URL in mention query")
		}
		urls += ">"
		out, err = twtxtCache.QueryInStatus(urls)
		apiErrCheck(err, r)

	case "tweets":
		out = compositeStatusQuery(query, r)

	default:
		return fmt.Errorf("endpoint query, no cases match")
	}

	out = registry.ReduceToPage(page, out)
	data := parseQueryOut(out)

	etag := fmt.Sprintf("%x", sha256.Sum256(data))
	w.Header().Set("ETag", etag)
	w.Header().Set("Content-Type", txtutf8)

	_, err = w.Write(data)

	return err
}

func joinQueryOuts(data ...[]string) []string {
	single := []string{}
	for _, e := range data {
		single = append(single, e...)
	}

	return dedupe(single)
}

func compositeStatusQuery(query string, r *http.Request) []string {
	var wg sync.WaitGroup
	var out, out2, out3 []string
	var err, err2, err3 error

	wg.Add(3)

	query = strings.ToLower(query)
	go func(query string) {
		out, err = twtxtCache.QueryInStatus(query)
		wg.Done()
	}(query)

	query = strings.Title(query)
	go func(query string) {
		out2, err2 = twtxtCache.QueryInStatus(query)
		wg.Done()
	}(query)

	query = strings.ToUpper(query)
	go func(query string) {
		out3, err3 = twtxtCache.QueryInStatus(query)
		wg.Done()
	}(query)

	wg.Wait()

	apiErrCheck(err, r)
	apiErrCheck(err2, r)
	apiErrCheck(err3, r)

	return joinQueryOuts(out, out2, out3)
}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-12-02 19:21:22 +0000