Statistics
| Branch: | Tag: | Revision:

root / lib / ssconf.py @ a21dda8b

History | View | Annotate | Download (5.6 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007 Google Inc.
5
#
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.
10
#
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.
15
#
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
19
# 02110-1301, USA.
20

    
21

    
22
"""Global Configuration data for Ganeti.
23

24
This module provides the interface to a special case of cluster
25
configuration data, which is mostly static and available to all nodes.
26

27
"""
28

    
29
import socket
30

    
31
from ganeti import errors
32
from ganeti import constants
33
from ganeti import utils
34

    
35

    
36
class SimpleStore:
37
  """Interface to static cluster data.
38

39
  This is different that the config.ConfigWriter class in that it
40
  holds data that is (mostly) constant after the cluster
41
  initialization. Its purpose is to allow limited customization of
42
  things which would otherwise normally live in constants.py. Note
43
  that this data cannot live in ConfigWriter as that is available only
44
  on the master node, and our data must be readable by both the master
45
  and the nodes.
46

47
  Other particularities of the datastore:
48
    - keys are restricted to predefined values
49
    - values are small (<4k)
50
    - since the data is practically static, read keys are cached in memory
51
    - some keys are handled specially (read from the system, so
52
      we can't update them)
53

54
  """
55
  _SS_FILEPREFIX = "ssconf_"
56
  SS_HYPERVISOR = "hypervisor"
57
  SS_NODED_PASS = "node_pass"
58
  SS_MASTER_NODE = "master_node"
59
  SS_MASTER_IP = "master_ip"
60
  SS_MASTER_NETDEV = "master_netdev"
61
  SS_CLUSTER_NAME = "cluster_name"
62
  SS_FILE_STORAGE_DIR = "file_storage_dir"
63
  SS_CONFIG_VERSION = "config_version"
64
  _VALID_KEYS = (SS_HYPERVISOR, SS_NODED_PASS, SS_MASTER_NODE, SS_MASTER_IP,
65
                 SS_MASTER_NETDEV, SS_CLUSTER_NAME, SS_FILE_STORAGE_DIR,
66
                 SS_CONFIG_VERSION)
67
  _MAX_SIZE = 4096
68

    
69
  def __init__(self, cfg_location=None):
70
    if cfg_location is None:
71
      self._cfg_dir = constants.DATA_DIR
72
    else:
73
      self._cfg_dir = cfg_location
74
    self._cache = {}
75

    
76
  def KeyToFilename(self, key):
77
    """Convert a given key into filename.
78

79
    """
80
    if key not in self._VALID_KEYS:
81
      raise errors.ProgrammerError("Invalid key requested from SSConf: '%s'"
82
                                   % str(key))
83

    
84
    filename = self._cfg_dir + '/' + self._SS_FILEPREFIX + key
85
    return filename
86

    
87
  def _ReadFile(self, key):
88
    """Generic routine to read keys.
89

90
    This will read the file which holds the value requested. Errors
91
    will be changed into ConfigurationErrors.
92

93
    """
94
    if key in self._cache:
95
      return self._cache[key]
96
    filename = self.KeyToFilename(key)
97
    try:
98
      fh = file(filename, 'r')
99
      try:
100
        data = fh.readline(self._MAX_SIZE)
101
        data = data.rstrip('\n')
102
      finally:
103
        fh.close()
104
    except EnvironmentError, err:
105
      raise errors.ConfigurationError("Can't read from the ssconf file:"
106
                                      " '%s'" % str(err))
107
    self._cache[key] = data
108
    return data
109

    
110
  def GetNodeDaemonPort(self):
111
    """Get the node daemon port for this cluster.
112

113
    Note that this routine does not read a ganeti-specific file, but
114
    instead uses socket.getservbyname to allow pre-customization of
115
    this parameter outside of ganeti.
116

117
    """
118
    try:
119
      port = socket.getservbyname("ganeti-noded", "tcp")
120
    except socket.error:
121
      port = constants.DEFAULT_NODED_PORT
122

    
123
    return port
124

    
125
  def GetHypervisorType(self):
126
    """Get the hypervisor type for this cluster.
127

128
    """
129
    return self._ReadFile(self.SS_HYPERVISOR)
130

    
131
  def GetNodeDaemonPassword(self):
132
    """Get the node password for this cluster.
133

134
    """
135
    return self._ReadFile(self.SS_NODED_PASS)
136

    
137
  def GetMasterNode(self):
138
    """Get the hostname of the master node for this cluster.
139

140
    """
141
    return self._ReadFile(self.SS_MASTER_NODE)
142

    
143
  def GetMasterIP(self):
144
    """Get the IP of the master node for this cluster.
145

146
    """
147
    return self._ReadFile(self.SS_MASTER_IP)
148

    
149
  def GetMasterNetdev(self):
150
    """Get the netdev to which we'll add the master ip.
151

152
    """
153
    return self._ReadFile(self.SS_MASTER_NETDEV)
154

    
155
  def GetClusterName(self):
156
    """Get the cluster name.
157

158
    """
159
    return self._ReadFile(self.SS_CLUSTER_NAME)
160

    
161
  def GetFileStorageDir(self):
162
    """Get the file storage dir.
163

164
    """
165
    return self._ReadFile(self.SS_FILE_STORAGE_DIR)
166

    
167
  def GetConfigVersion(self):
168
    """Get the configuration version.
169

170
    """
171
    value = self._ReadFile(self.SS_CONFIG_VERSION)
172
    try:
173
      return int(value)
174
    except (ValueError, TypeError), err:
175
      raise errors.ConfigurationError("Failed to convert config version %s to"
176
                                      " int: '%s'" % (value, str(err)))
177

    
178
  def SetKey(self, key, value):
179
    """Set the value of a key.
180

181
    This should be used only when adding a node to a cluster, or in other
182
    infrequent operations such as cluster-rename or master-failover.
183

184
    """
185
    file_name = self.KeyToFilename(key)
186
    utils.WriteFile(file_name, data="%s\n" % str(value),
187
                    uid=0, gid=0, mode=0400)
188
    self._cache[key] = value
189

    
190
  def GetFileList(self):
191
    """Return the list of all config files.
192

193
    This is used for computing node replication data.
194

195
    """
196
    return [self.KeyToFilename(key) for key in self._VALID_KEYS]