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
from crawler import dao
import requests
import re
import wc2_run_process
url = "http://checkip.dyndns.org"
response = requests.get(url)
server_name = response.text
server_name = re.findall(r'[0-9]+(?:\.[0-9]+){3}',server_name)
server_name = server_name[0]
###각 서버의 IP 주소 가져오기
###IP 주소로 DB 에서 해당 서버 가져오기
dao_ydns = dao.DAO()
server = dao_ydns.check_process(server_name)
###서버가 현재 프로세스 진행중이라면
if server['status']=="OUT":
dao_ydns.update_process_IN(server_name)
wc2_run_process.main()
# dao_ydns.update_process_OUT(server_name)
def divide_process(self, proxy_id, total_proxy_num):
PROXY_ID = proxy_id
TOTAL_PROXY_NUM = total_proxy_num
while True:
##mod : task 번호를 프록시 번호로 나누었을 때 나머지
mod = PROXY_ID if PROXY_ID < TOTAL_PROXY_NUM else 0
##db 연결
dao_ydns = dao.DAO(host='103.55.190.32',
port=3306,
user='******',
password='******',
db='crawl',
charset='utf8mb4')
##1. proxy_id 로 해당하는 proxy 가져오기
proxy_rows = dao_ydns.select_proxy(PROXY_ID)
##2. 해당 프록시를 list에 담아둔다.
proxy_list = []
for proxy in proxy_rows:
proxy_list.append(proxy)
##3. 요청 들어온 작업을 확인한다. 전체 프록시 개수로 나누었을 때 나머지가 proxy_id 와 같은 요청을 모두 가져옴(전체개수 ==proxy_id 일 때 제외) .
real_task_rows = []
task_rows = dao_ydns.select_gr()
for row in task_rows:
if row['id'] % TOTAL_PROXY_NUM == mod:
real_task_rows.append(row)
####해당 proxy 가 처리해야할 task 가 있는 경우
if len(real_task_rows) > 0:
real_task_rows = real_task_rows[:1]
### 해당 task 의 id 를 진행중으로 바꿔준다.
for task in real_task_rows:
id = task['id']
dao_ydns.update_gi(id)
input_data = []
##7. 요청된 테스크 가져오기
for task in real_task_rows:
try:
task_list = self.data_process(task)
input_data.append(task_list)
except:
dao_ydns.update_er(task['id'])
continue\
##8.proxy 형태 만들어주기
##make_proxy
# input : proxy_list
# return : req_proxy_list
req_proxy_list, proxy_id = self.make_proxy(proxy_list)
for id in proxy_id:
dao_ydns.update_N_proxy(id)
##9. input_data 에 proxy 넣어주기
for index, task_list in enumerate(input_data):
task_list[0].append(req_proxy_list[0])
task_list[0].append(proxy_id[0])
task_list[1].append(req_proxy_list[0])
task_list[1].append(proxy_id[0])
for i in input_data:
print(i)
##10. 쓰레드 돌리기
threads = [None] * len(input_data) * 2
results = [None] * len(input_data) * 2
for index, task_list in enumerate(input_data):
for jindex, input_list in enumerate(task_list):
print(input_list)
threads[2 * index + jindex] = Thread(
target=self.to_crawl,
args=(input_list, results, 2 * index + jindex,
req_proxy_list[0]))
threads[2 * index + jindex].start()
for i in range(len(threads)):
threads[i].join()
##crawling end
# proxy status : N -> P
for id in proxy_id:
dao_ydns.update_P_proxy(id)
# 쓰레드 결과 값(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])
# 워드클라우드 생성
for task_list in input_data:
self.to_venndiagram_wordcloud(task_list)
else:
print('해야할작업이 없습니다. 1분간 쉽니다', '현재시각:', datetime.now())
time.sleep(60)
def to_venndiagram_wordcloud(self, task):
dao_ydns = dao.DAO(host='103.55.190.32',
port=3306,
user='******',
password='******',
db='crawl',
charset='utf8mb4')
task_a = task[0]
task_b = task[1]
##task A 에 관한 작업 수행
keyword_a = task_a[0]
channel_a = task_a[1]
startdate_a = task_a[2]
enddate_a = task_a[3]
nUrl_a = task_a[4]
task_id_a = task_a[8]
#task_B에 관한 작업 수행
keyword_b = task_b[0]
channel_b = task_b[1]
startdate_b = task_b[2]
enddate_b = task_b[3]
nUrl_b = task_b[4]
task_id_b = task_b[8]
id = task_a[5]
proxy_id = task_a[7]
analyzer_a = textAnalyzer.TextAnalyzer(keyword_a, channel_a,
startdate_a, enddate_a, "Mecab",
nUrl_a, task_id_a, 'A', id)
analyzer_b = textAnalyzer.TextAnalyzer(keyword_b, channel_b,
startdate_b, enddate_b, "Mecab",
nUrl_b, task_id_b, 'B', id)
#워드클라우드를 위한 텍스트 분석
dict_a = analyzer_a.extractFrequentWords(500, 1)
dict_b = analyzer_b.extractFrequentWords(500, 1)
#a-b , a & b , b-a
try:
sc = setCalculus.setCalc(dict_a, dict_b)
interdict = sc.getInter()
differa = sc.getDiff1()
differb = sc.getDiff2()
plt.clf()
###### 벤다이어그램 ######
#a & b
wc5 = renderWordCloud.WordCloudRenderer(interdict, 'brg')
wc5.setMask("{}/mask_inter.png".format(self.base_dir +
self.mask_dir))
#a - b
wc6 = renderWordCloud.WordCloudRenderer(differa, 'Dark2')
wc6.setMask("{}/mask_diff1.png".format(self.base_dir +
self.mask_dir))
#b - a
wc7 = renderWordCloud.WordCloudRenderer(differb, 'tab10')
wc7.setMask("{}/mask_diff2.png".format(self.base_dir +
self.mask_dir))
# 교집합그림#
plt.figure(5, figsize=(16, 12))
plt.imshow(wc5.getWordCloud(), interpolation='bilinear')
plt.imshow(wc6.getWordCloud(), interpolation='bilinear')
plt.imshow(wc7.getWordCloud(), interpolation='bilinear')
plt.axis('off'), plt.xticks([]), plt.yticks([])
plt.tight_layout()
plt.subplots_adjust(left=0,
bottom=0,
right=1,
top=1,
hspace=0,
wspace=0)
img_name = str(id) + '.png'
img_path = '{}/source/inter/{}'.format(self.base_dir, img_name)
plt.savefig('{}/source/inter/{}'.format(self.base_dir, id),
pad_inches=0,
dpi=100,
transparent=False)
plt.close()
dao_ydns.update_wordcloud_path(self.base_dir,
str(id) + '.png', str(id))
img_url = self.upload_to_bucket(img_name, img_path, 'wordcloud_ap')
dao_ydns.update_img_url(img_url, id)
dao_ydns.update_gf(id)
dao_ydns.update_gather_finish(id)
dao_ydns.update_P_proxy(proxy_id)
print("{}완료".format(id))
except Exception as e:
print(e)
dao_ydns.update_er(id)
dao_ydns.update_P_proxy(proxy_id)
import pymysql
from crawler import navershopping
from crawler import naverblog
from crawler import bigkinds
from crawler import navernews
import re
import multiprocessing
import parmap
from threading import Thread
from crawler import dao
from crawler import data_util
##ydns dao 객체 생성
dao_ydns = dao.DAO(host='localhost',
port=3306,
user='******',
password='******',
db='crawl',
charset='utf8mb4')
#작업중인 요청 체크
row_gi = dao_ydns.select_gi()
##요청 처리하기(선입선출)
row_gr = dao_ydns.select_gr()
##만약 작업중인게 있다면
if len(row_gi) > 0:
print('이미진행중인 작업이 존재합니다.')
pass
elif len(row_gr) == 0:
print('요청작업이 없습니다')