python作业：HAproxy配置文件操作（第三周）

一.作业需求：

1. 根据用户输入输出对应的backend下的server信息

2. 可添加backend 和sever信息

3. 可修改backend 和sever信息

4. 可删除backend 和sever信息

5. 操作配置文件前进行备份

6 添加server信息时，如果ip已经存在则修改;如果backend不存在则创建；若信息与已有信息重复则不操作

配置文件参考 http://www.cnblogs.com/alex3714/articles/5717620.html

二.配置文件：

 1 global
 2         log 127.0.0.1 local2
 3         daemon
 4         maxconn 256
 5         log 127.0.0.1 local2 info
 6 defaults
 7         log global
 8         mode http
 9         timeout connect 5000ms
10         timeout client 50000ms
11         timeout server 50000ms
12         option  dontlognull
13 
14 listen stats :8888
15         stats enable
16         stats uri       /admin
17         stats auth      admin:1234
18 
19 frontend oldboy.org
20         bind 0.0.0.0:80
21         option httplog
22         option httpclose
23         option  forwardfor
24         log global
25         acl www hdr_reg(host) -i www.oldboy.org
26         use_backend www.oldboy.org if www
27 
28 backend www.oldboy.org
29         server 110.1.1.2 110.1.1.2 weight 20 maxconn 2000
30         server 110.1.1.1 110.1.1.1 weight 30 maxconn 3000
31 
32 backend www.12345.com.cn
33         server 100.1.7.8 100.1.7.8 weight 10 maxconn 1000
34 
35 backend www.baidu.com
36         server 100.0.0.1 100.0.0.1 weight 80 maxconn 1000

View Code

三.流程图：

四.代码：（python3.6 mac环境）

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 # Author: Even
  4 
  5 
  6 import os,sys
  7 
  8 
  9 def numif(number_input): # 判断输入是否为数字
 10     while not number_input.isdigit():    # 输入不是数字就进入循环
 11         number_input = input('\033[31m 输入%s不是数字，请重新输入!\033[0m' % number_input)    # 提示重新输入
 12     number = number_input
 13     return number
 14 
 15 
 16 def show_list(file):   # 查询显示并将文本生成程序需要的字典和列表
 17     backend_list = []
 18     backend_all_dict = {}
 19     backend_dict = {}
 20     server_list = []
 21     with open(file,'r') as f:    # 读取haproxy文件
 22         for line in f:
 23 
 24             line = line.strip()
 25             if line.startswith('backend') == True:    # 判断是否是backend开头，读取backend信息写到backend_list中
 26                 backend_name = line.split()[1]
 27                 backend_list.append(backend_name)    # 将文件中backend加到列表中
 28                 server_list = []   # 清空server_list里的记录，遇到新backend可以输入新的server_list
 29 
 30             elif line.startswith('server') == True:    # 判断是否是server开头，读取server信息写到backend_all_dict中
 31                 backend_dict['name'] = line.split()[1]    # 读取文件中server的name
 32                 backend_dict['IP'] = line.split()[2]    # 读取文件中server的IP
 33                 backend_dict['weight'] = line.split()[4]    # 读取文件中server的weight
 34                 backend_dict['maxconn'] = line.split()[6]   # 读取文件中server的maxconn
 35                 server_list.append(backend_dict.copy())    # 将backend中的信息加到server_list中,此处需要用copy
 36                 backend_all_dict[backend_name] = server_list    # 将server信息对应backend存到字典中
 37 
 38     return (backend_list,backend_all_dict)    # 返回backend和server信息
 39 
 40 
 41 def backend_show(backend_list):    # 展示backend列表内容
 42     backend_show_dict = {}
 43     print("-------------------------------------------------")
 44     print("\t\t\t欢迎来到HAproxy文件配置平台")
 45     print("-------------------------------------------------")
 46     print("backend列表信息如下：")
 47     for k,v in enumerate(backend_list,1):    # 逐行读取backend信息并展示
 48         print(k, v)
 49         backend_show_dict[str(k)] = v
 50     return backend_show_dict    # 返回backend和对应编号
 51 
 52 
 53 def server_show(backend_input,backend_all_dict):    # 展示backend下server内容
 54     server_show_dict = {}
 55     server_list = backend_all_dict[backend_input]
 56     for k,v in enumerate(server_list,1):    # 编号展示server信息
 57         print(k,"name:",v['name'],"\tIP:",v['IP'],"\tweight:",v['weight'],"\tmaxconn:",v['maxconn'])
 58         server_show_dict[k] = v
 59     return server_show_dict    # 返回编号对应的server字典
 60 
 61 
 62 def action_list():    # 显示操作列表和编号，并返回操作编号
 63     print("-------------------------------------------------")
 64     print("操作清单如下：")
 65     print('''
 66     1.查询backend和server信息
 67     2.添加backend和server信息
 68     3.修改backend和server信息
 69     4.删除backend和server信息
 70     5.退出
 71     ''')
 72     print("-------------------------------------------------")
 73     action_num = numif(input("请输入需要操作的编号：（请输入数字）"))
 74     return action_num
 75 
 76 
 77 def inquiry(inquiry_input):    # 定义查询功能
 78     while True:
 79         if inquiry_input in backend_show_dict:    # 编号输入分支
 80             backend_input = backend_show_dict[inquiry_input]    # 输入编号得到backend
 81             print(backend_input, ":")
 82             server_show(backend_input, backend_all_dict)    # 调用server_show，展示backend下server
 83             break
 84 
 85         elif inquiry_input in backend_show_dict.values():    # backend名称输入分支
 86             print(inquiry_input, ":")
 87             server_show(inquiry_input, backend_all_dict)    # 调用server_show，展示backend下server
 88             break
 89 
 90         else:    # 校验异常输入
 91             inquiry_input = input("输入错误，请重新输入：")
 92 
 93 
 94 def add(add_input,file):    # 定义添加功能
 95     (backend_list, backend_all_dict) = show_list(file)
 96     while True:
 97         if add_input in backend_show_dict:    #添加原有backend下server
 98             add_dict = {}
 99             add_dict['name'] = input("请输入需增加server名称：")
