-
Notifications
You must be signed in to change notification settings - Fork 0
/
config.py
223 lines (194 loc) · 8.79 KB
/
config.py
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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
from typing import List
from pyconfigparser import configparser, ConfigError
from schema import Use, And, Optional
SCHEMA_CONFIG = {
'opscenter': {
'opscenter_username': And(Use(str), lambda string: len(string) > 0),
'opscenter_password': And(Use(str), lambda string: len(string) > 0),
'opscenter_server_url': And(Use(str), lambda string: len(string) > 0),
},
'dse': {
'cluster_name': And(Use(str), lambda string: len(string) > 0),
'datastax_version': And(Use(str), lambda string: len(string) > 0),
'repository_name': And(Use(str), lambda string: len(string) > 0),
Optional('repository_url'): And(Use(str), lambda string: len(string) > 0),
Optional('repository_key_url'): And(Use(str), lambda string: len(string) > 0),
Optional('repository_use_proxy'): Use(bool),
'install_credential_name': And(Use(str), lambda string: len(string) > 0),
'install_credential_username': And(Use(str), lambda string: len(string) > 0),
Optional('install_credential_key_file'): And(Use(str), lambda string: len(string) > 0),
Optional('install_credential_password'): And(Use(str), lambda string: len(string) > 0),
Optional('install_credential_become_user'): And(Use(str), lambda string: len(string) > 0),
Optional('install_credential_become_password'): And(Use(str), lambda string: len(string) > 0),
Optional('install_credential_become_mode'): And(Use(str), lambda string: len(string) > 0),
'cassandra_default_password': And(Use(str), lambda string: len(string) > 0),
Optional('node_sync'): [{
'pattern': And(Use(str), lambda string: len(string) > 0),
}]
},
'config_profiles': [{
'name': And(Use(str), lambda string: len(string) > 0),
Optional('cassandra_yaml'): Use(str),
Optional('cassandra_env_sh'): Use(str),
Optional('dse_env_sh'): Use(str),
Optional('dse_yaml'): Use(str),
}],
'cluster': {
'config_profile_name': And(Use(str), lambda string: len(string) > 0),
'datacenters': [{
'name': And(Use(str), lambda string: len(string) > 0),
'solr_enabled': And(Use(bool)),
'spark_enabled': And(Use(bool)),
'graph_enabled': And(Use(bool)),
'hadoop_enabled': And(Use(bool)),
Optional('config_profile_name'): Use(str),
'nodes': [{
'name': And(Use(str), lambda string: len(string) > 0),
'private_ip': And(Use(str), lambda string: len(string) > 0),
'node_ip': And(Use(str), lambda string: len(string) > 0),
'rack': And(Use(str), lambda string: len(string) > 0),
Optional('config_profile_name'): Optional(str),
}]
}]
}
}
class NodeConfiguration:
name = None
private_ip = None
node_ip = None
rack = None
config_profile_name = None
def __init__(self, name, private_ip, node_ip, rack, config_profile_name=None):
self.name = name
self.private_ip = private_ip
self.node_ip = node_ip
self.rack = rack
self.config_profile_name = config_profile_name
class DatacenterConfiguration:
name = None
solr_enabled = None
spark_enabled = None
graph_enabled = None
hadoop_enabled = None
config_profile_name = None
node_configuration: List[NodeConfiguration] = None
def __init__(self, name, solr_enabled, spark_enabled, graph_enabled, hadoop_enabled, node_configuration,
config_profile_name=None):
self.name = name
self.solr_enabled = solr_enabled
self.spark_enabled = spark_enabled
self.graph_enabled = graph_enabled
self.hadoop_enabled = hadoop_enabled
self.node_configuration = node_configuration
self.config_profile_name = config_profile_name
class ConfigProfileConfiguration:
name = None
cassandra_yaml = None
cassandra_env_sh = None
dse_env_sh = None
dse_yaml = None
def __init__(self, name, cassandra_yaml=None, cassandra_env_sh=None, dse_env_sh=None, dse_yaml=None):
self.name = name
self.cassandra_yaml = cassandra_yaml
self.cassandra_env_sh = cassandra_env_sh
self.dse_env_sh = dse_env_sh
self.dse_yaml = dse_yaml
class NodeSyncConfiguration:
pattern = None
def __init__(self, pattern):
self.pattern = pattern
class OpsCenterConfiguration:
log_level = None
cluster_name = None
datastax_version = None
repository_name = None
repository_url = None
repository_key_url = None
repository_use_proxy = True
config_profile_name = None
username = None
password = None
server_url = None
install_credential_name = None
install_credential_username = None
install_credential_key = None
install_credential_password = None
install_credential_become_user = None
install_credential_become_password = None
install_credential_become_mode = "sudo"
cassandra_default_password = None
node_sync: List[NodeSyncConfiguration] = None
config_profiles: List[ConfigProfileConfiguration] = None
datacenter_configuration: List[DatacenterConfiguration] = None
def load_config(self, config_file):
# .config/config.yaml
try:
if not config_file:
config = configparser.get_config(SCHEMA_CONFIG)
else:
config = configparser.get_config(SCHEMA_CONFIG, config_dir='', file_name=config_file)
self.username = config['opscenter']['opscenter_username']
self.password = config['opscenter']['opscenter_password']
self.server_url = config['opscenter']['opscenter_server_url']
self.config_profile_name = config['cluster']['config_profile_name']
self.cluster_name = config['dse']['cluster_name']
self.datastax_version = config['dse']['datastax_version']
self.repository_name = config['dse']['repository_name']
self.repository_url = config['dse']['repository_url'] if 'repository_url' in config['dse'] else None
self.repository_key_url = config['dse']['repository_key_url'] if 'repository_key_url' in config['dse'] else None
self.repository_use_proxy = config['dse']['repository_use_proxy'] if 'repository_use_proxy' in config['dse'] else False
self.install_credential_name = config['dse']['install_credential_name']
self.install_credential_username = config['dse']['install_credential_username']
self.install_credential_password = config['dse']['install_credential_password'] if 'install_credential_password' in config['dse'] else None
self.install_credential_become_user = config['dse']['install_credential_become_user'] if 'install_credential_become_user' in config['dse'] else None
self.install_credential_become_password = config['dse']['install_credential_become_password'] if 'install_credential_become_password' in config['dse'] else None
self.install_credential_become_mode = config['dse']['install_credential_become_mode'] if 'install_credential_become_mode' in config['dse'] else self.install_credential_become_mode
self.cassandra_default_password = config['dse']['cassandra_default_password']
# SSH key
if 'install_credential_key_file' in config['dse']:
with open(config['dse']['install_credential_key_file'], 'r') as key_file:
self.install_credential_key = key_file.read()
# Initialise config profiles
if 'config_profiles' in config:
profiles = []
for config_profile in config['config_profiles']:
profiles += [
ConfigProfileConfiguration(
config_profile['name'],
cassandra_yaml=config_profile['cassandra_yaml'] if 'cassandra_yaml' in config_profile else None,
cassandra_env_sh=config_profile['cassandra_env_sh'] if 'cassandra_env_sh' in config_profile else None,
dse_env_sh=config_profile['dse_env_sh'] if 'dse_env_sh' in config_profile else None,
dse_yaml=config_profile['dse_yaml'] if 'dse_yaml' in config_profile else None
)
]
self.config_profiles = profiles
if 'node_sync' in config:
node_sync_tables = []
for node_sync in config['node_sync']:
node_sync_tables += [NodeSyncConfiguration(node_sync['pattern'])]
self.node_sync = node_sync_tables
# Initialise datacenter configurations
datacenters = []
for datacenter in config['cluster']['datacenters']:
nodes = []
for node in datacenter['nodes']:
nodes += [NodeConfiguration(
node['name'],
node['private_ip'],
node['node_ip'],
node['rack'],
node['config_profile_name'] if 'config_profile_name' in node else None
)]
datacenters += [DatacenterConfiguration(
datacenter['name'],
datacenter['solr_enabled'],
datacenter['spark_enabled'],
datacenter['graph_enabled'],
datacenter['hadoop_enabled'],
nodes,
config_profile_name=datacenter['config_profile_name'] if 'config_profile_name' in datacenter else None,
)]
self.datacenter_configuration = datacenters
except ConfigError as e:
print(e)
exit()