1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
#!/usr/bin/env python3
import requests
import yaml
import json
import os
import shutil
import logging
import time
import argparse
import subprocess
import hashlib
import daemon
logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', level=logging.INFO)
class ClashUp:
EXAMPLE_CONF = '''{
"http_port": 7890,
"socks5_port": 7891,
"redir_port": 7892,
"mixed_port": 7893,
"allow_lan": true,
"external_controller": "127.0.0.1:9090",
"subscribe_url": "",
"is_subscribe_banned": false,
"custom_rules": [],
"mmdb_file_url": "http://www.ideame.top/mmdb/Country.mmdb",
"mmdb_version_url: "http://www.ideame.top/mmdb/version",
"periodically_update": false
}
'''
def __init__(self):
self.conf_file_path = os.path.expanduser('~/.config/clash/clashup.json')
self.clash_conf_path = os.path.expanduser('~/.config/clash/config.yaml')
self.clash_conf_path_old = os.path.expanduser('~/.config/clash/config.yaml.old')
self.cache_file_path = os.path.expanduser('~/.cache/clashup')
self.mmdb_version_file = os.path.expanduser('~/.cache/clashup-mmdb')
self.mmdb_file_path = os.path.expanduser('~/.config/clash/Country.mmdb')
self.session = requests.Session()
self.session.trust_env = False
def load_conf(self):
if not os.path.isfile(self.conf_file_path):
with open(self.conf_file_path, 'w') as f:
f.write(self.EXAMPLE_CONF)
raise OSError('plz edit ~/.config/clash/clashup.json')
with open(self.conf_file_path) as f:
raw_config_text = f.read()
raw_config = json.loads(raw_config_text)
if not raw_config.get('subscribe_url'):
raise ValueError('subscribe_url can not be empty')
self.config = raw_config
hash_item = hashlib.sha256(raw_config_text.encode())
self.config_hash = hash_item.hexdigest()
def download(self, use_proxy=False):
if use_proxy:
proxy = {
'http': 'http://127.0.0.1:{}'.format(self.config['http_port']),
'https': 'http://127.0.0.1:{}'.format(self.config['http_port'])
}
res = self.session.get(self.config['subscribe_url'], timeout=5, proxies=proxy)
else:
res = self.session.get(self.config['subscribe_url'], timeout=5, proxies={'http': None, 'https': None})
res.raise_for_status()
raw_clash_conf = yaml.safe_load(res.text)
return raw_clash_conf
def _load_conf(self, config, local_config_key, config_key):
if local_config_key in self.config:
config[config_key] = self.config[local_config_key]
def parse_config(self, config):
self._load_conf(config, 'http_port', 'port')
self._load_conf(config, 'socks5_port', 'socks-port')
self._load_conf(config, 'redir_port', 'redir-port')
self._load_conf(config, 'mixed_port', 'mixed-port')
self._load_conf(config, 'allow_lan', 'allow-lan')
self._load_conf(config, 'external_controller', 'external-controller')
config['rules'] = self.config.get('custom_rules', []) + config.get('rules', [])
return config
def save(self, config):
if os.path.isfile(self.clash_conf_path):
shutil.move(self.clash_conf_path, self.clash_conf_path_old)
with open(self.clash_conf_path, 'w') as f:
f.write(yaml.safe_dump(config))
def update(self, use_proxy):
logging.info('Update Start')
try:
raw_clash_conf = self.download(use_proxy)
parsed_clash_conf = self.parse_config(raw_clash_conf)
self.save(parsed_clash_conf)
logging.info('Update Finish')
except requests.exceptions.RequestException:
logging.warning('Update Fail')
def update_mmdb(self):
try:
resp = self.session.get(self.config['mmdb_version_url'], proxies={'http': None, 'https': None})
resp.raise_for_status()
current_version = resp.text
if os.path.isfile(self.mmdb_version_file):
with open(self.mmdb_version_file, 'r') as f:
if current_version == f.read():
logging.info('pass mmdb update')
return
resp = self.session.get(self.config['mmdb_file_url'], proxies={'http': None, 'https': None})
resp.raise_for_status()
with open(self.mmdb_file_path, 'wb') as f:
f.write(resp.content)
with open(self.mmdb_version_file, 'w') as f:
f.write(current_version)
logging.info('Update mmdb')
except requests.exceptions.RequestException:
logging.warning('Update mmdb failed')
def update_time_cache(self):
if not os.path.isfile(self.cache_file_path):
self._write_cache()
return True
else:
with open(self.cache_file_path, 'r') as f:
cache_text = f.read().split('-')
last_time = float(cache_text[1])
if cache_text[0] != self.config_hash or time.time() - last_time > 86400:
self._write_cache()
return True
else:
return False
def _write_cache(self):
with open(self.cache_file_path, 'w') as f:
f.write('{}-{}'.format(self.config_hash, time.time()))
def run(self):
parser = argparse.ArgumentParser()
parser.add_argument('--pre', action='store_true')
parser.add_argument('--post', action='store_true')
parser.add_argument('--update', action='store_true')
args = parser.parse_args()
self.load_conf()
if args.update:
self.update(False)
self.update_mmdb()
elif args.pre and not self.config.get('periodically_update', False):
if self.config['is_subscribe_banned']:
logging.info('Subscribe is banned, pass this run')
else:
self.update(False)
if self.config.get('mmdb_version_url') and self.config.get('mmdb_file_url'):
with daemon.DaemonContext():
self.update_mmdb()
elif args.post and not self.config.get('periodically_update', False):
if self.config['is_subscribe_banned']:
if self.update_time_cache():
self.update(True)
subprocess.run(['systemctl', '--user', 'restart', 'clash'])
else:
logging.info('config file updated in 24h, pass this run')
else:
logging.info('pass this run')
if __name__ == '__main__':
ClashUp().run()
|