100             add_dict['IP'] = input("请输入需增加IP地址：")
101             add_dict['weight'] = input("请输入需增加weight值：")
102             add_dict['maxconn'] = input("请输入需增加maxcoon值：")
103             backend_name_add = backend_list[int(add_input)-1]
104 
105             for dict in backend_all_dict[backend_name_add]:    # 实现IP已存在，更新weight信息和maxconn信息
106                 if add_dict['IP'] in dict.values():
107                     dict['weight'] = add_dict['weight']
108                     dict['maxconn'] = add_dict['maxconn']
109                     break
110 
111                 else:    # IP不存在，就将server增加到backend下
112                     backend_all_dict[backend_name_add].append(add_dict)
113 
114             backup(file,backend_name_add,backend_all_dict)    # 调用backup函数，将新增内容读写到文件中
115             print('''name：%s IP：%s weight：%s maxconn：%s已添加成功'''%(
116             add_dict['name'],add_dict['IP'],add_dict['weight'],add_dict['maxconn']))    # 提示添加成功
117             break
118 
119         else:    # 添加新backend下的server
120             add_dict = {}
121             add_dict['name'] = input("请输入%s下新增server名称："%add_input)
122             add_dict['IP'] = input("请输入%s下新增IP地址："%add_input)
123             add_dict['weight'] = input("请输入%s下新增weight值："%add_input)
124             add_dict['maxconn'] = input("请输入%s下新增maxcoon值："%add_input)
125             backend_name_add = add_input
126             backend_all_dict[backend_name_add] = add_dict    # 将新增backend和对应server存到字典中
127 
128             file_new = "%s_new" % file    # 新建一个文件，用来新增数据
129             with open(file, 'r') as f_read, open(file_new, 'a+') as f_write:   # 读取file文件，追加backend信息
130                 for line in f_read:
131                     f_write.write(line)
132                 f_write.write("\nbackend %s" % backend_name_add)    # 追加backend信息
133                 server_line_write = '\n\t\tserver {name} {IP} weight {weight} maxconn {maxconn}\n'    # 追加server信息
134                 f_write.write(server_line_write.format(**add_dict))    # 格式化输出
135 
136             os.system('mv %s %s_backup' % (file, file))    # 将file文件名改为file_backup
137             os.system('mv %s %s' % (file_new, file))    # 将file_new文件名改为file，实现备份
138             print("\nbackend %s" % backend_name_add)
139             print('''name：%s IP：%s weight：%s maxconn：%s已添加成功''' % (
140             add_dict['name'], add_dict['IP'], add_dict['weight'], add_dict['maxconn']))    # 提示添加成功
141             break
142 
143 
144 def revise(revise_input):    # 定义修改功能
145     revise_dict = {}
146     if revise_input in backend_show_dict:    # 判断输入是否存在
147         backend_revise = backend_show_dict[revise_input]    # 通过编号获取backend
148         revise_choise = input("是否需要修改该backend名称：%s；确认请按'y'，按任意键继续："%backend_revise)    # 确认是否修改backend名，输入y修改，否则继续修改
149         if revise_choise == 'y':
150             backend_revise_new = input("请输入修改后的backend名：")    # 修改backend名
151             backend_all_dict[backend_revise_new] = backend_all_dict.pop(backend_revise)    # 将旧backend的server对应到修改后的backend上
152             revise_choise_server = input("是否需要继续修改%s下的server：确认请按'y'，按任意键继续："%backend_revise_new)    # 询问是否继续修改
153             if revise_choise_server == 'y':    # 继续修改server
154                 server_revise_dict = server_show(backend_revise_new, backend_all_dict)    # 展示server信息
155                 server_revise_num = numif(input("请输入需要修改的server编号："))   # 获取需要修改的server编号
156                 revise_dict['name'] = input("请输入修改后的name：")
157                 revise_dict['IP'] = input("请输入修改后的IP：")
158                 revise_dict['weight'] = input("请输入修改后的weight：")
159                 revise_dict['maxconn'] = input("请输入修改后的maxconn：")
160                 server_revise_dict[int(server_revise_num)] = revise_dict    # 通过编号修改server信息
161                 server_revise_dict_backup = {}
162                 server_revise_dict_backup[backend_revise_new] = server_revise_dict.values()    # 将修改的server信息对应到修改后的backend存到字典中
163                 backup(file, backend_revise, server_revise_dict_backup,backend_revise_new)    # 调用backup函数，操作文件
164 
165             else:    # 不修改server，只修改了backend
166                 backup(file, backend_revise, backend_all_dict,backend_revise_new)
167         else:    # 未修改backend名情况时修改server信息
168             server_revise_dict = server_show(backend_revise, backend_all_dict)
169             server_revise_num = numif(input("请输入需要修改的server编号："))    # 获取需修改的server编号
170             revise_dict['name'] = input("请输入修改后的name：")
171             revise_dict['IP'] = input("请输入修改后的IP：")
172             revise_dict['weight'] = input("请输入修改后的weight：")
173             revise_dict['maxconn'] = input("请输入修改后的maxconn：")
174             server_revise_dict[int(server_revise_num)] = revise_dict    # 修改的server信息对应到编号中存到字典中
175             server_revise_dict_backup = {}
176             server_revise_dict_backup[backend_revise] = server_revise_dict.values()    # 将修改后的server信息对应backend存到字典中
177             backup(file,backend_revise,server_revise_dict_backup)    # 调用backup函数，操作文件
178     else:    # 输入错误提示重新输入
179         revise_input_return = input("需修改backend不存在，请重新输入：")
180         revise(revise_input_return)
181 
182 
183 def delete(delete_input):    # 定义删除功能
184     if delete_input in backend_show_dict:
185         backend_delete = backend_show_dict[delete_input]
186         delete_choise = input("是否需要删除该backend：%s；确认请按'y'，按任意键继续："%backend_delete)
187         if delete_choise == 'y':    # 判断是否删除backend信息
188             del backend_all_dict[backend_delete]    # 在backend与server总字典中删除backend
189             backup(file, backend_delete, backend_all_dict)    # 调用backup函数，操作文件
190 
191         else:    # 删除server
192             server_delete_dict = server_show(backend_delete, backend_all_dict)
193             server_delete_num = int(numif(input("请输入需要删除的server编号：")))    # 除判断是否时数字外，还需转换为整数型
194             while True:    # 删除backend下的server循环
195                 if server_delete_num in server_delete_dict:    # 判断输入编号是否存在
196                     server_delete_dict.pop(server_delete_num)
197                     server_delete_dict_backup = {}
198                     server_delete_dict_backup[backend_delete] = server_delete_dict.values()
199                     backup(file, backend_delete, server_delete_dict_backup)    # 调用backup函数，操作文件
200                     break
201                 else:
202                     server_delete_num = input("输入编号不存在，请重新输入：")    # 提示输入错误
203 
204 
205 def backup(file,backend_name_action,backend_backup_dict,*backend_name_revise):    # 定义文档备份与回写功能
206     file_new = "%s_new"%file
207     add_flag = False    # 为跳过原backend下server存在
208     with open(file,'r') as f_read , open(file_new,'w+') as f_write:    # 同时打开读文件和写文件
209         for line in f_read:    # 读取每行信息
210             backend_name = "backend %s" % backend_name_action
211             backend_name_revise = "".join(tuple(backend_name_revise))    # 修改功能会传参，将元组转换为字符串
212             if line.strip() == backend_name:    # 读取某行中有参数中的backend
213                 if backend_name_action not in backend_backup_dict and backend_name_revise not in backend_backup_dict:  # 为了删除backend而存在
214                     add_flag = True
215                     pass
216 
217                 elif backend_name_revise in backend_backup_dict:    # 判断修改功能中修改后backend存在与字典中
218                     line_revise = "backend %s\n" % backend_name_revise
219                     f_write.write(line_revise)
220                     for add_dict in backend_backup_dict[backend_name_revise]:    # 逐行读取修改backend下的server信息
221                         server_line_write = '\t\tserver {name} {IP} weight {weight} maxconn {maxconn}\n'
222                         f_write.write(server_line_write.format(**add_dict))    # 格式化输出
223                     add_flag = True
224 
225                 else:
226                     f_write.write(line)    # 将此行写在文件中
227                     for add_dict in backend_backup_dict[backend_name_action]:    # 读取该backend下所有server信息
228                         server_line_write = '\t\tserver {name} {IP} weight {weight} maxconn {maxconn}\n'
229                         f_write.write(server_line_write.format(**add_dict))
230                     add_flag = True
231 
232             elif line.strip().startswith("server") == True and add_flag == True:  # 为了跳过原backend下的server
233                 pass
234 
235             else:    # 写无用行
236                 f_write.write(line)
237                 add_flag = False    # 写下无用行后可以继续循环
238 
239     os.system('mv %s %s_backup' % (file, file))
240     os.system('mv %s %s' % (file_new, file))
241 
242 
243 def backend_exit():    #定义退出功能
244     flag_exit = True
245     b_input = input("操作完毕退出请按'b'：")
246     while flag_exit:
247         if b_input == 'b':
248             flag_exit = False
249             return flag_exit
250 
251         else:
252             return backend_exit()   #使用尾递归优化，加上return帮助直接退出，而不需要递归一层层退出
253 
254 
255 flag = True    # 主函数开始
256 while flag:
257     flag_main = True
258     flag_action = True
259     file = 'haproxy'    # 文件名赋值
260     (backend_list, backend_all_dict) = show_list(file)    # 调用show_list函数获取backend和server信息
261     backend_show_dict = backend_show(backend_list)    # 展示backend信息
262     action_num = action_list()    # 展示功能项，并输入操作编号
263     while flag_main:
264         if action_num == '1':
265             inquiry(input("请输入需要查询的backend编号或名称："))
266             flag_main = backend_exit()
267             break
268 
269         if action_num == '2':
270             add(input("请输入需要添加的现有backend编号或新backend名称："), file)
271             flag_main = backend_exit()
272             break
273 
274         if action_num == '3':
275             revise(input("请输入需要修改的backend编号或名称："))
276             flag_main = backend_exit()
277             break
278 
279         if action_num == '4':
280             delete(input("请输入需要删除的backend编号或名称："))
281             flag_main = backend_exit()
282             break
283 
284         if action_num == '5':
285             sys.exit()
286 
287         elif action_num not in range(5):    # 当输入不在编号中，提示并重新输入
288             print("\033[31;1m输入错误请重新输入！\033[0m")
289             flag_main = False