class CloudflareProvider():
def __init__(self,
email=config.CLOUDFLARE_EMAIL,
api_key=config.CLOUDFLARE_KEY,
zone='ccis.io'):
self.zone = zone
self.client = PyflareClient(email, api_key)
def add_cname(self, hostname, target):
return self.client.rec_new(self.zone, 'CNAME', hostname, target)
def __init__(self,
email=config.CLOUDFLARE_EMAIL,
api_key=config.CLOUDFLARE_KEY,
zone='ccis.io'):
self.zone = zone
self.client = PyflareClient(email, api_key)
def setUp(self):
self.pyflare = PyflareClient('*****@*****.**', 'your_api_key')
from pyflare import PyflareClient
import mcstatus, yaml, threading
with open('config.yml', 'r') as cfg_file:
config = yaml.load(cfg_file)
email = config['email']
api_key = config['api-key']
domain = config['domain']
ip_pool = config['ips']
entry = config['entry']
cf = PyflareClient(email, api_key)
def get_slp_results(ips):
results = {}
for ip in ips:
status = mcstatus.McServer(ip, '25565')
status.Update()
results[ip] = status.available
return results
def get_records_for_name(name):
records = {}
response = cf.rec_load_all(domain)
for entry in response:
entry_name = entry['name']
if entry_name == name:
records[str(entry['display_content'])] = str(entry['rec_id'])
return records
class PyflareTest(unittest.TestCase):
def setUp(self):
self.pyflare = PyflareClient('*****@*****.**', 'your_api_key')
@mock_response_client
def test_stats(self):
response = self.pyflare.stats('example.com', 40)
self.assertIsInstance(response['response']['result']['timeZero'], int)
@mock_response_client
def test_zone_load_multi(self):
response = self.pyflare.zone_load_multi()
self.assertIsInstance(response['response']['zones']['count'], int)
@mock_response_client
def test_rec_load_all(self):
for response in self.pyflare.rec_load_all('example.com'):
self.assertIsInstance(response['props']['cloud_on'], int)
@mock_response_client
def test_zone_check(self):
response = self.pyflare.zone_check(['example.com'])
for zone, zid in response['response']['zones'].items():
self.assertIsInstance(zid, int)
@mock_response_client
def test_zone_ips(self):
response = self.pyflare.zone_ips('example.com')
self.assertIsInstance(response['response']['ips'], list)
@mock_response_client
def test_ip_lkup(self):
ip = '0.0.0.0'
response = self.pyflare.ip_lkup(ip)
self.assertIn(ip, response['response'])
@mock_response_client
def test_zone_settings(self):
response = self.pyflare.zone_settings('example.com')
self.assertIsInstance(response['response']['result']['objs'], list)
@mock_response_client
def test_sec_lvl(self):
response = self.pyflare.sec_lvl('example.com', 'med')
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_cache_lvl(self):
response = self.pyflare.cache_lvl('example.com', 'agg')
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_devmode(self):
response = self.pyflare.devmode('example.com', False)
self.assertIn('zone_id', response['response']['zone']['obj'])
@mock_response_client
def test_fpurge_ts(self):
response = self.pyflare.fpurge_ts('example.com')
self.assertIsInstance(response['response']['fpurge_ts'], int)
@mock_response_client
def test_zone_file_purge(self):
response = self.pyflare.zone_file_purge('example.com', 'https://example.com/image.jpg')
self.assertIn('url', response['response'])
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_zone_grab(self):
response = self.pyflare.zone_grab(9001)
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_wl(self):
response = self.pyflare.wl('0.0.0.0')
self.assertEqual(response['result'], 'success')
self.assertEqual(response['response']['result']['action'], 'WL')
@mock_response_client
def test_ban(self):
response = self.pyflare.ban('0.0.0.0')
self.assertEqual(response['result'], 'success')
self.assertEqual(response['response']['result']['action'], 'BAN')
@mock_response_client
def test_nul(self):
response = self.pyflare.nul('0.0.0.0')
self.assertEqual(response['result'], 'success')
self.assertEqual(response['response']['result']['action'], 'NUL')
@mock_response_client
def test_ipv46(self):
response = self.pyflare.ipv46('example.com', False)
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_async(self):
response = self.pyflare.async('example.com', 0)
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_minify(self):
response = self.pyflare.minify('example.com', 0)
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_mirage2(self):
response = self.pyflare.mirage2('example.com', False)
self.assertEqual(response['result'], 'success')
@mock_response_client
def test_rec_new(self):
response = self.pyflare.rec_new('example.com', 'A', 'sub', '1.2.3.4')
self.assertIn('rec_id', response['response']['rec']['obj'])
@mock_response_client
def test_rec_edit(self):
response = self.pyflare.rec_edit('example.com', 'A', 9001, 'sub', '1.2.3.4')
self.assertIn('rec_id', response['response']['rec']['obj'])
@mock_response_client
def test_rec_delete(self):
response = self.pyflare.rec_delete('example.com', 9001)
self.assertEqual(response['result'], 'success')
import sys
from requests import get
from pyflare import PyflareClient
# parsing command line arguments
email = sys.argv[1]
api_key = sys.argv[2]
root_domain = sys.argv[3]
sub_domain = sys.argv[4]
full_domain = sub_domain + '.' + root_domain
# get the current outside ip
outside_ip = get('http://api.ipify.org').text
# ask clouflare for all domain settings for that root_domain
cf = PyflareClient(email, api_key)
for setting in cf.rec_load_all(root_domain):
# get the dynamic dns entry from cloudflare
if (setting['name'] == full_domain) and (setting['type'] == 'A'):
# check if the ip address behind the dns entry is the one it should be
if outside_ip != setting['content']:
# change the ip address for that entry
single_domain_setting = cf.rec_edit(root_domain, 'A',
setting['rec_id'], sub_domain,
outside_ip)
# print message if dns entry was modified
if single_domain_setting['result'] == 'success':
current_ip4 = subprocess.check_output(
["dig +short myip.opendns.com @resolver1.opendns.com"],
shell=True).strip().decode()
current_ip6 = subprocess.check_output(["curl -6 utils.80x24.ca/my_ip"],
shell=True).strip().decode()
except Exception as e:
print("Failed to get IP.", e)
sys.exit(1)
# check that they're different
if old_ip4 == current_ip4 and old_ip6 == current_ip6:
print("IPs haven't changed")
sys.exit(0)
# the IP has changed, so let's update the record
cf = PyflareClient(CF_EMAIL, CF_API_KEY)
rec_id = None
for rec in cf.rec_load_all(CF_ZONE):
if rec['display_name'] == CF_REC_NAME and rec['type'] == 'A':
rec_id4 = rec['rec_id']
elif rec['display_name'] == CF_REC_NAME and rec['type'] == 'AAAA':
rec_id6 = rec['rec_id']
if rec_id4 is None:
print("Couldn't find the record.")
sys.exit(2)
cf.rec_edit(CF_ZONE, 'A', int(rec_id4), CF_REC_NAME, current_ip4)
cf.rec_edit(CF_ZONE, 'AAAA', int(rec_id6), CF_REC_NAME, current_ip6)
from pyflare import PyflareClient
from urllib.request import urlopen
from configparser import ConfigParser
import os
#Gets necessary variables
workingdirectory = os.getcwd()
configlocation = workingdirectory+'/config.ini'
Config = ConfigParser()
Config.read(configlocation)
apikey = Config.get('Settings', 'APIKey')
email = Config.get('Settings', 'Email')
recordname = Config.get('Settings', 'RecordName')
domain = Config.get('Settings','Domain')
cf = PyflareClient(email, apikey)
#Gets Public IP
ip = urlopen("https://api.ipify.org").read().decode("utf-8")
cf.rec_edit(domain, 'A', 'None', recordname, ip)
""" purge.py
"""
from os import environ
from pyflare import PyflareClient, APIError
try:
cf = PyflareClient(environ['CLOUDFLARE_EMAIL'], environ['CLOUDFLARE_KEY'])
cf.fpurge_ts('scrumtio.us')
except KeyError:
exit()
except APIError as error:
print 'Purge failed'
print error
