mirror of
https://gitee.com/Vancouver2017/luban-lite-t3e-pro.git
synced 2025-12-14 18:38:55 +00:00
244 lines
7.7 KiB
Python
244 lines
7.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import json
|
|
import copy
|
|
import time
|
|
import hashlib
|
|
import datetime
|
|
import subprocess
|
|
from adb_transfer import adb_push_file
|
|
from adb_transfer import adb_read_data
|
|
from adb_transfer import adb_write_data
|
|
|
|
loacl_path = ''
|
|
remote_path = ''
|
|
adb_exec_path = ''
|
|
adb_serial_number = ''
|
|
|
|
adb_sync_mod_name = 'sync_mod'
|
|
adb_sync_key = 'path'
|
|
name = 'name'
|
|
md5 = 'md5'
|
|
buff_size = 512
|
|
|
|
def get_pc_dir_info(path):
|
|
result = []
|
|
paths = os.listdir(path)
|
|
for i, item in enumerate(paths):
|
|
sub_path = os.path.join(path, item)
|
|
if os.path.isdir(sub_path):
|
|
file_info = {}
|
|
file_info[name] = path[len(loacl_path) :] + item + '/'
|
|
file_info[md5] = ''
|
|
result.append(file_info)
|
|
result += get_pc_dir_info(sub_path + '/')
|
|
else:
|
|
myhash = hashlib.md5()
|
|
f = open(sub_path,'rb')
|
|
while True:
|
|
b = f.read(8096)
|
|
if not b :
|
|
break
|
|
myhash.update(b)
|
|
f.close()
|
|
file_info = {}
|
|
file_info[name] = path[len(loacl_path) :] + item
|
|
file_info[md5] = str(myhash.hexdigest())
|
|
result.append(file_info)
|
|
return result
|
|
|
|
def get_dev_dir_info(path):
|
|
param = {}
|
|
result = None
|
|
param[adb_sync_key] = path
|
|
data = adb_read_data(adb_sync_mod_name, param, adb_path = adb_exec_path, serial_number = adb_serial_number)
|
|
if data:
|
|
result = json.loads(data)
|
|
return result
|
|
|
|
def get_sync_info(pc_info, dev_info):
|
|
sync_info = {}
|
|
delete_list = []
|
|
sync_list = []
|
|
temp = {}
|
|
|
|
for item in json_pc:
|
|
temp[item[name]] = item[md5]
|
|
for item in dev_info:
|
|
if not item[name] in list(temp.keys()):
|
|
delete_list.append(item[name])
|
|
elif item[md5] == temp[item[name]]:
|
|
del temp[item[name]]
|
|
|
|
for item in list(temp.keys()):
|
|
sync_list.append(item)
|
|
|
|
sync_info['delete'] = delete_list
|
|
sync_info['sync'] = sync_list
|
|
|
|
return sync_info
|
|
|
|
def dev_file_delete(path, delete_list):
|
|
buff = ''
|
|
curr_len = 0
|
|
for item in delete_list:
|
|
if curr_len + len(item) < buff_size - 4:
|
|
if curr_len == 0:
|
|
buff = '['
|
|
buff += '\"' + item + '\"'
|
|
else:
|
|
buff += ',' + '\"' + item + '\"'
|
|
curr_len = len(buff)
|
|
else:
|
|
buff += ']'
|
|
buff += b'\x00' * (buff_size-curr_len)
|
|
curr_len = 0
|
|
if curr_len != 0:
|
|
buff += ']'
|
|
buff += b'\x00' * (buff_size-curr_len)
|
|
curr_len = 0
|
|
param = {}
|
|
param[adb_sync_key] = path
|
|
adb_write_data(adb_sync_mod_name, param, buff, adb_path = adb_exec_path, serial_number = adb_serial_number)
|
|
|
|
def dev_file_delete_(path, delete_list):
|
|
success_list = []
|
|
failure_list = []
|
|
result = {}
|
|
for item in delete_list:
|
|
buff = []
|
|
buff.append(item)
|
|
json_str = json.dumps(buff).encode('utf-8') + b'\x00'
|
|
if len(json_str) > buff_size:
|
|
print('err! file name is to long')
|
|
else:
|
|
param = {}
|
|
param[adb_sync_key] = path
|
|
print('delete ' + item)
|
|
if adb_write_data(adb_sync_mod_name, param, json_str, adb_path = adb_exec_path, serial_number = adb_serial_number) == 'OK':
|
|
success_list.append(item)
|
|
else:
|
|
failure_list.append(item)
|
|
result['success'] = success_list
|
|
result['failure'] = failure_list
|
|
return result
|
|
|
|
def dev_file_sync(sync_list):
|
|
return adb_push_file(loacl_path, remote_path, sync_list, adb_path = adb_exec_path, serial_number = adb_serial_number)
|
|
|
|
def list_merge_path(list):
|
|
i = 0
|
|
j = 0
|
|
sort_res = sorted(list,key = lambda i:len(i),reverse=False)
|
|
while i < len(sort_res):
|
|
j = i + 1
|
|
while j < len(sort_res):
|
|
t1 = sort_res[i]
|
|
t2 = sort_res[j]
|
|
if t2.count(t1, 0, len(t1)) > 0:
|
|
sort_res.pop(j)
|
|
else:
|
|
j += 1
|
|
i += 1
|
|
return sort_res
|
|
|
|
def list_filtration_folders(list):
|
|
res = []
|
|
for item in list:
|
|
if item[-1] != '/':
|
|
res.append(item)
|
|
return res
|
|
|
|
def file_path_check():
|
|
global loacl_path
|
|
global remote_path
|
|
global adb_exec_path
|
|
|
|
loacl_path = loacl_path.replace('\\', '/')
|
|
remote_path = remote_path.replace('\\', '/')
|
|
if adb_exec_path != '':
|
|
adb_exec_path = adb_exec_path.replace('\\', '/')
|
|
if not os.path.exists(adb_exec_path):
|
|
print(adb_exec_path + ' adb exec path not exist')
|
|
return False
|
|
else:
|
|
if os.path.isdir(adb_exec_path):
|
|
if adb_exec_path[-1] != '/':
|
|
adb_exec_path += '/'
|
|
if not os.path.exists(adb_exec_path + 'adb.exe'):
|
|
print(adb_exec_path + 'adb.exe' + ' not exist')
|
|
return False
|
|
if loacl_path[-1] != '/':
|
|
loacl_path = loacl_path + '/'
|
|
if remote_path[-1] != '/':
|
|
remote_path = remote_path + '/'
|
|
|
|
if not os.path.exists(loacl_path):
|
|
print(loacl_path + ' folder does not exist')
|
|
return False
|
|
return True
|
|
|
|
def string_insensitive_sort(str_list):
|
|
listtemp = [(x.lower(),x) for x in str_list]
|
|
listtemp.sort()
|
|
return [x[1] for x in listtemp]
|
|
|
|
def user_parameter_parsing(args):
|
|
global adb_exec_path
|
|
global adb_serial_number
|
|
|
|
for i in range(0, len(args)):
|
|
if args[i] == '-s':
|
|
adb_serial_number = args[i+1]
|
|
elif args[i] == '-p':
|
|
adb_exec_path = args[i+1]
|
|
|
|
if __name__=='__main__':
|
|
loacl_path = sys.argv[1] if len(sys.argv) > 1 else '.'
|
|
remote_path = sys.argv[2] if len(sys.argv) > 2 else '/'
|
|
if len(sys.argv) > 3:
|
|
user_parameter_parsing(sys.argv[3:])
|
|
if file_path_check() == False:
|
|
exit(0)
|
|
starttime = time.time()
|
|
print('loacl:' + loacl_path)
|
|
print('remote:' + remote_path)
|
|
print('---------------- get dev info ----------------')
|
|
json_dev = get_dev_dir_info(remote_path)
|
|
if not isinstance(json_dev, list):
|
|
exit(0)
|
|
print('---------------- get pc info ----------------')
|
|
json_pc = get_pc_dir_info(loacl_path)
|
|
print('---------------- sync check ----------------')
|
|
sync_info = get_sync_info(json_pc, json_dev)
|
|
sync_list = list_filtration_folders(sync_info['sync'])
|
|
delete_list = list_merge_path(sync_info['delete'])
|
|
print('---------------- sync file ----------------')
|
|
sync_list_sort = string_insensitive_sort(sync_list)
|
|
sync_res = dev_file_sync(sync_list_sort)
|
|
print('---------------- delete file ----------------')
|
|
delete_list_sort = string_insensitive_sort(delete_list)
|
|
delete_res = dev_file_delete_(remote_path, delete_list_sort)
|
|
sync_try_res = {}
|
|
if len(sync_res['failure']) > 0:
|
|
print('---------------- sync retry ----------------')
|
|
sync_try_res = dev_file_sync(sync_res['failure'])
|
|
delete_try_res = {}
|
|
if len(delete_res['failure']) > 0:
|
|
print('---------------- delete retry ----------------')
|
|
delete_try_res = dev_file_delete_(delete_res['failure'])
|
|
print('---------------- sync end ----------------')
|
|
pc_list = []
|
|
for item in json_pc:
|
|
pc_list.append(item[name])
|
|
all_count = len(list_filtration_folders(sync_info['sync']))
|
|
delt_count = len(list_filtration_folders(sync_info['delete']))
|
|
fail_count = len(sync_try_res['failure']) if sync_try_res else 0
|
|
sync_count = all_count - fail_count
|
|
skip_count = len(list_filtration_folders(pc_list)) - sync_count
|
|
endtime = time.time()
|
|
print('sync:' + str(sync_count) + ' fail:' + str(fail_count) + ' skip:' + str(skip_count) + ' delete:' + str(delt_count) + ' time:' + str(round(endtime - starttime, 2)) + 's')
|