def main():
### 0. 연결할 DB 설정
dt = data_util.DataUtil()
process_list = []
dao_ydns = dao.DAO(host='103.55.190.32',
port=3306,
user='******',
password='******',
db='crawl',
charset='utf8mb4')
### 1. 서버명을 정해준다.
server = 'jykim'
### 2. 서버에 해당하는 프록시 정하기
selected_proxy_rows = dao_ydns.select_sever_proxy(server=server)
### 3. 모든 프록시 개수 가져오기
total_proxy_rows = dao_ydns.select_total_proxy()
total_proxy_num = len(total_proxy_rows)
proxy_id_list = []
for proxy_row in selected_proxy_rows:
proxy_id_list.append(proxy_row['id'])
min_proxy_id = min(proxy_id_list)
max_proxy_id = max(proxy_id_list)
### 4. 프록시에 해당하는 프로세스를 만들어준다.
# 프록시는 자신의 고유 번호(id) 를 가진다. ex) 1,2,3,4
# 전체 프록시 길이로 task num 을 나누었을 때 나머지가 프로세스가 할당받은 아이디와 같은 task 만 처리한다
# ex) 전체길이가 12 이고 process 가 할당받은 id 가 5라면 이 process가 처리하는 작업은 5, 17, 29, 41
# 각각의 프로세스는 한번에 여러개의 task 를 처리할 수 있지만 프로세스 별로 task 가 중복될 수 없다.
# 가령 id가 5인 process 는 항상 id가 6인 process 와 처리하는 작업이 다르다.
for proxy_id in range(min_proxy_id, max_proxy_id + 1):
dt = data_util.DataUtil()
process = Process(
target=dt.divide_process,
args=(proxy_id, total_proxy_num),
) ##프로세스의 고유 id(proxy_id) 와 전체 길이를 넘겨준다.
process_list.append(process)
print("process시작")
for process in process_list:
process.start()
def main() :
tmp_proxy_list = []
##db 연결
dao_ydns = dao.DAO(host='103.55.190.32', port=3306, user='******', password='******', db='crawl',
charset='utf8mb4')
##1. 사용가능한 프록시 갯수 확인하기 , 어떤 서버에서 가져올지 parameter 로 넘겨주기
proxy_rows = dao_ydns.select_check_proxy(server='ydns')
##2. 사용가능한 프록시의 id를 list에 담아둔다.
for proxy in proxy_rows:
tmp_proxy_list.append(proxy)
##3. 요청 들어온 작업을 확인한다. 요청은 프록시 개수보다 작거나 같음.
task_rows = dao_ydns.select_gr(len(proxy_rows))
##4. 다시 요청의 개수만큼 프록시 사이즈를 맞춰준다.
proxy_list = tmp_proxy_list[:len(task_rows)]
####여기서 if 로 프록시 있으면 하고 없으면 하지말기로 체크하기
print('---------------')
if len(proxy_rows)>0:
##5. 사용하고 있는 프록시의 상태를 N 으로 변경해준다
for proxy in proxy_list:
id = proxy['id']
dao_ydns.update_N_proxy(id)
for task in task_rows:
id = task['id']
dao_ydns.update_gi(id)
dao_ydns.update_gather_start(id)
##6. input_data 만들기
input_data = []
##7. 요청된 테스크 가져오기
for task in task_rows:
dt = data_util.DataUtil()
task_list = dt.data_process(task)
input_data.append(task_list)
##8.proxy 형태 만들어주기
##make_proxy
# input : proxy_list
# return : req_proxy_list
dt = data_util.DataUtil()
req_proxy_list, proxy_id = dt.make_proxy(proxy_list)
##9. input_data 에 proxy 넣어주기
for index, task_list in enumerate(input_data):
task_list[0].append(req_proxy_list[index])
task_list[0].append(proxy_id[index])
task_list[1].append(req_proxy_list[index])
task_list[1].append(proxy_id[index])
for i in input_data:
print(i)
##10. input 데이터를 이용해서 threading 하기
# def multiprocessing
num_process = len(proxy_list) * 2
return num_process, input_data
pass
elif len(row_gr) == 0:
print('요청작업이 없습니다')
#작업중인게 없고 요청들어온게 있으면
elif len(row_gr) > 0:
try:
print('요청된 작업을 처리합니다.')
##작업을 시작합니다.
task = row_gr[0]
##작업 상태를 업데이트 시켜주기
dao_ydns.update_gi(task['id'])
dao_ydns.update_gather_start(task['id'])
#task : dictionary 타입 keyword:'', channel: '', perioda=['',''] etc
#task 를 처리하기 위해 data util 객체를 생성합니다.
dt = data_util.DataUtil(task)
#task 를 thread 처리 하기 위해 input_data 로 만들어줍니다.
input_data = dt.data_process()
#dt.to_crawl 입력받은 데이터를 크롤링 엔진으로 전달
#threading 생성
threads = [None] * len(input_data)
results = [None] * len(input_data)
#모든 스레드를 각각 시작한다.
for index, input_list in enumerate(input_data):
threads[index] = Thread(target=dt.to_crawl,
args=(input_list, results, index))
threads[index].start()
##10. input 데이터를 이용해서 threading 하기
# def multiprocessing
num_process = len(proxy_list) * 2
return num_process, input_data
if __name__ == '__main__':
##main 함수 시작
num_process, input_data = main()
##멀티프로세싱 크롤링 시작
freeze_support()
processes = [None] * num_process
manager = multiprocessing.Manager()
results = manager.list(range(num_process))
dt = data_util.DataUtil()
# 모든 스레드를 각각 시작한다.
for index, task_list in enumerate(input_data):
for jindex, input_list in enumerate(task_list):
print(input_list)
processes[2 * index + jindex] = Process(target=dt.to_crawl,
args=(input_list, results, 2 * index + jindex))
processes[2 * index + jindex].start()
for i in range(len(processes)):
processes[i].join()
# 쓰레드 결과 값(TASK ID ) 워드클라우드 생성을 위해 전달
for index, task_list in enumerate(input_data):
for jindex, input_list in enumerate(task_list):
input_list.append(results[2 * index + jindex])
if __name__ == '__main__':
conn = pymysql.connect(host='103.55.190.32',
user='******',
password='******',
db='crawl',
charset='utf8mb4')
curs = conn.cursor(pymysql.cursors.DictCursor)
sql = "select * from polls_breakdown where status=\'%s\' limit 5" % ('GR')
curs.execute(sql)
rows = curs.fetchall()
input_data = []
###요청된 테스크 가져오기
for row_gr in rows:
dt = data_util.DataUtil(row_gr)
task_list = dt.data_process()
input_data.append(task_list)
###api 이용해서 사용가능한 개인 IP 가져오기(proxy 우회)
input_data = make_proxy(input_data)
Processes = [None] * len(rows) * 2
manager = multiprocessing.Manager()
results = manager.list(range(len(rows) * 2))
#모든 스레드를 각각 시작한다.
for index, task_list in enumerate(input_data):
for jindex, input_list in enumerate(task_list):
print(input_list)
Processes[2 * index + jindex] = Process(target=to_crawl,