4 # Copyright (C) 2006, 2007, 2008 Google Inc.
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful, but
12 # WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 """Functions to bootstrap a new cluster.
32 from ganeti import rpc
33 from ganeti import ssh
34 from ganeti import utils
35 from ganeti import errors
36 from ganeti import config
37 from ganeti import constants
38 from ganeti import ssconf
41 def _InitSSHSetup(node):
42 """Setup the SSH configuration for the cluster.
45 This generates a dsa keypair for root, adds the pub key to the
46 permitted hosts and adds the hostkey to its own known hosts.
49 node: the name of this host as a fqdn
52 priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
54 for name in priv_key, pub_key:
55 if os.path.exists(name):
56 utils.CreateBackup(name)
57 utils.RemoveFile(name)
59 result = utils.RunCmd(["ssh-keygen", "-t", "dsa",
63 raise errors.OpExecError("Could not generate ssh keypair, error %s" %
66 f = open(pub_key, 'r')
68 utils.AddAuthorizedKey(auth_keys, f.read(8192))
73 def _InitGanetiServerSetup(ss):
74 """Setup the necessary configuration for the initial node daemon.
76 This creates the nodepass file containing the shared password for
77 the cluster and also generates the SSL certificate.
80 ss: A WritableSimpleStore
83 # Create pseudo random password
84 randpass = sha.new(os.urandom(64)).hexdigest()
85 # and write it into sstore
86 ss.SetKey(ss.SS_NODED_PASS, randpass)
88 result = utils.RunCmd(["openssl", "req", "-new", "-newkey", "rsa:1024",
89 "-days", str(365*5), "-nodes", "-x509",
90 "-keyout", constants.SSL_CERT_FILE,
91 "-out", constants.SSL_CERT_FILE, "-batch"])
93 raise errors.OpExecError("could not generate server ssl cert, command"
94 " %s had exitcode %s and error message %s" %
95 (result.cmd, result.exit_code, result.output))
97 os.chmod(constants.SSL_CERT_FILE, 0400)
99 result = utils.RunCmd([constants.NODE_INITD_SCRIPT, "restart"])
102 raise errors.OpExecError("Could not start the node daemon, command %s"
103 " had exitcode %s and error %s" %
104 (result.cmd, result.exit_code, result.output))
107 def InitCluster(cluster_name, hypervisor_type, mac_prefix, def_bridge,
108 master_netdev, file_storage_dir,
111 """Initialise the cluster.
114 if config.ConfigWriter.IsCluster():
115 raise errors.OpPrereqError("Cluster is already initialised")
117 if hypervisor_type == constants.HT_XEN_HVM31:
118 if not os.path.exists(constants.VNC_PASSWORD_FILE):
119 raise errors.OpPrereqError("Please prepare the cluster VNC"
121 constants.VNC_PASSWORD_FILE)
123 hostname = utils.HostInfo()
125 if hostname.ip.startswith("127."):
126 raise errors.OpPrereqError("This host's IP resolves to the private"
127 " range (%s). Please fix DNS or %s." %
128 (hostname.ip, constants.ETC_HOSTS))
130 if not utils.TcpPing(hostname.ip, constants.DEFAULT_NODED_PORT,
131 source=constants.LOCALHOST_IP_ADDRESS):
132 raise errors.OpPrereqError("Inconsistency: this host's name resolves"
133 " to %s,\nbut this ip address does not"
134 " belong to this host."
135 " Aborting." % hostname.ip)
137 clustername = utils.HostInfo(cluster_name)
139 if utils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT,
141 raise errors.OpPrereqError("Cluster IP already active. Aborting.")
144 if not utils.IsValidIP(secondary_ip):
145 raise errors.OpPrereqError("Invalid secondary ip given")
146 if (secondary_ip != hostname.ip and
147 (not utils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,
148 source=constants.LOCALHOST_IP_ADDRESS))):
149 raise errors.OpPrereqError("You gave %s as secondary IP,"
150 " but it does not belong to this host." %
153 if vg_name is not None:
154 # Check if volume group is valid
155 vgstatus = utils.CheckVolumeGroupSize(utils.ListVolumeGroups(), vg_name,
156 constants.MIN_VG_SIZE)
158 raise errors.OpPrereqError("Error: %s\nspecify --no-lvm-storage if"
159 " you are not using lvm" % vgstatus)
161 file_storage_dir = os.path.normpath(file_storage_dir)
163 if not os.path.isabs(file_storage_dir):
164 raise errors.OpPrereqError("The file storage directory you passed is"
165 " not an absolute path.")
167 if not os.path.exists(file_storage_dir):
169 os.makedirs(file_storage_dir, 0750)
171 raise errors.OpPrereqError("Cannot create file storage directory"
173 (file_storage_dir, err))
175 if not os.path.isdir(file_storage_dir):
176 raise errors.OpPrereqError("The file storage directory '%s' is not"
177 " a directory." % file_storage_dir)
179 if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$", mac_prefix):
180 raise errors.OpPrereqError("Invalid mac prefix given '%s'" % mac_prefix)
182 if hypervisor_type not in constants.HYPER_TYPES:
183 raise errors.OpPrereqError("Invalid hypervisor type given '%s'" %
186 result = utils.RunCmd(["ip", "link", "show", "dev", master_netdev])
188 raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
190 result.output.strip()))
192 if not (os.path.isfile(constants.NODE_INITD_SCRIPT) and
193 os.access(constants.NODE_INITD_SCRIPT, os.X_OK)):
194 raise errors.OpPrereqError("Init.d script '%s' missing or not"
195 " executable." % constants.NODE_INITD_SCRIPT)
197 # set up the simple store
198 ss = ssconf.WritableSimpleStore()
199 ss.SetKey(ss.SS_HYPERVISOR, hypervisor_type)
200 ss.SetKey(ss.SS_MASTER_NODE, hostname.name)
201 ss.SetKey(ss.SS_MASTER_IP, clustername.ip)
202 ss.SetKey(ss.SS_MASTER_NETDEV, master_netdev)
203 ss.SetKey(ss.SS_CLUSTER_NAME, clustername.name)
204 ss.SetKey(ss.SS_FILE_STORAGE_DIR, file_storage_dir)
205 ss.SetKey(ss.SS_CONFIG_VERSION, constants.CONFIG_VERSION)
207 # set up the inter-node password and certificate
208 _InitGanetiServerSetup(ss)
210 # start the master ip
211 # TODO: Review rpc call from bootstrap
212 rpc.call_node_start_master(hostname.name)
214 # set up ssh config and /etc/hosts
215 f = open(constants.SSH_HOST_RSA_PUB, 'r')
220 sshkey = sshline.split(" ")[1]
222 utils.AddHostToEtcHosts(hostname.name)
223 _InitSSHSetup(hostname.name)
225 # init of cluster config file
226 cfg = config.ConfigWriter()
227 cfg.InitConfig(hostname.name, hostname.ip, secondary_ip, sshkey,
228 mac_prefix, vg_name, def_bridge)
230 ssh.WriteKnownHostsFile(cfg, ss, constants.SSH_KNOWN_HOSTS_FILE)
233 def SetupNodeDaemon(node):
234 """Add a node to the cluster.
236 This function must be called before the actual opcode, and will ssh
237 to the remote node, copy the needed files, and start ganeti-noded,
238 allowing the master to do the rest via normal rpc calls.
241 node: fully qualified domain name for the new node
244 ss = ssconf.SimpleStore()
245 sshrunner = ssh.SshRunner(ss)
246 gntpass = ss.GetNodeDaemonPassword()
247 if not re.match('^[a-zA-Z0-9.]{1,64}$', gntpass):
248 raise errors.OpExecError("ganeti password corruption detected")
249 f = open(constants.SSL_CERT_FILE)
251 gntpem = f.read(8192)
254 # in the base64 pem encoding, neither '!' nor '.' are valid chars,
255 # so we use this to detect an invalid certificate; as long as the
256 # cert doesn't contain this, the here-document will be correctly
257 # parsed by the shell sequence below
258 if re.search('^!EOF\.', gntpem, re.MULTILINE):
259 raise errors.OpExecError("invalid PEM encoding in the SSL certificate")
260 if not gntpem.endswith("\n"):
261 raise errors.OpExecError("PEM must end with newline")
263 # set up inter-node password and certificate and restarts the node daemon
264 # and then connect with ssh to set password and start ganeti-noded
265 # note that all the below variables are sanitized at this point,
266 # either by being constants or by the checks above
267 mycommand = ("umask 077 && "
268 "echo '%s' > '%s' && "
269 "cat > '%s' << '!EOF.' && \n"
270 "%s!EOF.\n%s restart" %
271 (gntpass, ss.KeyToFilename(ss.SS_NODED_PASS),
272 constants.SSL_CERT_FILE, gntpem,
273 constants.NODE_INITD_SCRIPT))
275 result = sshrunner.Run(node, 'root', mycommand, batch=False, ask_key=True)
277 raise errors.OpExecError("Remote command on node %s, error: %s,"
279 (node, result.fail_reason, result.output))
284 def MasterFailover():
285 """Failover the master node.
287 This checks that we are not already the master, and will cause the
288 current master to cease being master, and the non-master to become
292 ss = ssconf.WritableSimpleStore()
294 new_master = utils.HostInfo().name
295 old_master = ss.GetMasterNode()
297 if old_master == new_master:
298 raise errors.OpPrereqError("This commands must be run on the node"
299 " where you want the new master to be."
300 " %s is already the master" %
306 logging.info("setting master to %s, old master: %s", new_master, old_master)
308 if not rpc.call_node_stop_master(old_master, True):
309 logging.error("could disable the master role on the old master"
310 " %s, please disable manually", old_master)
312 ss.SetKey(ss.SS_MASTER_NODE, new_master)
314 cfg = config.ConfigWriter()
316 if not rpc.call_upload_file(cfg.GetNodeList(),
317 ss.KeyToFilename(ss.SS_MASTER_NODE)):
318 logging.error("could not distribute the new simple store master file"
319 " to the other nodes, please check.")
321 if not rpc.call_node_start_master(new_master, True):
322 logging.error("could not start the master role on the new master"
323 " %s, please check", new_master)