def main():
parser = argparse.ArgumentParser(
description='example: python %s -d domain.com *.domain.com' %
os.path.basename(__file__))
parser.add_argument('-d',
'--domains',
help='domain list',
required=True,
nargs='+')
parser.add_argument('-c',
'--cert',
help='certificate name, e.g. domain.com')
parser.add_argument('-f',
'--force',
help='force renewal',
default=False,
action='store_true')
parser.add_argument('--dns',
help='dns type, default: aliyun',
default='aliyun',
choices=dns_types)
parser.add_argument('--challenge-alias',
dest='alias',
help='challenge aliased domain, e.g. alias.domain.com')
args = parser.parse_args()
Logger.info(args)
run(args)
def auth(dns_type='aliyun', aliased_domain=None):
try:
if 'CERTBOT_DOMAIN' not in os.environ:
raise Exception('Environment variable CERTBOT_DOMAIN is empty.')
if 'CERTBOT_VALIDATION' not in os.environ:
raise Exception(
'Environment variable CERTBOT_VALIDATION is empty.')
certbot_domain = aliased_domain or os.environ['CERTBOT_DOMAIN']
certbot_validation = os.environ['CERTBOT_VALIDATION']
Logger.info('manual#auth: Start to setting dns')
Logger.info('manual#auth certbot_domain: ' + certbot_domain)
Logger.info('manual#auth certbot_validation: ' + certbot_validation)
maindomain, acme_challenge = __extract_maindomain_and_challenge(
certbot_domain)
client = __get_dns_client(dns_type)
client.add_domain_record(maindomain, acme_challenge,
certbot_validation)
Logger.info('manual#auth: sleep %(time)i seconds' %
{'time': __get_wait_time()})
time.sleep(__get_wait_time())
Logger.info('manual#auth: Success.')
except Exception as e:
Logger.error('manual#auth raise Exception:' + str(e))
sys.exit()
def main():
parser = argparse.ArgumentParser(
description='example: python %s --auth --dns aliyun' %
os.path.basename(__file__))
parser.add_argument('-a', '--auth', help='auth hook', action='store_true')
parser.add_argument('-c',
'--cleanup',
help='cleanup hook',
action='store_true')
parser.add_argument('-t',
'--test',
help='test DNS API',
action='store_true')
parser.add_argument('--dns',
help='dns type, default: aliyun',
default='aliyun')
parser.add_argument('-d', '--domain', help='a domain for test DNS API')
parser.add_argument('--challenge-alias',
dest='alias',
help='challenge aliased domain, e.g. alias.domain.com')
args = parser.parse_args()
Logger.info(args)
if args.test:
if args.domain is None:
parser.error('-t, --test require --domain.')
return test(args.alias or args.domain, args.dns)
elif args.auth:
auth(args.dns, args.alias)
elif args.cleanup:
cleanup(args.dns, args.alias)
def run(args):
domains = map(lambda domain: '-d ' + domain, args.domains)
domains = ' '.join(domains)
Logger.info('obtain domains: ' + domains)
deploy_hook = '--deploy-hook "python ' + deploy_path + '"' if Utils.is_enable_deployment(
) else ''
cert_name = '--cert-name ' + args.cert if args.cert else ''
force_renewal = '--force-renewal' if args.force else ''
challenge_alias = '--challenge-alias ' + args.alias if args.alias else ''
certbot_cmd = certbot_cmd_template % {
'email': Config['base']['email'],
'cert_name': cert_name,
'force_renewal': force_renewal,
'manual_path': manual_path,
'dns': args.dns,
'deploy_hook': deploy_hook,
'domains': domains,
'challenge_alias': challenge_alias
}
Logger.info('certbot obtain: ' + certbot_cmd)
os.system(certbot_cmd)
def run():
# Init web
host = Config['API']['host']
port = int(Config['API']['port'])
Logger.info('Api running on port ' + str(port) + '.')
server = WSGIServer((host, port), Api.api, log=None)
server.serve_forever()
def __request(self, params):
url = self.__compose_url(params)
Logger.info('Request URL: ' + url)
request = urllib2.Request(url)
try:
f = urllib2.urlopen(request, timeout=45)
response = f.read().decode('utf-8')
Logger.info(response)
return response
except urllib2.HTTPError as e:
Logger.error('aliyun#__request raise urllib2.HTTPError: ' + str(e))
raise SystemExit(e)
def __init__(self, station):
self.station = station['ID']
self.name = station['Name']
position = utm.to_latlon(station['X'], station['Y'], 32, 'X')
self.lat = position[0]
self.lon = position[1]
self.lastUpdate = datetime(1970, 1, 1)
Logger.info('New stop ' + self.name + ' has been loaded ' + str(position) + '.')
def __extract_maindomain_and_challenge(domain):
sudomain, maindomain = Utils.extract_domain(domain)
acme_challenge = '_acme-challenge'
if sudomain:
acme_challenge += '.' + sudomain
Logger.info('manual_hook maindomain: ' + maindomain)
Logger.info('manual_hook acme_challenge: ' + acme_challenge)
return (maindomain, acme_challenge)
def __request(self, method, path, payload={}):
url = 'https://%s%s?%s' % (self.__endpoint,
self.__parse_path(path)[:-1],
self.__parse_query_string(path))
data = json.dumps(payload).encode('utf8')
sdk_date = self.__build_sdk_date()
Logger.info('Request URL: ' + url)
Logger.info('Request Data: ' + str(data))
request = urllib2.Request(url=url, data=data)
request.get_method = lambda: method
request.add_header('Content-Type', 'application/json')
request.add_header('Host', self.__endpoint)
request.add_header('X-sdk-date', sdk_date)
request.add_header('Authorization',
self.__build_authorization(request))
Logger.info('Request headers: ' + str(request.headers))
try:
f = urllib2.urlopen(request, timeout=45)
response = f.read().decode('utf-8')
Logger.info(response)
return response
except urllib2.HTTPError as e:
Logger.error('huaweicloud#__request raise urllib2.HTTPError: ' +
str(e))
raise SystemExit(e)
class Core:
"""Core class, contains core services (like listeners, executors, datapool)"""
def __init__(self):
self.cnf = cnf.get("core")
self.logger = Logger("Core")
self.logger.debug("Loading services")
self._services = []
for service_name in self.cnf.get("services"):
service = Loader.by_id('services', service_name)
self._services.append(service)
def start(self):
"""Starts all loaded services"""
self.logger.info("Starting")
for service in self._services:
service.start()
self.logger.info("Started")
def stop(self):
"""Stops all loaded services"""
self.logger.info("Stopping Core")
for service in self._services:
service.stop()
self.logger.info("Stopped")
def __compose_url(self, params):
common_params = {
'SecretId': self.secret_id,
'SignatureMethod': 'HmacSHA1',
'Nonce': int(round(time.time() * 1000)),
'Timestamp': int(time.time())
}
final_params = common_params.copy()
final_params.update(params)
final_params['Signature'] = self.__compute_signature(final_params)
Logger.info('Signature ' + str(final_params['Signature']))
url = 'https://%s%s?%s' % (self.__host, self.__path,
urllib.urlencode(final_params))
return url
def __compose_url(self, params):
common_params = {
'Format' : 'JSON',
'Version' : '2015-01-09',
'AccessKeyId' : self.access_key_id,
'SignatureVersion' : '1.0',
'SignatureMethod' : 'HMAC-SHA1',
'SignatureNonce' : int(round(time.time() * 1000)),
'Timestamp' : time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
}
final_params = common_params.copy()
final_params.update(params)
final_params['Signature'] = self.__compute_signature(final_params)
Logger.info('Signature ' + str(final_params['Signature']))
url = 'https://%s/?%s' % (self.__endpoint, urllib.urlencode(final_params))
return url
def run(args):
cert_names = map(lambda domain: '--cert-name ' + domain, args.certs)
cert_names = ' '.join(cert_names)
Logger.info('obtain cert_names: ' + cert_names)
force_renewal = '--force-renewal' if args.force else ''
deploy_hook = '--deploy-hook "python ' + deploy_path + '"' if Utils.is_enable_deployment(
) else ''
certbot_cmd = certbot_cmd_template % {
'deploy_hook': deploy_hook,
'cert_names': cert_names,
'force_renewal': force_renewal
}
Logger.info('certbot renew: ' + certbot_cmd)
os.system(certbot_cmd)
def main():
parser = argparse.ArgumentParser(description='example: python %s' %
os.path.basename(__file__))
parser.add_argument('-f',
'--force',
help='force renewal',
default=False,
action='store_true')
parser.add_argument('-c',
'--certs',
help='certificates, e.g. domain.com',
default=[],
nargs='*')
args = parser.parse_args()
Logger.info(args)
run(args)
def __request(self, method, path, payload={}):
url = 'https://%s%s%s' % (self.__host, self.__path, path)
data = json.dumps(payload).encode('utf-8')
Logger.info('Request URL: ' + url)
Logger.info('Request Data: ' + str(data))
request = urllib2.Request(url=url, data=data)
request.add_header('Content-Type', 'application/json')
request.add_header('Accept', 'application/json')
if self.api_token:
request.add_header('Authorization', 'Bearer %s' % (self.api_token))
elif self.email and self.api_key:
request.add_header('X-Auth-Email', self.email)
request.add_header('X-Auth-Key', self.api_key)
request.get_method = lambda: method
try:
f = urllib2.urlopen(request, timeout=45)
response = f.read().decode('utf-8')
Logger.info(response)
return response
except urllib2.HTTPError as e:
Logger.error('cloudflare#__request raise urllib2.HTTPError: ' +
str(e))
if e.code != 403:
raise SystemExit(e)
class Remote:
"""Used to run remote Actions.. meh"""
def __init__(self, ip, port):
self._send_lock = threading.Lock()
self._ip = ip
self._port = port
self._url = "tcp://%s:%s" % (ip, port)
self._logger = Logger("Remote %s" % self._url)
self._z_ctx = None
self._z_sck = None
def connect(self):
self._z_ctx = zmq.Context()
self._z_sck = self._z_ctx.socket(zmq.REQ)
def run(self, action, data=None):
msg = Message()
msg.set('action', action)
msg.set('data', data)
rep = self._send_msg(msg)
if rep.get('status') == False:
self._logger.info(rep.get('data'))
return rep
def _send_msg(self, msg):
self._logger.debug(msg.data())
self._send_lock.acquire()
self._z_sck.connect(self._url)
self._z_sck.send(msg.dump())
reply = Message.load(self._z_sck.recv())
self._send_lock.release()
self._logger.debug(reply.data())
return reply
def run():
try:
Logger.info('deploy#run deploy')
if 'RENEWED_LINEAGE' not in os.environ:
raise Exception('Environment variable RENEWED_LINEAGE is empty.')
if 'RENEWED_DOMAINS' not in os.environ:
raise Exception('Environment variable RENEWED_DOMAINS is empty.')
Logger.info('deploy#run start to deploy cert: ' +
os.environ['RENEWED_LINEAGE'])
Logger.info('deploy#run deploy domains: ' +
os.environ['RENEWED_DOMAINS'])
deploy()
Logger.info('deploy#run deployed cert')
except Exception as e:
Logger.error('deploy#run raise Exception:' + str(e))
def cleanup(dns_type='aliyun', aliased_domain=None):
try:
if 'CERTBOT_DOMAIN' not in os.environ:
raise Exception('Environment variable CERTBOT_DOMAIN is empty.')
certbot_domain = aliased_domain or os.environ['CERTBOT_DOMAIN']
Logger.info('manual#cleanup: Start to cleanup dns')
Logger.info('manual#cleanup: ' + certbot_domain)
maindomain, acme_challenge = __extract_maindomain_and_challenge(
certbot_domain)
client = __get_dns_client(dns_type)
client.delete_domain_record(maindomain, acme_challenge)
Logger.info('manual#cleanup: Success.')
except Exception as e:
Logger.error('manual#cleanup raise Exception:' + str(e))
sys.exit()
def __request(self, method, path, payload={}):
url = 'https://%s%s%s' % (self.__host, self.__path, path)
data = json.dumps(payload).encode('utf-8')
Logger.info('Request URL: ' + url)
Logger.info('Request Data: ' + str(data))
request = urllib2.Request(url=url, data=data)
request.add_header('Content-Type', 'application/json')
request.add_header('Accept', 'application/json')
request.add_header('Authorization',
'sso-key %s:%s' % (self.api_key, self.api_secret))
request.get_method = lambda: method
try:
f = urllib2.urlopen(request, timeout=45)
response = f.read().decode('utf-8')
Logger.info(response)
return response
except urllib2.HTTPError as e:
Logger.error('godaddy#__request raise urllib2.HTTPError: ' +
str(e))
raise SystemExit(e)
class Service(Loadable):
"""Base class for loadale service"""
# service consists of running thread and storage attached
def __init__(self, thread, id, root=cnf):
super().__init__(id, root)
self._data = Loader.by_id('storage', self.lcnf.get("storage"))
self._stop_timeout = 10
self._running = False
self._thread_to_run = thread
self._run_thread = None
self._logger = Logger('Service')
self._init()
def _init(self):
pass
def start(self):
"""Executes pre_start, starts thread and executes post_start"""
self._logger.debug('pre_start')
self._pre_start()
self._logger.debug('start')
self._running = True
self._run_thread = Thread(target=self._thread_to_run)
self._run_thread.daemon = True
self._run_thread.start()
self._logger.debug('post_start')
self._post_start()
self._logger.info('start finished')
def stop(self):
"""Executes pre_stop, stops thread and executes post_stop"""
self._logger.debug('pre_stop')
self._pre_stop()
self._logger.debug('stop')
self._running = False
self._run_thread.join(timeout=self._stop_timeout)
self._logger.debug('post_stop')
self._post_stop()
self._logger.info('stop finished')
def __run(self):
while self._running:
self._logger.debug('NOOP')
sleep(1)
def _pre_stop(self):
pass
def _post_stop(self):
pass
def _pre_start(self):
pass
def _post_start(self):
pass
hm = hmac.new(self.secret_access_key.encode('utf-8'),
string2sign.encode('utf-8'),
digestmod=hashlib.sha256).digest()
return binascii.hexlify(hm).decode()
def __urlencode(self, string):
return urllib.quote(str(string), safe='~')
def __hexencode_sha256_hash(self, data):
sha256 = hashlib.sha256()
sha256.update(data)
return sha256.hexdigest()
if __name__ == '__main__':
Logger.info('开始调用华为云 DNS API')
Logger.info(' '.join(sys.argv))
_, action, certbot_domain, acme_challenge, certbot_validation, api_key, api_secret = sys.argv
huaweicloud = HuaweiCloud(api_key, api_secret)
if 'add' == action:
huaweicloud.add_domain_record(certbot_domain, acme_challenge,
certbot_validation)
elif 'delete' == action:
huaweicloud.delete_domain_record(certbot_domain, acme_challenge,
certbot_validation)
elif 'get' == action:
huaweicloud.get_domain_record(certbot_domain, acme_challenge)
request.get_method = lambda: method
try:
f = urllib2.urlopen(request, timeout=45)
response = f.read().decode('utf-8')
Logger.info(response)
return response
except urllib2.HTTPError as e:
Logger.error('cloudflare#__request raise urllib2.HTTPError: ' +
str(e))
if e.code != 403:
raise SystemExit(e)
if __name__ == '__main__':
Logger.info('开始调用 Cloudflare DNS API')
Logger.info(' '.join(sys.argv))
_, action, certbot_domain, acme_challenge, certbot_validation, email, api_key, api_token = sys.argv
api_token = None if api_token == '_' else api_token
cloudflare = Cloudflare(email, api_key, api_token)
if 'add' == action:
cloudflare.add_domain_record(certbot_domain, acme_challenge,
certbot_validation)
elif 'delete' == action:
cloudflare.delete_domain_record(certbot_domain, acme_challenge,
certbot_validation)
elif 'get' == action:
cloudflare.get_domain_record(certbot_domain, acme_challenge)
images = Image.open(os.path.join(pic_dir, fine))
today_date.paste(images, (20, 365))
def fetcher_errors(images, drafts, msg="咦？设备好像出错了呀！"):
img = Image.open(os.path.join(pic_dir, 'ERROR.bmp'))
images.paste(img, (60, 20))
drafts.text((100, 160), msg, font=font48, fill=0)
return drafts
try:
# 读取天气位置坐标配置
weather_coordinate = open_fletcher(
os.path.join(BASE_DIR, 'weather_coordinate_fletcher.yml'))
logger.info('加载位置信息...')
location = Location()
Latitude = location.Location_Latitude()
Longitude = location.Location_Longitude()
logger.info('位置信息加载成功，正在获取天气信息...')
# 获取天气实况
weather_fletcher = weather(Latitude, Longitude, 'condition')
# 获取7天预报
forecast_days = weather(Latitude, Longitude, 'forecast15days')
forecast_data = write_weather_data(forecast_days.get('forecast'))
# 获取空气质量
aqi = weather(Latitude, Longitude, 'aqi')['aqi']
condition = weather_fletcher.get('condition')
epd = EPD()
logger.info("墨水屏正在初始化")
'sso-key %s:%s' % (self.api_key, self.api_secret))
request.get_method = lambda: method
try:
f = urllib2.urlopen(request, timeout=45)
response = f.read().decode('utf-8')
Logger.info(response)
return response
except urllib2.HTTPError as e:
Logger.error('godaddy#__request raise urllib2.HTTPError: ' +
str(e))
raise SystemExit(e)
if __name__ == '__main__':
Logger.info('开始调用 Godaddy DNS API')
Logger.info(' '.join(sys.argv))
_, action, certbot_domain, acme_challenge, certbot_validation, api_key, api_secret = sys.argv
godaddy = GoDaddy(api_key, api_secret)
if 'add' == action:
godaddy.add_domain_record(certbot_domain, acme_challenge,
certbot_validation)
elif 'delete' == action:
godaddy.delete_domain_record(certbot_domain, acme_challenge,
certbot_validation)
elif 'get' == action:
godaddy.get_domain_record(certbot_domain, acme_challenge)
signature = base64.encodebytes(digest).strip()
return signature
def __percent_encode(self, string):
if sys.version_info <(3,0):
res = urllib.quote(string.decode('utf8').encode('utf8'), '')
else:
res = urllib.quote(string.encode('utf8'))
res = res.replace('+', '%20')
res = res.replace('\'', '%27')
res = res.replace('\"', '%22')
res = res.replace('*', '%2A')
res = res.replace('%7E', '~')
return res
if __name__ == '__main__':
Logger.info('开始调用阿里云 DNS API')
Logger.info('-'.join(sys.argv))
_, action, certbot_domain, acme_challenge, certbot_validation, access_key_id, access_key_secret = sys.argv
aliyun = Aliyun(access_key_id, access_key_secret)
if 'add' == action:
aliyun.add_domain_record(certbot_domain, acme_challenge, certbot_validation)
elif 'delete' == action:
aliyun.delete_domain_record(certbot_domain, acme_challenge)
Logger.info('结束调用阿里云 DNS API')
