about summary refs log blame commit diff stats
path: root/arc/.traces/jump-if-skip
blob: e5d51a78db2f43dbab1369efd71a38fe364510cd (plain) (tree)





















































                                                                      
c{0: 0 (((2 integer)) <- ((copy)) ((1 literal))) -- nil
c{0: 1 (((1 boolean)) <- ((equal)) ((1 literal)) ((2 integer))) -- nil
c{0: 2 (((jump-if)) ((1 boolean)) ((1 offset))) -- nil
c{0: 3 (((2 integer)) <- ((copy)) ((3 literal))) -- nil
c{0: 4 (((reply))) -- nil
c{0: 5 (((3 integer)) <- ((copy)) ((34 literal))) -- nil
c{1: 0 ✓ (((2 integer)) <- ((copy)) ((1 literal)))
c{1: 1 ✓ (((1 boolean)) <- ((equal)) ((1 literal)) ((2 integer)))
c{1: 2 ✓ (((jump-if)) ((1 boolean)) ((1 offset)))
c{1: 3 ✓ (((2 integer)) <- ((copy)) ((3 literal)))
c{1: 4 ✓ (((reply)))
c{1: 5 ✓ (((3 integer)) <- ((copy)) ((34 literal)))
cn0: convert-names in main
cn0: (((2 integer)) <- ((copy)) ((1 literal))) nil nil
cn0: checking arg ((1 literal))
cn0: checking oarg ((2 integer))
maybe-add: ((2 integer))
cn0: (((1 boolean)) <- ((equal)) ((1 literal)) ((2 integer))) nil nil
cn0: checking arg ((1 literal))
cn0: checking arg ((2 integer))
maybe-add: ((2 integer))
cn0: checking oarg ((1 boolean))
maybe-add: ((1 boolean))
cn0: (((jump-if)) ((1 boolean)) ((1 offset))) nil nil
cn0: checking arg ((1 boolean))
maybe-add: ((1 boolean))
cn0: checking arg ((1 offset))
cn0: (((2 integer)) <- ((copy)) ((3 literal))) nil nil
cn0: checking arg ((3 literal))
cn0: checking oarg ((2 integer))
maybe-add: ((2 integer))
cn0: (((reply))) nil nil
cn0: (((3 integer)) <- ((copy)) ((34 literal))) nil nil
cn0: checking arg ((34 literal))
cn0: checking oarg ((3 integer))
maybe-add: ((3 integer))
cn1: (((2 integer)) <- ((copy)) ((1 literal)))
cn1: (((1 boolean)) <- ((equal)) ((1 literal)) ((2 integer)))
cn1: (((jump-if)) ((1 boolean)) ((1 offset)))
cn1: (((2 integer)) <- ((copy)) ((3 literal)))
cn1: (((reply)))
cn1: (((3 integer)) <- ((copy)) ((34 literal)))
schedule: main
run: main 0: (((2 integer)) <- ((copy)) ((1 literal)))
run: main 0: 1 => ((2 integer))
mem: ((2 integer)): 2 <= 1
run: main 1: (((1 boolean)) <- ((equal)) ((1 literal)) ((2 integer)))
mem: ((2 integer)) => 1
run: main 1: t => ((1 boolean))
mem: ((1 boolean)): 1 <= t
run: main 2: (((jump-if)) ((1 boolean)) ((1 offset)))
mem: ((1 boolean)) => t
run: main 4: (((reply)))
schedule: done with routine nil
9ed ^
d2680fb ^
3bc4358 ^
d2680fb ^
efa99ed ^
5310d08 ^

d2680fb ^
3bc4358 ^
d2680fb ^
efa99ed ^
3bc4358 ^





5310d08 ^

bd2800a ^
3bc4358 ^
5310d08 ^
efa99ed ^
5310d08 ^
3bc4358 ^

bd2800a ^
efa99ed ^
37bf8b0 ^

d2680fb ^
dfab6f2 ^
d2680fb ^
d2680fb ^
efa99ed ^
37bf8b0 ^






3bc4358 ^
37bf8b0 ^





d437b89 ^
d2680fb ^
3bc4358 ^






d2680fb ^
efa99ed ^
711012e ^
dfab6f2 ^
3bc4358 ^






d2680fb ^
fb63b07 ^
cd635e6 ^


711012e ^
bd5e602 ^

c87acad ^
747f4fb ^
06cffd8 ^
c87acad ^


893123c ^
bd23ef0 ^
78f4d8a ^
bd5e602 ^
d083ce6 ^
893123c ^
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
                                                      

        
             

                  
              

                                     
                                

 

                                                   
                 
 


                                                        
                                                  

                                                   
                        
                                       
                                         
 
                           
                                       
                                       
 
                           
                                       
                                           
 

                                                          
                                        
                                       
                                             
 





                                                     

                                                                      
                                                                             
                                       
                                               
 
                                                                             

                                                                            
                                               
 

                                                                            
                                                         
                                                                                 
                                
                                                   
 






                                                            
                                                            





                                                                 
                                 
                                             






                                               
                                               
 
                                                
                                                                   






                                                                   
                                           
 


                                                   
 

                                                        
                               
                                                                            
                                      


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

import (
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/gorilla/handlers"
	"github.com/gorilla/mux"
)

// Start is the initialization function for getwtxt
func Start() {
	initSvc()

	// StrictSlash(true) allows /api and /api/
	// to serve the same content without duplicating
	// handlers/paths
	index := mux.NewRouter().StrictSlash(true)
	api := index.PathPrefix("/api").Subrouter()

	index.Path("/").
		Methods("GET", "HEAD").
		HandlerFunc(indexHandler)

	index.Path("/css").
		Methods("GET", "HEAD").
		HandlerFunc(cssHandler)

	index.Path("/api").
		Methods("GET", "HEAD").
		HandlerFunc(apiBaseHandler)

	// twtxt will add support for other formats later.
	// Maybe json? Making this future-proof.
	api.Path("/{format:(?:plain)}").
		Methods("GET", "HEAD").
		HandlerFunc(apiFormatHandler)

	// Non-standard API call to list *all* tweets
	// in a single request.
	api.Path("/{format:(?:plain)}/tweets/all").
		Methods("GET", "HEAD").
		HandlerFunc(apiAllTweetsHandler)

	// Specifying the endpoint with and without query information.
	// Will return 404 on empty queries otherwise.
	api.Path("/{format:(?:plain)}/{endpoint:(?:mentions|users|tweets)}").
		Methods("GET", "HEAD").
		HandlerFunc(apiEndpointHandler)

	api.Path("/{format:(?:plain)}/{endpoint:(?:mentions|users|tweets)}").
		Queries("url", "{url}", "q", "{query}", "page", "{[0-9]+}").
		Methods("GET", "HEAD").
		HandlerFunc(apiEndpointHandler)

	// This is for submitting new users. Both query variables must exist
	// in the request for this to match.
	api.Path("/{format:(?:plain)}/{endpoint:users}").
		Queries("url", "{url}", "nickname", "{nickname:[a-zA-Z0-9_-]+}").
		Methods("POST").
		HandlerFunc(apiEndpointPOSTHandler)

	// This is for submitting new users incorrectly
	// and letting the requester know about their error.
	api.Path("/{format:(?:plain)}/{endpoint:users}").
		Queries("url", "{url}").
		Methods("POST").
		HandlerFunc(apiEndpointPOSTHandler)

	// This is also for submitting new users incorrectly
	// and letting the requester know about their error.
	api.Path("/{format:(?:plain)}/{endpoint:users}").
		Queries("nickname", "{nickname:[a-zA-Z0-9_-]+}").
		Methods("POST").
		HandlerFunc(apiEndpointPOSTHandler)

	// Show all observed tags
	api.Path("/{format:(?:plain)}/tags").
		Methods("GET", "HEAD").
		HandlerFunc(apiTagsBaseHandler)

	// Show Nth page of all observed tags
	api.Path("/{format:(?:plain)}/tags").
		Queries("page", "{[0-9]+}").
		Methods("GET", "HEAD").
		HandlerFunc(apiTagsBaseHandler)

	// Requests statuses with a specific tag
	api.Path("/{format:(?:plain)}/tags/{tags:[a-zA-Z0-9_-]+}").
		Methods("GET", "HEAD").
		HandlerFunc(apiTagsHandler)

	// Requests Nth page of statuses with a specific tag
	api.Path("/{format:(?:plain)}/tags/{tags:[a-zA-Z0-9_-]+}").
		Queries("page", "{[0-9]+}").
		Methods("GET", "HEAD").
		HandlerFunc(apiTagsHandler)

	confObj.Mu.RLock()
	portnum := fmt.Sprintf(":%v", confObj.Port)
	confObj.Mu.RUnlock()

	// handlers.CompressHandler gzips all responses.
	// Write/Read timeouts are self explanatory.
	server := &http.Server{
		Handler:      handlers.CompressHandler(ipMiddleware(index)),
		Addr:         portnum,
		WriteTimeout: 15 * time.Second,
		ReadTimeout:  15 * time.Second,
	}

	log.Printf("Listening on %v\n", portnum)
	errLog("", server.ListenAndServe())

	closeLog <- true
}