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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
package mongo
import (
"fmt"
"os"
"os/exec"
"path"
"path/filepath"
"github.com/juju/loggo"
"launchpad.net/juju-core/upstart"
"launchpad.net/juju-core/utils"
)
const (
maxFiles = 65000
maxProcs = 20000
)
var (
logger = loggo.GetLogger("juju.agent.mongo")
oldMongoServiceName = "juju-db"
// JujuMongodPath holds the default path to the juju-specific mongod.
JujuMongodPath = "/usr/lib/juju/bin/mongod"
// MongodbServerPath holds the default path to the generic mongod.
MongodbServerPath = "/usr/bin/mongod"
)
// MongoPackageForSeries returns the name of the mongo package for the series
// of the machine that it is going to be running on.
func MongoPackageForSeries(series string) string {
switch series {
case "precise", "quantal", "raring", "saucy":
return "mongodb-server"
default:
// trusty and onwards
return "juju-mongodb"
}
}
// MongodPathForSeries returns the path to the mongod executable for the
// series of the machine that it is going to be running on.
func MongodPathForSeries(series string) string {
if series == "trusty" {
return JujuMongodPath
}
return MongodbServerPath
}
// MongoPath returns the executable path to be used to run mongod on this
// machine. If the juju-bundled version of mongo exists, it will return that
// path, otherwise it will return the command to run mongod from the path.
func MongodPath() (string, error) {
if _, err := os.Stat(JujuMongodPath); err == nil {
return JujuMongodPath, nil
}
path, err := exec.LookPath("mongod")
if err != nil {
return "", err
}
return path, nil
}
// EnsureMongoServer ensures that the correct mongo upstart script is installed
// and running.
//
// This method will remove old versions of the mongo upstart script as necessary
// before installing the new version.
func EnsureMongoServer(dir string, port int) error {
// NOTE: ensure that the right package is installed?
name := makeServiceName(mongoScriptVersion)
// TODO: get the series from somewhere, non trusty values return
// the existing default path.
mongodPath := MongodPathForSeries("some-series")
service, err := MongoUpstartService(name, mongodPath, dir, port)
if err != nil {
return err
}
if service.Installed() {
return nil
}
if err := removeOldMongoServices(mongoScriptVersion); err != nil {
return err
}
if err := makeJournalDirs(dir); err != nil {
return err
}
if err := service.Install(); err != nil {
return fmt.Errorf("failed to install mongo service %q: %v", service.Name, err)
}
return service.Start()
}
func makeJournalDirs(dir string) error {
journalDir := path.Join(dir, "journal")
if err := os.MkdirAll(journalDir, 0700); err != nil {
logger.Errorf("failed to make mongo journal dir %s: %v", journalDir, err)
return err
}
// manually create the prealloc files, since otherwise they get created as 100M files.
zeroes := make([]byte, 64*1024) // should be enough for anyone
for x := 0; x < 3; x++ {
name := fmt.Sprintf("prealloc.%d", x)
filename := filepath.Join(journalDir, name)
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0700)
if err != nil {
return fmt.Errorf("failed to open mongo prealloc file %q: %v", filename, err)
}
defer f.Close()
for total := 0; total < 1024*1024; {
n, err := f.Write(zeroes)
if err != nil {
return fmt.Errorf("failed to write to mongo prealloc file %q: %v", filename, err)
}
total += n
}
}
return nil
}
// removeOldMongoServices looks for any old juju mongo upstart scripts and
// removes them.
func removeOldMongoServices(curVersion int) error {
old := upstart.NewService(oldMongoServiceName)
if err := old.StopAndRemove(); err != nil {
logger.Errorf("Failed to remove old mongo upstart service %q: %v", old.Name, err)
return err
}
// the new formatting for the script name started at version 2
for x := 2; x < curVersion; x++ {
old := upstart.NewService(makeServiceName(x))
if err := old.StopAndRemove(); err != nil {
logger.Errorf("Failed to remove old mongo upstart service %q: %v", old.Name, err)
return err
}
}
return nil
}
func makeServiceName(version int) string {
return fmt.Sprintf("juju-db-v%d", version)
}
// mongoScriptVersion keeps track of changes to the mongo upstart script.
// Update this version when you update the script that gets installed from
// MongoUpstartService.
const mongoScriptVersion = 2
// MongoUpstartService returns the upstart config for the mongo state service.
//
// This method assumes there is a server.pem keyfile in dataDir.
func MongoUpstartService(name, mongodExec, dataDir string, port int) (*upstart.Conf, error) {
keyFile := path.Join(dataDir, "server.pem")
svc := upstart.NewService(name)
dbDir := path.Join(dataDir, "db")
conf := &upstart.Conf{
Service: *svc,
Desc: "juju state database",
Limit: map[string]string{
"nofile": fmt.Sprintf("%d %d", maxFiles, maxFiles),
"nproc": fmt.Sprintf("%d %d", maxProcs, maxProcs),
},
Cmd: mongodExec +
" --auth" +
" --dbpath=" + dbDir +
" --sslOnNormalPorts" +
" --sslPEMKeyFile " + utils.ShQuote(keyFile) +
" --sslPEMKeyPassword ignored" +
" --bind_ip 0.0.0.0" +
" --port " + fmt.Sprint(port) +
" --noprealloc" +
" --syslog" +
" --smallfiles",
// TODO(Nate): uncomment when we commit HA stuff
// +
// " --replSet juju",
}
return conf, nil
}
|