63 |
64 |
80 |
81 | {% with messages = get_flashed_messages() %}
82 | {% if messages %}
83 |
90 | {% endif %}
91 | {% endwith %}
92 | {% block content %}{% endblock %}
93 |
94 |
95 |
96 |
97 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
--------------------------------------------------------------------------------
/app/templates/editor.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "editor" %}
3 | {% block content %}
4 |
5 |
53 | {% endblock %}
54 |
--------------------------------------------------------------------------------
/app/templates/hadoop.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "hadoop" %}
3 | {% block content %}
4 |
5 |
33 |
34 |
35 |
36 |
37 |
38 |
39 | {% if failed_host %}
40 |
41 | ERROR: Failed to connect to host {{ failed_host }} port 22: Network is unreachable.
42 |
43 | {% elif failed_auth %}
44 |
45 | ERROR: Failed to connect to host {{ master_hostname }} port 22: Authentication failed.
46 |
47 | {% elif none_host %}
48 |
49 | ERROR: Please choose a master_hostname at first.
50 |
51 | {% elif failed_cmd %}
52 |
53 | ERROR: Failed to execute command '{{ cmd }}' on host {{ master_hostname }}.
54 |
55 |
56 |
57 |
Output
58 |
59 |
60 | {% if out.stderr %}
61 |
{{ out.stderr }}
62 | {% endif %}
63 | {% if out.stdout %}
64 |
{{ out.stdout }}
65 | {% endif %}
66 |
67 |
68 | {% elif succeeded_cmd %}
69 |
70 | OK: Succeeded to execute command '{{ cmd }}' on host {{ master_hostname }}.
71 |
72 |
73 |
74 |
Output
75 |
76 |
77 |
{{ out.stdout }}
78 |
79 |
80 | {% endif %}
81 |
82 | {% endblock %}
83 |
--------------------------------------------------------------------------------
/app/templates/index.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "index" %}
3 | {% block content %}
4 |
5 |
6 |
Hi, {{ g.user.firstname }}!
7 | {% for post in posts %}
8 |
{{ post.author.nickname }} says: {{ post.body }}
9 | {% endfor %}
10 |
11 | {% endblock %}
12 |
--------------------------------------------------------------------------------
/app/templates/login.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "login" %}
3 | {% block content %}
4 |
56 | {% endblock %}
57 |
--------------------------------------------------------------------------------
/app/templates/operations.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "operations" %}
3 | {% block content %}
4 |
23 |
24 |
25 |
26 |
27 |
28 |
29 | {% if failed_host %}
30 |
31 | ERROR: Failed to connect to host {{ failed_host }} port 22: Network is unreachable.
32 |
33 | {% elif failed_auth %}
34 |
35 | ERROR: Failed to connect to host {{ hostname }} port 22: Authentication failed.
36 |
37 | {% elif blacklisted_word %}
38 |
39 | ERROR: The blacklisted word/character {{ blacklisted_word }} in command.
40 |
41 | {% elif failed_cmd %}
42 |
43 | ERROR: Failed to execute command '{{ cmd }}' on host {{ hostname }}.
44 |
45 |
46 |
47 |
Output
48 |
49 |
50 | {% if out.stderr %}
51 |
{{ out.stderr }}
52 | {% endif %}
53 | {% if out.stdout %}
54 |
{{ out.stdout }}
55 | {% endif %}
56 |
57 |
58 | {% elif succeeded_cmd %}
59 |
60 | OK: Succeeded to execute command '{{ cmd }}' on host {{ hostname }}.
61 |
62 |
63 |
64 |
Output
65 |
66 |
67 |
{{ out.stdout }}
68 |
69 |
70 | {% endif %}
71 |
72 | {% endblock %}
73 |
--------------------------------------------------------------------------------
/app/templates/racktables.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "racktables" %}
3 | {% block content %}
4 |
5 |
89 |
90 |
91 |
92 |
93 |
94 |
95 | {% if failed_cmd %}
96 |
97 | ERROR: Failed to execute command '{{ cmd }}'.
98 |
99 |
100 |
101 |
Output
102 |
103 |
104 | {% if out.stderr %}
105 |
{{ out.stderr }}
106 | {% endif %}
107 | {% if out.stdout %}
108 |
{{ out.stdout }}
109 | {% endif %}
110 |
111 |
112 | {% elif succeeded_cmd %}
113 |
114 | OK: Succeeded to execute command '{{ cmd }}'.
115 |
116 |
117 |
118 |
Output
119 |
120 |
121 |
{{ out.stdout }}
122 |
123 |
124 | {% endif %}
125 |
126 | {% endblock %}
127 |
--------------------------------------------------------------------------------
/app/templates/signup.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "signup" %}
3 | {% block content %}
4 |
77 | {% endblock %}
78 |
--------------------------------------------------------------------------------
/app/templates/status.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% set active_page = "status" %}
3 | {% block content %}
4 |
5 |
6 |
7 |
8 |
9 |
10 |
FQDN: {{ os_fqdn }}
11 |
Release: {{ os_release }}
12 |
Memory: {{ os_memory }}M
13 |
CPU: {{ cpu_type }}, {{cpu_cores}} Core(s)
14 |
Network: {{ os_network }}
15 |
Disk: {{ disk_usage }}
16 |
Stats:
17 | {% for top_info_item in top_info_list %}
18 | {{ top_info_item }}
19 | {% endfor %}
20 |
21 |
22 |
23 |
24 | {% endblock %}
25 |
--------------------------------------------------------------------------------
/app/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/app/utils/__init__.py
--------------------------------------------------------------------------------
/app/utils/operations.py:
--------------------------------------------------------------------------------
1 | #!/bin/env python
2 |
3 | '''
4 | A simple interface to execute shell commands.
5 | Reference: fabric/operations.py.
6 |
7 | Examples:
8 | >>> from operations import local,remote,get,put
9 |
10 | >>> out = local('uname -r')
11 | >>> print out
12 | 2.6.32
13 | >>> print out.stdout
14 | 2.6.32
15 | >>> print out.failed
16 | False
17 | >>> print out.succeeded
18 | True
19 |
20 | >>> out = remote('hostname --fqdn',hostname='heylinux.com',username='jobs',
21 | pkey='/path/to/rsa',port=8022)
22 | >>> print out
23 | heylinux.com
24 | >>> print out.failed
25 | False
26 | >>> print out.succeeded
27 | True
28 |
29 | >>> out = get('/tmp/remote.txt','/tmp/local.txt',hostname='heylinux.com',username='jobs',
30 | pkey='/path/to/dsa',pkey_type='dsa',port=8022)
31 | >>> print out.failed
32 | True
33 | >>> print out.succeeded
34 | False
35 | >>> print out.stderr
36 | No such file or directory
37 |
38 | >>> out = put('/tmp/local.txt','/tmp/remote.txt',hostname='heylinux.com',username='jobs',
39 | password='apple')
40 | >>> print out.failed
41 | False
42 | >>> print out.succeeded
43 | True
44 | '''
45 |
46 | import subprocess
47 | import paramiko
48 |
49 | class _AttributeString(str):
50 | """
51 | Simple string subclass to allow arbitrary attribute access.
52 | """
53 | @property
54 | def stdout(self):
55 | return str(self)
56 |
57 | def local(cmd, capture=True, shell=None):
58 | out_stream = subprocess.PIPE
59 | err_stream = subprocess.PIPE
60 | p = subprocess.Popen(cmd, shell=True, stdout=out_stream, stderr=err_stream, executable=shell)
61 | (stdout, stderr) = p.communicate()
62 |
63 | out = _AttributeString(stdout.strip() if stdout else "")
64 | err = _AttributeString(stderr.strip() if stderr else "")
65 |
66 | out.cmd = cmd
67 | out.failed = False
68 | out.return_code = p.returncode
69 | out.stderr = err
70 | if out.return_code != 0:
71 | out.failed = True
72 | out.succeeded = not out.failed
73 |
74 | return out
75 |
76 | def remote(cmd, hostname, username, password=None, pkey=None, pkey_type="rsa", port=22):
77 | p = paramiko.SSHClient()
78 | p.set_missing_host_key_policy(paramiko.AutoAddPolicy())
79 |
80 | if pkey is not None:
81 | if pkey_type == "dsa":
82 | pkey = paramiko.DSSKey.from_private_key_file(pkey)
83 | else:
84 | pkey = paramiko.RSAKey.from_private_key_file(pkey)
85 | p.connect(hostname=hostname, username=username, pkey=pkey, port=port)
86 | else:
87 | p.connect(hostname=hostname, username=username, password=password, port=port)
88 |
89 | (stdin, stdout, stderr) = p.exec_command(cmd)
90 |
91 | stdout_str=""
92 | stderr_str=""
93 | for line in stdout.readlines():
94 | stdout_str = stdout_str + line
95 | for line in stderr.readlines():
96 | stderr_str = stderr_str + line
97 |
98 | out = _AttributeString(stdout_str.strip() if stdout else "")
99 | err = _AttributeString(stderr_str.strip() if stderr else "")
100 |
101 | out.cmd = cmd
102 | out.failed = False
103 | out.return_code = stdout.channel.recv_exit_status()
104 | out.stderr = err
105 | if out.return_code != 0:
106 | out.failed = True
107 | out.succeeded = not out.failed
108 |
109 | p.close()
110 | return out
111 |
112 | def sftp(src_path, dest_path, hostname, username, password=None, pkey=None, pkey_type="rsa",
113 | port=22, transfer_type=None):
114 | p = paramiko.Transport((hostname,port))
115 |
116 | if pkey is not None:
117 | if pkey_type == "dsa":
118 | pkey = paramiko.DSSKey.from_private_key_file(pkey)
119 | else:
120 | pkey = paramiko.RSAKey.from_private_key_file(pkey)
121 | p.connect(username=username, pkey=pkey)
122 | else:
123 | p.connect(username=username, password=password)
124 |
125 | sftp = paramiko.SFTPClient.from_transport(p)
126 |
127 | out = _AttributeString()
128 | out.failed = False
129 | out.stderr = None
130 |
131 | if transfer_type is not None:
132 | try:
133 | if transfer_type == "get":
134 | sftp.get(src_path, dest_path)
135 | if transfer_type == "put":
136 | sftp.put(src_path, dest_path)
137 | except Exception, e:
138 | out.failed = True
139 | out.stderr = e.args[1]
140 |
141 | out.succeeded = not out.failed
142 |
143 | p.close()
144 | return out
145 |
146 | def get(remote_path, local_path, hostname, username, password=None, pkey=None, pkey_type="rsa", port=22):
147 | return sftp(remote_path, local_path, hostname, username, password=password, pkey=pkey, pkey_type=pkey_type,
148 | port=port, transfer_type="get")
149 |
150 | def put(local_path, remote_path, hostname, username, password=None, pkey=None, pkey_type="rsa", port=22):
151 | return sftp(local_path, remote_path, hostname, username, password=password, pkey=pkey, pkey_type=pkey_type,
152 | port=port, transfer_type="put")
153 |
--------------------------------------------------------------------------------
/app/views.py:
--------------------------------------------------------------------------------
1 | from flask import render_template, flash, redirect, session, url_for, request, g
2 | from flask.ext.login import login_user, logout_user, current_user, login_required
3 | from app import app, db, lm
4 | from app.models import User
5 |
6 |
7 | @lm.user_loader
8 | def load_user(uid):
9 | return User.query.get(int(uid))
10 |
11 |
12 | @app.before_request
13 | def before_request():
14 | g.user = current_user
15 |
16 |
17 | @app.route('/')
18 | @app.route('/index')
19 | @login_required
20 | def index():
21 | posts = [{ 'author': { 'nickname': 'Dong' },
22 | 'body': 'Bootstrap is beautiful, and Flask is cool!' }]
23 | return render_template('index.html',posts=posts)
24 |
25 |
26 | @app.route('/status')
27 | @login_required
28 | def status():
29 | from app.utils.operations import local
30 | from decimal import Decimal
31 |
32 | os_fqdn = local('hostname --fqdn')
33 |
34 | os_release = local('cat /etc/*-release |head -n 1 |cut -d= -f2 |sed s/\\"//g')
35 |
36 | mem_kb = local("""grep -w "MemTotal" /proc/meminfo |awk '{print $2}'""")
37 | mem_mb = Decimal(mem_kb) / 1024
38 | os_memory = round(mem_mb,2)
39 |
40 | cpu_type = local("""grep 'model name' /proc/cpuinfo |uniq |awk -F : '{print $2}' |sed 's/^[ \t]*//g' |sed 's/ \+/ /g'""")
41 | cpu_cores = local("""grep 'processor' /proc/cpuinfo |sort |uniq |wc -l""")
42 |
43 | nics = local("""/sbin/ifconfig |grep "Link encap" |awk '{print $1}' |grep -wv 'lo' |xargs""")
44 | nics_list = nics.split()
45 | t_nic_info = ""
46 | for i in nics_list:
47 | ipaddr = local("""/sbin/ifconfig %s |grep -w "inet addr" |cut -d: -f2 | awk '{print $1}'""" % (i))
48 | if ipaddr:
49 | t_nic_info = t_nic_info + i + ":" + ipaddr + ", "
50 |
51 | disk_usage = local("""df -hP |grep -Ev 'Filesystem|tmpfs' |awk '{print $3"/"$2" "$5" "$6", "}' |xargs""")
52 |
53 | top_info = local('top -b1 -n1 |head -n 5')
54 | top_info_list = top_info.split('\n')
55 |
56 | return render_template('status.html',
57 | os_fqdn=os_fqdn,
58 | os_release=os_release,
59 | os_memory=os_memory,
60 | cpu_type=cpu_type,
61 | cpu_cores=cpu_cores,
62 | os_network=t_nic_info,
63 | disk_usage=disk_usage,
64 | top_info_list=top_info_list)
65 |
66 |
67 | @app.route('/operations', methods=['GET', 'POST'])
68 | @login_required
69 | def operations():
70 | import paramiko
71 | from app.utils.operations import remote
72 | from config import basedir
73 | from app.forms import OperationsForm
74 |
75 | def isup(hostname):
76 | import socket
77 |
78 | conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
79 | conn.settimeout(2)
80 | try:
81 | conn.connect((hostname,22))
82 | conn.close()
83 | except:
84 | return False
85 | return True
86 |
87 | form = OperationsForm()
88 | if form.validate_on_submit():
89 | username = 'dong'
90 | pkey = basedir + '/sshkeys/id_rsa'
91 |
92 | hostname = form.hostname.data
93 | cmd = form.cmd.data
94 |
95 | if not isup(hostname):
96 | return render_template('operations.html',form=form,failed_host=hostname)
97 |
98 | blacklist = ['reboot', 'shutdown', 'poweroff',
99 | 'rm', 'mv', '-delete', 'source', 'sudo',
100 | '<', '<<', '>>', '>']
101 | for item in blacklist:
102 | if item in cmd.split():
103 | return render_template('operations.html',form=form,blacklisted_word=item)
104 |
105 | try:
106 | out = remote(cmd,hostname=hostname,username=username,pkey=pkey)
107 | except paramiko.AuthenticationException:
108 | return render_template('operations.html',form=form,hostname=hostname,failed_auth=True)
109 |
110 | failed_cmd = out.failed
111 | succeeded_cmd = out.succeeded
112 |
113 | return render_template('operations.html',
114 | form=form,
115 | cmd=cmd,
116 | hostname=hostname,
117 | out=out,
118 | failed_cmd=failed_cmd,
119 | succeeded_cmd=succeeded_cmd)
120 |
121 | return render_template('operations.html',form=form)
122 |
123 |
124 | @app.route('/racktables', methods=['GET', 'POST'])
125 | @login_required
126 | def racktables():
127 | from app.utils.operations import local
128 | from config import basedir
129 | from app.forms import RacktablesForm
130 |
131 | form = RacktablesForm()
132 | if form.validate_on_submit():
133 | param_do = form.do_action.data
134 | objectname = form.objectname.data
135 | objecttype = form.objecttype.data
136 | param_s = form.rackspace.data
137 | param_p = form.rackposition.data
138 |
139 | script = basedir + "/scripts/racktables.py"
140 |
141 | if param_do == 'help':
142 | cmd = "{0} -h".format(script)
143 |
144 | if param_do == 'get':
145 | cmd = "{0}".format(script)
146 | if objectname:
147 | cmd = "{0} {1}".format(script,objectname)
148 |
149 | if param_do == 'list':
150 | cmd = "{0} {1} -l".format(script,objectname)
151 |
152 | if param_do == 'read':
153 | cmd = "{0} {1} -r".format(script,objectname)
154 | if objecttype == 'offline_mode':
155 | cmd = cmd + " -o"
156 | if objecttype == 'patch_panel':
157 | cmd = cmd + " -b"
158 | if objecttype == 'network_switch':
159 | cmd = cmd + " -n"
160 | if objecttype == 'network_security':
161 | cmd = cmd + " -f"
162 | if objecttype == 'pdu':
163 | cmd = cmd + " -u"
164 |
165 | if param_do == 'write':
166 | cmd = "{0} {1} -w".format(script,objectname)
167 | if param_s:
168 | cmd = cmd + " -s {0}".format(param_s)
169 | if param_p != 'none':
170 | cmd = cmd + " -p {0}".format(param_p)
171 | if objecttype == 'offline_mode':
172 | cmd = cmd + " -o"
173 | if objecttype == 'patch_panel':
174 | cmd = cmd + " -b"
175 | if objecttype == 'network_switch':
176 | cmd = cmd + " -n"
177 | if objecttype == 'network_security':
178 | cmd = cmd + " -f"
179 | if objecttype == 'pdu':
180 | cmd = cmd + " -u"
181 |
182 | if param_do == 'delete':
183 | cmd = "{0} {1} -d".format(script,objectname)
184 |
185 | out = local(cmd)
186 |
187 | failed_cmd = out.failed
188 | succeeded_cmd = out.succeeded
189 |
190 | return render_template('racktables.html',
191 | form=form,
192 | cmd=cmd,
193 | out=out,
194 | failed_cmd=failed_cmd,
195 | succeeded_cmd=succeeded_cmd)
196 |
197 | return render_template('racktables.html',form=form)
198 |
199 |
200 | @app.route('/hadoop', methods=['GET', 'POST'])
201 | @login_required
202 | def hadoop():
203 | import paramiko
204 | from app.utils.operations import remote
205 | from config import basedir
206 | from app.forms import HadoopForm
207 |
208 | def isup(hostname):
209 | import socket
210 |
211 | conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
212 | conn.settimeout(2)
213 | try:
214 | conn.connect((hostname,22))
215 | conn.close()
216 | except:
217 | return False
218 | return True
219 |
220 | form = HadoopForm()
221 | if form.validate_on_submit():
222 | username = 'dong'
223 | pkey = basedir + '/sshkeys/id_rsa'
224 |
225 | param_do = form.do_action.data
226 | slave_hostname = form.slave_hostname.data
227 | master_hostname = form.master_hostname.data
228 |
229 | if master_hostname == 'none':
230 | return render_template('hadoop.html',form=form,none_host=True)
231 |
232 | if master_hostname in ['idc1-hnn1', 'idc2-hnn1']:
233 | script = '/root/bin/excludedn'
234 |
235 | if master_hostname in ['idc1-hrm1', 'idc2-hrm1']:
236 | script = '/root/bin/excludeyn'
237 |
238 | if param_do == 'exclude':
239 | cmd = "sudo {0} {1}".format(script,slave_hostname)
240 |
241 | if param_do == 'recover':
242 | cmd = "sudo {0} -r {1}".format(script,slave_hostname)
243 |
244 | if not isup(master_hostname):
245 | return render_template('hadoop.html',form=form,failed_host=master_hostname)
246 |
247 | try:
248 | out = remote(cmd,hostname=master_hostname,username=username,pkey=pkey)
249 | except paramiko.AuthenticationException:
250 | return render_template('hadoop.html',form=form,master_hostname=master_hostname,failed_auth=True)
251 |
252 | failed_cmd = out.failed
253 | succeeded_cmd = out.succeeded
254 |
255 | return render_template('hadoop.html',
256 | form=form,
257 | cmd=cmd,
258 | master_hostname=master_hostname,
259 | out=out,
260 | failed_cmd=failed_cmd,
261 | succeeded_cmd=succeeded_cmd)
262 |
263 | return render_template('hadoop.html',form=form)
264 |
265 |
266 | @app.route('/editor', methods=['GET', 'POST'])
267 | @login_required
268 | def editor():
269 | import os
270 | import time
271 | from hashlib import md5
272 | from app.utils.operations import local
273 | from app.forms import EditorForm
274 |
275 | form = EditorForm()
276 | if form.validate_on_submit():
277 | param_do = form.do_action.data
278 | file_path = form.file_path.data
279 |
280 | if param_do == 'read':
281 | file_access = os.access(file_path, os.W_OK)
282 | if not file_access:
283 | return render_template('editor.html',
284 | form=form,
285 | file_path=file_path,
286 | file_access=file_access)
287 |
288 | with open(file_path, 'rb') as f:
289 | file_data = f.read()
290 | f.closed
291 | form.file_data.data=file_data
292 | return render_template('editor.html',
293 | form=form,
294 | file_path=file_path,
295 | file_access=file_access)
296 |
297 | if param_do == 'save':
298 | file_access = os.access(file_path, os.W_OK)
299 | if not file_access:
300 | return render_template('editor.html',
301 | form=form,
302 | file_path=file_path,
303 | file_access=file_access)
304 |
305 | file_md5sum = md5(open(file_path, 'rb').read()).hexdigest()
306 | form_md5sum = md5(form.file_data.data.replace('\r\n','\n')).hexdigest()
307 | if file_md5sum == form_md5sum:
308 | return render_template('editor.html',
309 | form=form,
310 | file_path=file_path,
311 | file_access=file_access,
312 | file_no_change=True)
313 |
314 |
315 | postfix = time.strftime("%Y%m%d%H%M%S")
316 | file_backup = file_path + "." + postfix
317 |
318 | backup_out = local("cp -p {0} {1}".format(file_path,file_backup))
319 | succeeded_backup = backup_out.succeeded
320 | failed_backup = backup_out.failed
321 |
322 | file = open(file_path, 'wb')
323 | file.write(form.file_data.data.replace('\r\n','\n'))
324 | file.close()
325 |
326 | return render_template('editor.html',
327 | form=form,
328 | file_path=file_path,
329 | file_access=file_access,
330 | postfix=postfix,
331 | backup_out=backup_out,
332 | failed_backup=failed_backup,
333 | succeeded_backup=succeeded_backup)
334 |
335 | return render_template('editor.html',form=form)
336 |
337 |
338 | @app.route('/signup', methods=['GET', 'POST'])
339 | def signup():
340 | from app.forms import SignupForm
341 |
342 | form = SignupForm()
343 | if form.validate_on_submit():
344 | user = User.query.filter_by(email=form.email.data.lower()).first()
345 | if user is not None:
346 | form.email.errors.append("The Email address is already taken.")
347 | return render_template('signup.html', form=form)
348 |
349 | newuser = User(form.firstname.data,form.lastname.data,form.email.data,form.password.data)
350 | db.session.add(newuser)
351 | db.session.commit()
352 |
353 | session['email'] = newuser.email
354 | return redirect(url_for('login'))
355 |
356 | return render_template('signup.html', form=form)
357 |
358 |
359 | @app.route('/login', methods=['GET', 'POST'])
360 | def login():
361 | if g.user is not None and g.user.is_authenticated():
362 | return redirect(url_for('index'))
363 |
364 | from app.forms import LoginForm
365 |
366 | form = LoginForm()
367 | if form.validate_on_submit():
368 | session['remember_me'] = form.remember_me.data
369 | user = User.query.filter_by(email=form.email.data.lower()).first()
370 | if user and user.check_password(form.password.data):
371 | session['email'] = form.email.data
372 | login_user(user,remember=session['remember_me'])
373 | return redirect(url_for('index'))
374 | else:
375 | return render_template('login.html',form=form,failed_auth=True)
376 |
377 | return render_template('login.html',form=form)
378 |
379 |
380 | @app.route('/logout')
381 | def logout():
382 | logout_user()
383 | return redirect(url_for('index'))
384 |
--------------------------------------------------------------------------------
/config.py:
--------------------------------------------------------------------------------
1 | import os
2 | basedir = os.path.abspath(os.path.dirname(__file__))
3 |
4 | CSRF_ENABLED = True
5 | SECRET_KEY = 'devopsdemo_secret_key'
6 |
7 | SQLALCHEMY_DATABASE_URI = 'mysql://demo_user:demo_pass@localhost/devopsdemo'
8 |
--------------------------------------------------------------------------------
/flask/requirements.txt:
--------------------------------------------------------------------------------
1 | flask
2 | flask-login
3 | flask-openid
4 | flask-mail
5 | flask-sqlalchemy
6 | flask-wtf
7 |
--------------------------------------------------------------------------------
/run.py:
--------------------------------------------------------------------------------
1 | #!flask/bin/python
2 |
3 | from app import app
4 | app.run(host='0.0.0.0', debug=True)
5 |
--------------------------------------------------------------------------------
/screenshots/editor.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/editor.png
--------------------------------------------------------------------------------
/screenshots/hadoop.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/hadoop.png
--------------------------------------------------------------------------------
/screenshots/index.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/index.png
--------------------------------------------------------------------------------
/screenshots/login.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/login.png
--------------------------------------------------------------------------------
/screenshots/operations.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/operations.png
--------------------------------------------------------------------------------
/screenshots/racktables.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/racktables.png
--------------------------------------------------------------------------------
/screenshots/signup.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/signup.png
--------------------------------------------------------------------------------
/screenshots/status.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mcsrainbow/devopsdemo/3e60246969c4d4f3b74d2ef4237e2b3963d48b04/screenshots/status.png
--------------------------------------------------------------------------------
/scripts/racktables.py:
--------------------------------------------------------------------------------
1 | #!/bin/env python
2 | #-*- coding:utf-8 -*-
3 |
4 | # Author: Dong Guo
5 | # Last Modified: 2015/04/30
6 |
7 | import os
8 | import sys
9 | from decimal import Decimal
10 | import requests
11 | from requests.auth import HTTPBasicAuth
12 |
13 | # import urllib to encode the data for POST
14 | from urllib import quote_plus
15 |
16 | # torndb is a lightweight wrapper around MySQLdb
17 | try:
18 | from torndb import Connection
19 | except ImportError:
20 | sys.stderr.write("ERROR: Requires torndb, try 'yum install MySQL-python' then 'pip install torndb'.\n")
21 | sys.exit(1)
22 |
23 | # racktables server address, database, username, password, headers, auth
24 | rt_server = "real_rt_server"
25 | rt_webuser = "real_rt_webuser"
26 | rt_webpass = "real_rt_webpass"
27 | rt_dbname = "real_rt_dbname"
28 | rt_dbuser = "real_rt_dbuser"
29 | rt_dbpass = "real_rt_dbpass"
30 |
31 | rt_headers = {'Content-Type': 'application/x-www-form-urlencoded'}
32 | rt_auth = HTTPBasicAuth(rt_webuser, rt_webpass)
33 |
34 | def parse_opts():
35 | """Help messages (-h, --help) for racktables.py"""
36 |
37 | import textwrap
38 | import argparse
39 |
40 | parser = argparse.ArgumentParser(
41 | formatter_class=argparse.RawDescriptionHelpFormatter,
42 | description=textwrap.dedent(
43 | '''
44 | examples:
45 | {0} idc1-server1
46 | {0} idc1-server1 -r
47 | {0} idc1-server1 -d
48 | {0} idc1-server1 -w
49 | {0} idc1-server1 -w -s IDC1:P1:C1:1
50 | {0} idc1-server2 -o -w -s IDC1:P1:C1:2
51 | {0} idc1-server2 -o -r
52 | {0} idc2-server1 -w -s IDC2:P2:C1:1,2
53 | {0} idc2-server2 -w -s IDC2:P1:C2:20 -p left
54 | {0} idc2-server3 -w -s IDC2:P1:C2:20 -p right
55 | {0} BlankIDC2P1C2U9 -b -w -s IDC2:P1:C2:9
56 | {0} BlankIDC2P1C2U9 -b -r
57 | {0} BlankIDC2P1C2U9 -d
58 | {0} IDC2:P1:C2 -l
59 | {0} idc2-switch1 -n -w -s IDC2:P3:C3:30
60 | {0} idc2-switch1 -n -r
61 | {0} idc2-switch1 -d
62 | {0} idc1-firewall1 -f -w -s IDC2:P3:C3:40
63 | {0} idc1-firewall1 -f -r
64 | {0} idc1-firewall1 -d
65 | {0} idc2-pdu1 -u -w -s IDC2:P3:C2:32
66 | {0} idc2-pdu1 -u -d
67 | '''.format(__file__)
68 | ))
69 | parser.add_argument('hostname', action="store", type=str)
70 | exclusion_1 = parser.add_mutually_exclusive_group()
71 | exclusion_1.add_argument('-r', action="store_true", default=False,help='read from database')
72 | exclusion_1.add_argument('-d', action="store_true", default=False,help='delete from database')
73 | exclusion_1.add_argument('-w', action="store_true", default=False,help='write to database')
74 | exclusion_1.add_argument('-l', action="store_true", default=False,help='list hosts and devices of the rackspace')
75 | exclusion_2 = parser.add_mutually_exclusive_group()
76 | exclusion_2.add_argument('-o', action="store_true", default=False,help='offline mode for Type as Server')
77 | exclusion_2.add_argument('-b', action="store_true", default=False,help='set Type as PatchPanel')
78 | exclusion_2.add_argument('-n', action="store_true", default=False,help='set Type as NetworkSwitch')
79 | exclusion_2.add_argument('-f', action="store_true", default=False,help='set Type as NetworkSecurity')
80 | exclusion_2.add_argument('-u', action="store_true", default=False,help='set Type as PDU')
81 | parser.add_argument('-s', metavar='rackspace', type=str, help='rackspace informations')
82 | parser.add_argument('-p', metavar='rackposition', type=str, choices=['left','right','front','interior','back'], help='rackspace detailed position')
83 |
84 | args = parser.parse_args()
85 | return {'hostname':args.hostname, 'read':args.r, 'delete':args.d,
86 | 'offline':args.o, 'blank':args.b, 'switch':args.n, 'security':args.f, 'pdu':args.u,
87 | 'write':args.w, 'rackspace':args.s, 'rackposition':args.p, 'list':args.l }
88 |
89 | class _AttributeString(str):
90 | """
91 | Simple string subclass to allow arbitrary attribute access.
92 | """
93 | @property
94 | def stdout(self):
95 | return str(self)
96 |
97 | def remote(cmd, hostname, username, password=None, pkey=None, pkey_type="rsa", port=22):
98 | import warnings
99 | with warnings.catch_warnings():
100 | warnings.simplefilter("ignore")
101 | import paramiko
102 |
103 | p = paramiko.SSHClient()
104 | p.set_missing_host_key_policy(paramiko.AutoAddPolicy())
105 |
106 | if pkey is not None:
107 | if pkey_type == "dsa":
108 | pkey = paramiko.DSSKey.from_private_key_file(pkey)
109 | else:
110 | pkey = paramiko.RSAKey.from_private_key_file(pkey)
111 | p.connect(hostname=hostname, username=username, pkey=pkey, port=port)
112 | else:
113 | p.connect(hostname=hostname, username=username, password=password, port=port)
114 |
115 | (stdin, stdout, stderr) = p.exec_command(cmd)
116 |
117 | stdout_str=""
118 | stderr_str=""
119 | for line in stdout.readlines():
120 | stdout_str = stdout_str + line
121 | for line in stderr.readlines():
122 | stderr_str = stderr_str + line
123 |
124 | out = _AttributeString(stdout_str.strip() if stdout else "")
125 | err = _AttributeString(stderr_str.strip() if stderr else "")
126 |
127 | out.cmd = cmd
128 | out.failed = False
129 | out.return_code = stdout.channel.recv_exit_status()
130 | out.stderr = err
131 | if out.return_code != 0:
132 | out.failed = True
133 | out.succeeded = not out.failed
134 |
135 | p.close()
136 | return out
137 |
138 | def run(cmd,hostname=False):
139 | if not hostname:
140 | hostname = opts['hostname']
141 |
142 | username = "root"
143 | pkey = "/root/.ssh/id_dsa"
144 | pkey_type = 'dsa'
145 |
146 | out = remote(cmd, hostname=hostname, username=username, pkey=pkey, pkey_type=pkey_type)
147 |
148 | return out
149 |
150 | def sudo(cmd,hostname=False):
151 | cmd_sudo = 'sudo ' + cmd
152 |
153 | if not hostname:
154 | out = run(cmd_sudo)
155 | else:
156 | out = run(cmd_sudo,hostname)
157 |
158 | return out
159 |
160 | def isup(host):
161 | """Check if host is up"""
162 |
163 | import socket
164 |
165 | conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
166 | conn.settimeout(3)
167 | try:
168 | conn.connect((host,22))
169 | conn.close()
170 | except:
171 | print "Failed to connect to host {0} port 22: Network is unreachable".format(host)
172 | return False
173 | return True
174 |
175 | class GetServerInfo(object):
176 | """Remotely get informations"""
177 |
178 | def __init__(self):
179 | pass
180 |
181 | def get_server_type(self):
182 | xapi_sign = run('rpm -q --quiet xapi-xe')
183 | if xapi_sign.succeeded:
184 | return "XenServer"
185 |
186 | ec2_sign = run("""curl http://169.254.169.254/latest/meta-data/hostname --connect-timeout 1 |egrep -wq 'ec2.internal|compute.internal'""")
187 | if ec2_sign.succeeded:
188 | return "EC2"
189 |
190 | xen_sign = run('ps -e | egrep -wq "xenbus|xenwatch"')
191 | if xen_sign.succeeded:
192 | return "VM"
193 |
194 | return "Server"
195 |
196 | def get_fqdn(self):
197 | hostname = run('hostname |cut -d. -f1')
198 | fqdn = run('hostname -f')
199 | if fqdn.failed:
200 | fqdn = hostname
201 | return fqdn
202 |
203 | def get_os_release(self):
204 | os_release = run('cat /etc/*-release |head -n 1 |cut -d= -f2 |sed s/\\"//g')
205 |
206 | os_mode = run('uname -m')
207 | return os_release + ", " + os_mode
208 |
209 | def get_memory(self):
210 | output = run("""grep -w "MemTotal" /proc/meminfo |awk '{print $2}'""")
211 | t_mem_g = Decimal(output) / 1024 / 1024
212 | return round(t_mem_g,2)
213 |
214 | def get_swap(self):
215 | output = run("""grep -w "SwapTotal" /proc/meminfo |awk '{print $2}'""")
216 | t_swap_g = Decimal(output) / 1024 /1024
217 | return round(t_swap_g,2)
218 |
219 | def get_cpu(self):
220 | cpu_type = run("""grep 'model name' /proc/cpuinfo |uniq |awk -F : '{print $2}' |sed 's/^[ \t]*//g' |sed 's/ \+/ /g'""")
221 | cpu_cores = run("""grep 'processor' /proc/cpuinfo |sort |uniq |wc -l""")
222 | return {'cpu_cores':cpu_cores, 'cpu_type':cpu_type}
223 |
224 | def get_disk(self):
225 | disk = sudo("""fdisk -l 2>/dev/null |grep -v "/dev/mapper" |grep "Disk /dev" |awk '{print $2" "$3" "$4}'|grep -Ev '^$|^doesn' |sort |xargs""")
226 | return disk
227 |
228 | def get_network(self):
229 | output = run("""/sbin/ifconfig |grep "Link encap" |awk '{print $1}' |grep -wv 'lo' |xargs""")
230 | nics = output.split()
231 | t_nic_info = ""
232 | for i in nics:
233 | ipaddr = run("""/sbin/ifconfig %s |grep -w "inet addr" |cut -d: -f2 | awk '{print $1}'""" % (i))
234 | if ipaddr:
235 | t_nic_info = t_nic_info + i + ":" + ipaddr + ", "
236 | return t_nic_info
237 |
238 | def get_vm_list(self):
239 | output = sudo("""xl list-vm |awk '{print $3}' |grep -vw name |sort -n |xargs""")
240 | vm_list = ','.join(output.split())
241 | return vm_list
242 |
243 | def get_rst_on(self):
244 | colo_prefix = run("""hostname -s |egrep 'sc2-|iad2-' |cut -d- -f1""")
245 | xs_pool_master = colo_prefix + '-vm1001'
246 |
247 | if not isup(xs_pool_master):
248 | return False
249 |
250 | vm_uuid = sudo("""xe vm-list |grep -B1 -w %s |awk '{if ($1 == "uuid") print $NF}'""" % (opts['hostname']),hostname=xs_pool_master)
251 | rst_uuid = sudo("""xe vm-param-get uuid={0} param-name=resident-on""".format(vm_uuid),hostname=xs_pool_master)
252 | rst_name = sudo("""xe vm-list params |egrep 'name-label|resident-on' |grep -B1 %s |grep -w "Control domain" |awk -F ": " '{print $NF}' |cut -d. -f1""" % (rst_uuid),hostname=xs_pool_master)
253 | return rst_name
254 |
255 | def get_xs_memory(self):
256 | t_mem_m = sudo('xl info |grep total_memory |cut -d : -f 2')
257 | t_mem_g = int(t_mem_m) / 1024
258 | return t_mem_g
259 |
260 | def get_xs_cpu(self):
261 | cpu_cores = sudo("""xe host-cpu-info |grep -w cpu_count |awk -F ': ' '{print $2}'""")
262 | cpu_type = run("""grep 'model name' /proc/cpuinfo |uniq |awk -F : '{print $2}' |sed 's/^[ \t]*//g' |sed 's/ \+/ /g'""")
263 | return {'cpu_cores':cpu_cores, 'cpu_type':cpu_type}
264 |
265 | def get_ec2_pubname(self):
266 | ec2_pubname = run("""curl http://169.254.169.254/latest/meta-data/public-hostname --connect-timeout 1""")
267 | return ec2_pubname
268 |
269 | def sum_info():
270 | """Get & Print all informations"""
271 |
272 | server_info = GetServerInfo()
273 |
274 | server_type = server_info.get_server_type()
275 | print "TYPE: " + server_type
276 |
277 | fqdn = server_info.get_fqdn()
278 | print "FQDN: " + fqdn
279 |
280 | os_release = server_info.get_os_release()
281 | print "OS: " + os_release
282 |
283 | if server_type == "XenServer":
284 | memory = server_info.get_xs_memory()
285 | else:
286 | memory = server_info.get_memory()
287 | print "MEMORY: " + str(memory) + " GB"
288 |
289 | swap = server_info.get_swap()
290 | print "SWAP: " + str(swap) + " GB"
291 |
292 | if server_type == "XenServer":
293 | cpu_info = server_info.get_xs_cpu()
294 | else:
295 | cpu_info = server_info.get_cpu()
296 | print "CPU: " + cpu_info['cpu_cores'] + " Cores, " + cpu_info['cpu_type']
297 |
298 | disk = server_info.get_disk()
299 | print "DISK: " + disk
300 |
301 | network = server_info.get_network()
302 | print "NETWORK: " + network
303 |
304 | vm_list = ""
305 | if server_type == "XenServer":
306 | vm_list = server_info.get_vm_list()
307 | print "VMLIST: " + vm_list
308 |
309 | xs_name = ""
310 | if server_type == "VM":
311 | xs_name = server_info.get_rst_on()
312 | print "RESIDENT-ON: " + xs_name
313 |
314 | ec2_pubname = ""
315 | if server_type == "EC2":
316 | ec2_pubname = server_info.get_ec2_pubname()
317 | print "PUBNAME: " + ec2_pubname
318 |
319 | return {'server_type':server_type, 'fqdn':fqdn, 'hostname':opts['hostname'],'os_release':os_release,
320 | 'memory':memory,'swap':swap, 'cpu_cores':cpu_info['cpu_cores'], 'cpu_type':cpu_info['cpu_type'],
321 | 'disk':disk,'network':network, 'vm_list':vm_list, 'resident_on':xs_name, 'ec2_pubname':ec2_pubname}
322 |
323 | def read_db(info):
324 | """Get info from Racktables DB"""
325 |
326 | # connect to racktables db
327 | db = Connection(rt_server,rt_dbname,rt_dbuser,rt_dbpass)
328 |
329 | # check if object_id already exists
330 | object_id = ""
331 | for item in db.query("select * from Object where name='{0}'".format(info['hostname'])):
332 | object_id = item.id
333 | if not object_id:
334 | print "Object:{0} does not exist".format(info['hostname'])
335 | return False
336 |
337 | # get the location info
338 | rack_id_list = []
339 | unit_no_list = []
340 | for item in db.query("select rack_id,unit_no from RackSpace where object_id=(select id from Object where name='{0}')".format(info['hostname'])):
341 | rack_id_list.append(int(item.rack_id))
342 | unit_no_list.append(int(item.unit_no))
343 | if not item:
344 | print "Object:{0} does not have location info".format(info['hostname'])
345 | return False
346 | rack_id = ','.join(str(i) for i in list(set(rack_id_list)))
347 | unit_no = ','.join(str(i) for i in list(set(unit_no_list)))
348 |
349 | location_name = ""
350 | row_name = ""
351 | rack_name = ""
352 | for item in db.query("select location_name,row_name,name from Rack where id='{0}'".format(rack_id)):
353 | location_name = item.location_name
354 | row_name = item.row_name
355 | rack_name = item.name
356 | if not location_name or not row_name or not rack_name:
357 | print "Object:{0} does not have location info".format(info['hostname'])
358 | return False
359 | print "RACKSPACE: {0}:{1}:{2}:{3}".format(location_name,row_name,rack_name,unit_no)
360 |
361 | # close db
362 | db.close()
363 |
364 | return {'location_name':location_name, 'row_name':row_name, 'rack_name':rack_name, 'unit_no':unit_no}
365 |
366 | def update_db(info):
367 | """Automate server audit into Racktables"""
368 |
369 | # connect to racktables db
370 | db = Connection(rt_server,rt_dbname,rt_dbuser,rt_dbpass)
371 |
372 | # get object_type_id
373 | for item in db.query("select * from Dictionary where dict_value='{0}'".format(info['server_type'])):
374 | object_type_id = item.dict_key
375 |
376 | # delete object if already exists
377 | delete_object(info)
378 |
379 | # create object
380 | url = """http://{0}/racktables/index.php?module=redirect&page=depot&tab=addmore&op=addObjects""".format(rt_server)
381 | if info['server_type'] in ["Server","XenServer"]:
382 | payload = """0_object_type_id={0}&0_object_name={1}&0_object_label=&0_object_asset_no={1}&got_fast_data=Go%21"""\
383 | .format(object_type_id,info['hostname'])
384 | if info['server_type'] in ["VM","EC2"]:
385 | payload = """virtual_objects=&0_object_type_id={0}&0_object_name={1}&got_fast_data=Go%21"""\
386 | .format(object_type_id,info['hostname'])
387 |
388 | req = requests.post(url, data=payload, headers=rt_headers, auth=rt_auth)
389 | if req.status_code != requests.codes.ok:
390 | print "Failed to create object: {0}".format(info['hostname'])
391 | return False
392 | else:
393 | print "OK - Created object: {0}".format(info['hostname'])
394 |
395 | object_id = ""
396 | # get object_id
397 | for item in db.query("select * from Object where name='{0}'".format(info['hostname'])):
398 | object_id = item.id
399 | if not object_id:
400 | print "Failed to get object_id"
401 | return False
402 |
403 | # get os_release_id
404 | os_release_key = ""
405 | for item in db.query("select * from Dictionary where dict_value='{0}'".format(info['os_release'])):
406 | os_release_key = item.dict_key
407 | if not os_release_key:
408 | print "Failed to get object_type_id, please add '{0}' to 'Configuration - Dictionary - Server OS type'.".format(info['os_release'])
409 | return False
410 |
411 | # update the informations of object, all post data formats were got by firebug on firefox
412 | url = """http://{0}/racktables/index.php?module=redirect&page=object&tab=edit&op=update""".format(rt_server)
413 | if info['server_type'] == "Server":
414 | payload = """object_id={0}&object_type_id={1}&object_name={2}&object_label=&object_asset_no={2}&0_attr_id=14&0_value=&1_attr_id=10000&1_value={3}\
415 | &2_attr_id=10004&2_value={4}&3_attr_id=3&3_value={5}&4_attr_id=2&4_value=0&5_attr_id=26&5_value=0&6_attr_id=10006&6_value={6}\
416 | &7_attr_id=10003&7_value={7}&8_attr_id=1&8_value=&9_attr_id=28&9_value=&10_attr_id=21&10_value=&11_attr_id=4&11_value={8}\
417 | &12_attr_id=24&12_value=&13_attr_id=10005&13_value={9}&14_attr_id=25&14_value=&num_attrs=15&object_comment=&submit.x=15&submit.y=13"""\
418 | .format(object_id,object_type_id,info['hostname'],info['cpu_cores'],quote_plus(info['disk']),info['fqdn'],
419 | info['memory'],quote_plus(info['network']),os_release_key,info['swap'])
420 | if info['server_type'] == "XenServer":
421 | payload = """object_id={0}&object_type_id={1}&object_name={2}&object_label=&object_asset_no={2}&0_attr_id=14&0_value=&1_attr_id=10000&1_value={3}\
422 | &2_attr_id=10004&2_value={4}&3_attr_id=3&3_value={5}&4_attr_id=26&4_value=0&5_attr_id=10006&5_value={6}&6_attr_id=10003&6_value={7}\
423 | &7_attr_id=1&7_value=&8_attr_id=28&8_value=&9_attr_id=4&9_value={8}&10_attr_id=24&10_value=&11_attr_id=10005&11_value={9}\
424 | &12_attr_id=25&12_value=&13_attr_id=10008&13_value={10}&num_attrs=14&object_comment=&submit.x=18&submit.y=21"""\
425 | .format(object_id,object_type_id,info['hostname'],info['cpu_cores'],quote_plus(info['disk']),info['fqdn'],
426 | info['memory'],quote_plus(info['network']),os_release_key,info['swap'],quote_plus(info['vm_list']))
427 | if info['server_type'] == "EC2":
428 | payload = """object_id={0}&object_type_id={1}&object_name={2}&object_label=&object_asset_no=&0_attr_id=14&0_value=&1_attr_id=10000&1_value={3}\
429 | &2_attr_id=10004&2_value={4}&3_attr_id=3&3_value={5}&4_attr_id=26&4_value=0&5_attr_id=10006&5_value={6}&6_attr_id=10003&6_value={7}\
430 | &7_attr_id=10010&7_value={8}&8_attr_id=4&8_value={9}&9_attr_id=24&9_value=&10_attr_id=10005&10_value={10}&num_attrs=11&object_comment=&submit.x=19&submit.y=27"""\
431 | .format(object_id,object_type_id,info['hostname'],info['cpu_cores'],quote_plus(info['disk']),info['fqdn'],
432 | info['memory'],quote_plus(info['network']),info['ec2_pubname'],os_release_key,info['swap'])
433 | if info['server_type'] == "VM":
434 | payload = """object_id={0}&object_type_id={1}&object_name={2}&object_label=&object_asset_no=&0_attr_id=14&0_value=&1_attr_id=10000&1_value={3}\
435 | &2_attr_id=10004&2_value={4}&3_attr_id=3&3_value={5}&4_attr_id=26&4_value=0&5_attr_id=10006&5_value={6}&6_attr_id=10003&6_value={7}\
436 | &7_attr_id=10007&7_value={8}&8_attr_id=4&8_value={9}&9_attr_id=24&9_value=&10_attr_id=10005&10_value={10}&num_attrs=11&object_comment=&submit.x=25&submit.y=14'"""\
437 | .format(object_id,object_type_id,info['hostname'],info['cpu_cores'],quote_plus(info['disk']),info['fqdn'],
438 | info['memory'],quote_plus(info['network']),info['resident_on'],os_release_key,info['swap'])
439 |
440 | req = requests.post(url, data=payload, headers=rt_headers, auth=rt_auth)
441 | if req.status_code != requests.codes.ok:
442 | print "Failed to update attributes"
443 | return False
444 | print "OK - Updated attributes"
445 |
446 | # ec2 servers don't need to update the ip pool
447 | if info['server_type'] not in ["EC2"]:
448 | # update the ip pool
449 | nics = ("".join(info['network'].split())).split(',')
450 | for i in nics:
451 | nic_info = i.split(':')
452 | nic_name = "".join(nic_info[0:1])
453 | nic_addr = "".join(nic_info[1:2])
454 | # check if nic_name is not correct
455 | if nic_name.isalnum():
456 | # create nic
457 | url = """http://{0}/racktables/index.php?module=redirect&page=object&tab=ip&op=add""".format(rt_server)
458 | payload = """object_id={0}&bond_name={1}&ip={2}&bond_type=regular&submit.x=11&submit.y=6"""\
459 | .format(object_id,nic_name,nic_addr)
460 | req = requests.post(url, data=payload, headers=rt_headers, auth=rt_auth)
461 | if req.status_code != requests.codes.ok:
462 | print "Failed to update ip pool for {0}:{1}".format(nic_name,nic_addr)
463 | return False
464 | print "OK - Updated ip pool for {0}:{1}".format(nic_name,nic_addr)
465 |
466 | # virtual servers don't need to update the rackspace
467 | if info['server_type'] not in ["EC2","VM"]:
468 | # update rack info
469 | update_rack(info,object_id)
470 |
471 | # close db
472 | db.close()
473 |
474 | # end
475 | return True
476 |
477 | def update_blank_switch_security_pdu_offline(info):
478 | """Automate server autodir for PatchPanel/NetworkSwitch/NetworkSecurity/PDU into Racktables or as offline mode"""
479 |
480 | # connect to racktables db
481 | db = Connection(rt_server,rt_dbname,rt_dbuser,rt_dbpass)
482 |
483 | # delete object if already exists
484 | delete_object(info)
485 |
486 | # create object
487 | url = """http://{0}/racktables/index.php?module=redirect&page=depot&tab=addmore&op=addObjects""".format(rt_server)
488 | if opts['blank']:
489 | payload = """0_object_type_id=9&0_object_name={0}&0_object_label=&0_object_asset_no={0}&got_fast_data=Go%21"""\
490 | .format(info['hostname'])
491 | if opts['switch']:
492 | payload = """0_object_type_id=8&0_object_name={0}&0_object_label=&0_object_asset_no={0}&got_fast_data=Go%21"""\
493 | .format(info['hostname'])
494 | if opts['security']:
495 | payload = """0_object_type_id=798&0_object_name={0}&0_object_label=&0_object_asset_no={0}&got_fast_data=Go%21"""\
496 | .format(info['hostname'])
497 | if opts['pdu']:
498 | payload = """0_object_type_id=2&0_object_name={0}&0_object_label=&0_object_asset_no={0}&got_fast_data=Go%21"""\
499 | .format(info['hostname'])
500 | if opts['offline']:
501 | payload = """0_object_type_id=4&0_object_name={0}&0_object_label=&0_object_asset_no={0}&got_fast_data=Go%21"""\
502 | .format(info['hostname'])
503 |
504 | req = requests.post(url, data=payload, headers=rt_headers, auth=rt_auth)
505 | if req.status_code != requests.codes.ok:
506 | print "Failed to create object: {0}".format(info['hostname'])
507 | return False
508 | else:
509 | print "OK - Created object: {0}".format(info['hostname'])
510 |
511 | # get object_id
512 | for item in db.query("select * from Object where name='{0}'".format(info['hostname'])):
513 | object_id = item.id
514 | if not object_id:
515 | print "Failed to get object_id"
516 | return False
517 |
518 | # update rack info
519 | update_rack(info,object_id)
520 |
521 | # close db
522 | db.close()
523 |
524 | # end
525 | return True
526 |
527 | def update_rack(info,object_id):
528 | """Automate server audit for rack info into Racktables"""
529 |
530 | # connect to racktables db
531 | db = Connection(rt_server,rt_dbname,rt_dbuser,rt_dbpass)
532 |
533 | # update the rackspace
534 | if opts['rackspace']:
535 | rs_info = opts['rackspace'].split(':')
536 | colo = "".join(rs_info[0:1])
537 | row = "".join(rs_info[1:2])
538 | rack = "".join(rs_info[2:3])
539 | atom = "".join(rs_info[3:4])
540 | if not atom:
541 | print "The rackspace is not correct"
542 | return False
543 |
544 | # get rack_id
545 | for item in db.query("select * from Rack where name = '{0}' and location_name = '{1}' and row_name = '{2}'".format(rack,colo,row)):
546 | rack_id = item.id
547 | if not rack_id:
548 | print "Failed to get rack_id"
549 | return False
550 |
551 | atom_list = atom.split(',')
552 | atom_data = []
553 | for i in atom_list:
554 | if opts['rackposition']:
555 | if opts['rackposition'] in ['left', 'front']:
556 | atom_data.append("&atom_{0}_{1}_0=on".format(rack_id,i))
557 | if opts['rackposition'] in ['right', 'back']:
558 | atom_data.append("&atom_{0}_{1}_2=on".format(rack_id,i))
559 | if opts['rackposition'] in ['interior']:
560 | atom_data.append("&atom_{0}_{1}_1=on".format(rack_id,i))
561 | else:
562 | atom_data.append("&atom_{0}_{1}_0=on&atom_{0}_{1}_1=on&atom_{0}_{1}_2=on".format(rack_id,i))
563 | atom_url = "".join(atom_data)
564 |
565 | url = """http://{0}/racktables/index.php?module=redirect&page=object&tab=rackspace&op=updateObjectAllocation""".format(rt_server)
566 | payload = """object_id={0}&rackmulti%5B%5D={1}&comment=&got_atoms=Save{2}"""\
567 | .format(object_id,rack_id,atom_url)
568 | req = requests.post(url, data=payload, headers=rt_headers, auth=rt_auth)
569 | if req.status_code != requests.codes.ok:
570 | print "Failed to update rackspace"
571 | return False
572 | print "OK - Updated rackspace"
573 |
574 | # close db
575 | db.close()
576 |
577 | # end
578 | return True
579 |
580 | def delete_object(info):
581 | """Delete object from DB"""
582 |
583 | # connect to racktables db
584 | db = Connection(rt_server,rt_dbname,rt_dbuser,rt_dbpass)
585 |
586 | # check if object_id already exists, then create object if not
587 | object_id = ""
588 | for item in db.query("select * from Object where name='{0}'".format(info['hostname'])):
589 | object_id = item.id
590 |
591 | # delete object if already exists
592 | if object_id:
593 | url = """http://{0}/racktables/index.php?module=redirect&op=deleteObject&page=depot&tab=addmore&object_id={1}"""\
594 | .format(rt_server,object_id)
595 | req = requests.get(url,auth=rt_auth)
596 | if req.status_code != requests.codes.ok:
597 | print "Failed to delete the existing object: {0}".format(info['hostname'])
598 | return False
599 | else:
600 | print "OK - Deleted the existing object: {0}".format(info['hostname'])
601 |
602 | # close db
603 | db.close()
604 |
605 | return True
606 |
607 | def list_object(info):
608 | """List the objects of the given rackspace"""
609 |
610 | # connect to racktables db
611 | db = Connection(rt_server,rt_dbname,rt_dbuser,rt_dbpass)
612 |
613 | # check if rackspace is correct
614 | rs_info = opts['hostname'].split(':')
615 | colo = "".join(rs_info[0:1])
616 | row = "".join(rs_info[1:2])
617 | rack = "".join(rs_info[2:3])
618 | if not rack:
619 | print "The rackspace is not correct"
620 | return False
621 |
622 | # get rack_id
623 | for item in db.query("select * from Rack where name = '{0}' and location_name = '{1}' and row_name = '{2}'".format(rack,colo,row)):
624 | rack_id = item.id
625 | if not rack_id:
626 | print "Failed to get rack_id"
627 | return False
628 |
629 | # get object_id
630 | object_id_list = []
631 | for item in db.query("select * from RackSpace where rack_id={0}".format(rack_id)):
632 | object_id_list.append(item.object_id)
633 | if len(object_id_list) == 0:
634 | print "Failed to get object_id"
635 | return False
636 |
637 | # get rid of the duplicated items then sort and read one by one
638 | for object_id in sorted(list(set(object_id_list))):
639 | for item in db.query("select * from Object where id={0}".format(object_id)):
640 | object_name = item.name
641 | object_type_id = item.objtype_id
642 | for item in db.query("select * from Dictionary where dict_key={0}".format(object_type_id)):
643 | object_type_name = item.dict_value
644 | print "{0}: {1}".format(object_type_name,object_name)
645 |
646 | # close db
647 | db.close()
648 |
649 | return True
650 |
651 | if __name__=='__main__':
652 | # show help messages if no parameter
653 | argv_len = len(sys.argv)
654 | if argv_len < 2:
655 | os.system(__file__ + " -h")
656 | sys.exit(1)
657 | opts = parse_opts()
658 |
659 | if not opts['list'] and not opts['delete'] and not opts['blank'] and not opts['switch'] and not opts['security'] \
660 | and not opts['pdu'] and not opts['offline']:
661 | # check if host is up
662 | hostup = isup(opts['hostname'])
663 |
664 | if hostup:
665 | # get info
666 | print "========================================"
667 | print "Getting informations from '{0}'...".format(opts['hostname'])
668 | print "========================================"
669 | info = sum_info()
670 |
671 | # update racktables
672 | if opts['write']:
673 | if info['server_type'] in ["Server","XenServer"]:
674 | print "========================================"
675 | print "Getting informations from DB..."
676 | print "========================================"
677 | read_db(info)
678 | print "========================================"
679 | print "Updating racktables..."
680 | print "========================================"
681 | update_db(info)
682 | else:
683 | info = {'hostname':opts['hostname']}
684 | else:
685 | info = {'hostname':opts['hostname']}
686 | if opts['blank'] or opts['switch'] or opts['security'] or opts['offline'] or opts['pdu']:
687 | if opts['write']:
688 | print "========================================"
689 | print "Updating racktables..."
690 | print "========================================"
691 | update_blank_switch_security_pdu_offline(info)
692 | if opts['list']:
693 | print "========================================"
694 | print "Getting objects in rackspace:'{0}'...".format(opts['hostname'])
695 | print "========================================"
696 | list_object(info)
697 |
698 | # read racktables
699 | if opts['read'] or opts['delete']:
700 | print "========================================"
701 | print "Getting informations from DB..."
702 | print "========================================"
703 | read_db(info)
704 |
705 | # delete object from db
706 | if opts['delete']:
707 | print "========================================"
708 | print "Deleting Object: '{0}' from DB...".format(opts['hostname'])
709 | print "========================================"
710 | delete_object(info)
711 |
--------------------------------------------------------------------------------
/scripts/requirements.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | function require_os(){
4 | sudo yum groupinstall "Development tools"
5 | sudo yum install zlib-devel bzip2-devel openssl-devel ncurses-devel
6 | sudo yum install python-setuptools python-devel
7 | }
8 |
9 | function require_virtualenv(){
10 | sudo yum install http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
11 | sudo yum install python-pip
12 | sudo easy_install virtualenv
13 | }
14 |
15 | function require_flask(){
16 | mkdir -p ~/devopsdemo
17 | cd ~/devopsdemo
18 | virtualenv flask
19 | . flask/bin/activate
20 | pip install -r flask/requirements.txt
21 | }
22 |
23 | function require_mysql(){
24 | cd ~/devopsdemo
25 | . flask/bin/activate
26 | sudo yum install http://www.percona.com/redir/downloads/percona-release/redhat/latest/percona-release-0.1-3.noarch.rpm
27 | sudo yum install Percona-Server-devel Percona-Server-shared-compat Percona-Server-client-55 Percona-Server-shared-55
28 | sudo yum install Percona-Server-server-55
29 | easy_install -U distribute
30 | pip install mysql-python torndb
31 | }
32 |
33 | function require_misc(){
34 | cd ~/devopsdemo
35 | . flask/bin/activate
36 | pip install argparse requests paramiko
37 | mkdir -p sshkeys tmp
38 | }
39 |
40 | case $1 in
41 | all)
42 | require_os
43 | require_virtualenv
44 | require_flask
45 | require_mysql
46 | require_misc
47 | ;;
48 | os)
49 | require_os
50 | ;;
51 | virtualenv)
52 | require_virtualenv
53 | ;;
54 | flask)
55 | require_flask
56 | ;;
57 | mysql)
58 | require_mysql
59 | ;;
60 | misc)
61 | require_misc
62 | ;;
63 | *)
64 | echo $"Usage: $0 {all|os|virtualenv|flask|mysql|misc}"
65 | exit 2
66 | esac
67 |
--------------------------------------------------------------------------------