Merge branch 'master' into 3036-collection-uuids
[arvados.git] / services / keepstore / keepstore.go
1 package main
2
3 import (
4         "bytes"
5         "flag"
6         "fmt"
7         "io/ioutil"
8         "log"
9         "net"
10         "net/http"
11         "os"
12         "os/signal"
13         "strings"
14         "syscall"
15         "time"
16 )
17
18 // ======================
19 // Configuration settings
20 //
21 // TODO(twp): make all of these configurable via command line flags
22 // and/or configuration file settings.
23
24 // Default TCP address on which to listen for requests.
25 // Initialized by the --listen flag.
26 const DEFAULT_ADDR = ":25107"
27
28 // A Keep "block" is 64MB.
29 const BLOCKSIZE = 64 * 1024 * 1024
30
31 // A Keep volume must have at least MIN_FREE_KILOBYTES available
32 // in order to permit writes.
33 const MIN_FREE_KILOBYTES = BLOCKSIZE / 1024
34
35 var PROC_MOUNTS = "/proc/mounts"
36
37 // The Keep VolumeManager maintains a list of available volumes.
38 // Initialized by the --volumes flag (or by FindKeepVolumes).
39 var KeepVM VolumeManager
40
41 // enforce_permissions controls whether permission signatures
42 // should be enforced (affecting GET and DELETE requests).
43 // Initialized by the --enforce-permissions flag.
44 var enforce_permissions bool
45
46 // permission_ttl is the time duration for which new permission
47 // signatures (returned by PUT requests) will be valid.
48 // Initialized by the --permission-ttl flag.
49 var permission_ttl time.Duration
50
51 // data_manager_token represents the API token used by the
52 // Data Manager, and is required on certain privileged operations.
53 // Initialized by the --data-manager-token-file flag.
54 var data_manager_token string
55
56 // never_delete can be used to prevent the DELETE handler from
57 // actually deleting anything.
58 var never_delete = false
59
60 // ==========
61 // Error types.
62 //
63 type KeepError struct {
64         HTTPCode int
65         ErrMsg   string
66 }
67
68 var (
69         BadRequestError     = &KeepError{400, "Bad Request"}
70         CollisionError      = &KeepError{500, "Collision"}
71         RequestHashError    = &KeepError{422, "Hash mismatch in request"}
72         PermissionError     = &KeepError{403, "Forbidden"}
73         DiskHashError       = &KeepError{500, "Hash mismatch in stored data"}
74         ExpiredError        = &KeepError{401, "Expired permission signature"}
75         NotFoundError       = &KeepError{404, "Not Found"}
76         GenericError        = &KeepError{500, "Fail"}
77         FullError           = &KeepError{503, "Full"}
78         TooLongError        = &KeepError{504, "Timeout"}
79         MethodDisabledError = &KeepError{405, "Method disabled"}
80 )
81
82 func (e *KeepError) Error() string {
83         return e.ErrMsg
84 }
85
86 // TODO(twp): continue moving as much code as possible out of main
87 // so it can be effectively tested. Esp. handling and postprocessing
88 // of command line flags (identifying Keep volumes and initializing
89 // permission arguments).
90
91 func main() {
92         log.Println("Keep started: pid", os.Getpid())
93
94         // Parse command-line flags:
95         //
96         // -listen=ipaddr:port
97         //    Interface on which to listen for requests. Use :port without
98         //    an ipaddr to listen on all network interfaces.
99         //    Examples:
100         //      -listen=127.0.0.1:4949
101         //      -listen=10.0.1.24:8000
102         //      -listen=:25107 (to listen to port 25107 on all interfaces)
103         //
104         // -volumes
105         //    A comma-separated list of directories to use as Keep volumes.
106         //    Example:
107         //      -volumes=/var/keep01,/var/keep02,/var/keep03/subdir
108         //
109         //    If -volumes is empty or is not present, Keep will select volumes
110         //    by looking at currently mounted filesystems for /keep top-level
111         //    directories.
112
113         var (
114                 data_manager_token_file string
115                 listen                  string
116                 permission_key_file     string
117                 permission_ttl_sec      int
118                 serialize_io            bool
119                 volumearg               string
120                 pidfile                 string
121         )
122         flag.StringVar(
123                 &data_manager_token_file,
124                 "data-manager-token-file",
125                 "",
126                 "File with the API token used by the Data Manager. All DELETE "+
127                         "requests or GET /index requests must carry this token.")
128         flag.BoolVar(
129                 &enforce_permissions,
130                 "enforce-permissions",
131                 false,
132                 "Enforce permission signatures on requests.")
133         flag.StringVar(
134                 &listen,
135                 "listen",
136                 DEFAULT_ADDR,
137                 "Interface on which to listen for requests, in the format "+
138                         "ipaddr:port. e.g. -listen=10.0.1.24:8000. Use -listen=:port "+
139                         "to listen on all network interfaces.")
140         flag.BoolVar(
141                 &never_delete,
142                 "never-delete",
143                 false,
144                 "If set, nothing will be deleted. HTTP 405 will be returned "+
145                         "for valid DELETE requests.")
146         flag.StringVar(
147                 &permission_key_file,
148                 "permission-key-file",
149                 "",
150                 "File containing the secret key for generating and verifying "+
151                         "permission signatures.")
152         flag.IntVar(
153                 &permission_ttl_sec,
154                 "permission-ttl",
155                 1209600,
156                 "Expiration time (in seconds) for newly generated permission "+
157                         "signatures.")
158         flag.BoolVar(
159                 &serialize_io,
160                 "serialize",
161                 false,
162                 "If set, all read and write operations on local Keep volumes will "+
163                         "be serialized.")
164         flag.StringVar(
165                 &volumearg,
166                 "volumes",
167                 "",
168                 "Comma-separated list of directories to use for Keep volumes, "+
169                         "e.g. -volumes=/var/keep1,/var/keep2. If empty or not "+
170                         "supplied, Keep will scan mounted filesystems for volumes "+
171                         "with a /keep top-level directory.")
172
173         flag.StringVar(
174                 &pidfile,
175                 "pid",
176                 "",
177                 "Path to write pid file")
178
179         flag.Parse()
180
181         // Look for local keep volumes.
182         var keepvols []string
183         if volumearg == "" {
184                 // TODO(twp): decide whether this is desirable default behavior.
185                 // In production we may want to require the admin to specify
186                 // Keep volumes explicitly.
187                 keepvols = FindKeepVolumes()
188         } else {
189                 keepvols = strings.Split(volumearg, ",")
190         }
191
192         // Check that the specified volumes actually exist.
193         var goodvols []Volume = nil
194         for _, v := range keepvols {
195                 if _, err := os.Stat(v); err == nil {
196                         log.Println("adding Keep volume:", v)
197                         newvol := MakeUnixVolume(v, serialize_io)
198                         goodvols = append(goodvols, &newvol)
199                 } else {
200                         log.Printf("bad Keep volume: %s\n", err)
201                 }
202         }
203
204         if len(goodvols) == 0 {
205                 log.Fatal("could not find any keep volumes")
206         }
207
208         // Initialize data manager token and permission key.
209         // If these tokens are specified but cannot be read,
210         // raise a fatal error.
211         if data_manager_token_file != "" {
212                 if buf, err := ioutil.ReadFile(data_manager_token_file); err == nil {
213                         data_manager_token = strings.TrimSpace(string(buf))
214                 } else {
215                         log.Fatalf("reading data manager token: %s\n", err)
216                 }
217         }
218         if permission_key_file != "" {
219                 if buf, err := ioutil.ReadFile(permission_key_file); err == nil {
220                         PermissionSecret = bytes.TrimSpace(buf)
221                 } else {
222                         log.Fatalf("reading permission key: %s\n", err)
223                 }
224         }
225
226         // Initialize permission TTL
227         permission_ttl = time.Duration(permission_ttl_sec) * time.Second
228
229         // If --enforce-permissions is true, we must have a permission key
230         // to continue.
231         if PermissionSecret == nil {
232                 if enforce_permissions {
233                         log.Fatal("--enforce-permissions requires a permission key")
234                 } else {
235                         log.Println("Running without a PermissionSecret. Block locators " +
236                                 "returned by this server will not be signed, and will be rejected " +
237                                 "by a server that enforces permissions.")
238                         log.Println("To fix this, run Keep with --permission-key-file=<path> " +
239                                 "to define the location of a file containing the permission key.")
240                 }
241         }
242
243         // Start a round-robin VolumeManager with the volumes we have found.
244         KeepVM = MakeRRVolumeManager(goodvols)
245
246         // Tell the built-in HTTP server to direct all requests to the REST
247         // router.
248         http.Handle("/", MakeRESTRouter())
249
250         // Set up a TCP listener.
251         listener, err := net.Listen("tcp", listen)
252         if err != nil {
253                 log.Fatal(err)
254         }
255
256         // Shut down the server gracefully (by closing the listener)
257         // if SIGTERM is received.
258         term := make(chan os.Signal, 1)
259         go func(sig <-chan os.Signal) {
260                 s := <-sig
261                 log.Println("caught signal:", s)
262                 listener.Close()
263         }(term)
264         signal.Notify(term, syscall.SIGTERM)
265
266         if pidfile != "" {
267                 f, err := os.Create(pidfile)
268                 if err == nil {
269                         fmt.Fprint(f, os.Getpid())
270                         f.Close()
271                 } else {
272                         log.Printf("Error writing pid file (%s): %s", pidfile, err.Error())
273                 }
274         }
275
276         // Start listening for requests.
277         srv := &http.Server{Addr: listen}
278         srv.Serve(listener)
279
280         log.Println("shutting down")
281
282         if pidfile != "" {
283                 os.Remove(pidfile)
284         }
285 }