def main():
if os.getenv("CF_API_KEY"):
CF_API_KEY = os.getenv("CF_API_KEY")
if os.getenv("CF_API_EMAIL"):
CF_API_EMAIL = os.getenv("CF_API_EMAIL")
cf = CloudFlare.CloudFlare(token=CF_API_KEY,
email=CF_API_EMAIL,
raw=True)
else:
cf = CloudFlare.CloudFlare(token=CF_API_KEY, raw=True)
else:
usage()
sys.exit(1)
cf = CloudFlare.CloudFlare(raw=True)
ZONE_ID, ZONE_NAME = getzoneid(cf)
WAF_ID = getwafid(cf, ZONE_ID)
mode = getMode()
apply = areYouSure(mode, ZONE_NAME)
if apply == 1:
log.info('Modifying rules')
changeRules(cf, mode, ZONE_ID, WAF_ID)
else:
log.info('Not Modifying any rule')
return
def _all_records(self):
cf = CloudFlare.CloudFlare()
zones = cf.zones.get(params={
'name': self._ctx.zone_name,
'per_page': 1
})
if len(zones) == 0:
exit('No zones found')
zone_id = zones[0]['id']
cf_raw = CloudFlare.CloudFlare(raw=True)
page = 1
records = []
while True:
raw_results = cf_raw.zones.dns_records.get(
zone_id,
params={
'per_page': 100,
'page': page
},
)
total_pages = raw_results['result_info']['total_pages']
result = raw_results['result']
for rec in result:
records.append(rec)
if page == total_pages:
break
page += 1
return records
def on_event(self, event, extension):
""" Handles Prefences Update event """
if event.id == 'api_key':
extension.cf_client = CloudFlare.CloudFlare(
email=extension.preferences['email'], token=event.new_value)
elif event.id == 'email':
extension.cf_client = CloudFlare.CloudFlare(
email=event.new_value, token=extension.preferences['api_key'])
def __init__(self, zone, email=None, api=None):
if email and api:
self.cf = CloudFlare.CloudFlare(email=email, token=api)
else:
self.cf = CloudFlare.CloudFlare()
try:
self.zoneid = self.cf.zones.get(params=dict(name=zone))[0]['id']
except IndexError:
raise UserWarning("Zone '%s' not found" % zone)
def add():
if 'user_info' not in session:
return redirect(url_for('home'))
if request.method == 'POST':
domain = request.form['domain']
type = request.form['type']
if not domain or not type:
flash('请正确输入域名和正确选择接入类型', 'red')
return render_template('add.html')
user_info = session['user_info']
if type == 'cname':
result = cf.zone_set(user_info['user_key'], domain, 'example.com', '_domain-wildcard')
pprint.pprint(result)
if result['result'] == 'error':
flash(result['msg'], 'red')
return render_template('add.html')
cf_client = CloudFlare.CloudFlare(user_info['cloudflare_email'], token=user_info['user_api_key'])
zone = cf_client.zones.get(params={'name': domain})[0]
dns_records = cf_client.zones.dns_records.get(zone['id'])
for record in dns_records:
if record['content'] == 'example.com':
cf_client.zones.dns_records.delete(zone['id'], record['id'])
flash(f'添加域名 {domain} 成功!', 'green')
return redirect(url_for('zones', domain=domain))
if type == 'ns':
result = cf.full_zone_set(user_info['user_key'], domain)
pprint.pprint(result)
if result['result'] == 'error':
flash(result['msg'], 'red')
return render_template('add.html')
flash(f'添加域名 {domain} 成功!', 'green')
flash(result['response']['msg'], 'red')
return redirect(url_for('zones', domain=domain))
return render_template('add.html')
def domain_records_list(request):
try:
if not request.session.get('is_login', False):
return record_error3
cf = CloudFlare.CloudFlare(request.session['user_mail'],
request.session['user_api_key'])
data_id = request.GET.get('data_id')
dns_records = cf.zones.dns_records.get(data_id)
if len(dns_records):
zone_name = dns_records[0]['zone_name']
record_list = []
record_list.append({'status': 'success', 'zone_name': zone_name})
for dns_record in dns_records:
record_data = {}
record_data['record_id'] = dns_record['id']
record_data['name'] = dns_record['name']
record_data['type'] = dns_record['type']
record_data['value'] = dns_record['content']
record_data['ttl'] = dns_record['ttl']
record_data['time'] = dns_record['modified_on']
record_data['proxied'] = dns_record['proxied']
record_list.append(record_data)
record_lists = json.dumps(record_list)
return HttpResponse(record_lists)
else:
record_list = []
record_list.append({'status': 'no_records', 'zone_name': 'none'})
record_lists = json.dumps(record_list)
return HttpResponse(record_lists)
except CloudFlare.exceptions.CloudFlareAPIError as e:
return record_error1
except Exception as e:
return record_error2
def __init__(self):
self.cfapi = CloudFlare.CloudFlare()
self.dns_provider_name = 'cloudflare'
self.logger = get_logger(__name__).bind(
dns_provider_name=self.dns_provider_name)
def purge_cache(self, bucket_name):
"""
Purge the Cloudflare cache for the frontend hostname.
Frontend S3 buckets are named by hostname.
Cloudflare zones are named by domain.
Assumes the caller's shell has the following environment
variables set to enable Cloudflare API auth:
CF_API_EMAIL
CF_API_KEY
"""
zone_name = '.'.join(
bucket_name.split('.')[-2:]) # Zone name is the TLD
data = {'hosts': [bucket_name]}
cloudflare_client = CloudFlare.CloudFlare()
try:
zone_id = cloudflare_client.zones.get(
params={'name': zone_name})[0]['id'] # pylint: disable=no-member
cloudflare_client.zones.purge_cache.post(zone_id, data=data) # pylint: disable=no-member
self.LOG(
'Successfully purged Cloudflare cache for hostname {}.'.format(
bucket_name))
except (CloudFlare.exceptions.CloudFlareAPIError, IndexError,
KeyError):
self.FAIL(
1,
'Failed to purge the Cloudflare cache for hostname {}.'.format(
bucket_name))
def main():
st.title('CloudCoFlare')
st.write('DNS Updater app for CloudCo')
st.write('Select the record type, enter the subdomain and ip address. Press enter when done to confirm.')
zone_name = 'cloudcopartner.com'
cf = CloudFlare.CloudFlare(email=auth.cf_email, token=auth.cf_api_key)
# query the zone name and expect only one value back
try:
zones = cf.zones.get(params={'name': zone_name, 'per_page': 1})
except CloudFlare.exceptions.CloudFlareAPIError as e:
exit('/zones.get %d %s - api call failed' % (e, e))
except Exception as e:
exit('/zones.get - %s api call failed' % e)
if len(zones) == 0:
exit('No zones found')
# extract the zone_id which is needed to process that zone
zone = zones[0]
zone_id = zone['id']
# request the DNS records from that zone
try:
dns_records = cf.zones.dns_records.get(zone_id)
except CloudFlare.exceptions.CloudFlareAPIError as e:
exit('/zones/dns_records.get %d %s - api call failed' % (e, e))
record_type = st.selectbox(
'Record Type',
['A', 'CNAME'])
record_name = st.text_input('Record Subdomain (omit ".cloudcopartner.com")')
record_content = st.text_input('IP Address')
dns_record = {
'type': record_type,
'name': record_name,
'content': record_content,
'proxied': False
}
if record_name and record_content:
try:
r = cf.zones.dns_records.post(zone_id, data=dns_record)
st.write('Record submitted successfully')
except CloudFlare.exceptions.CloudFlareAPIError as e:
st.write('Record submission failed')
exit('/zones.dns_records.post %s %s - %d %s' % (zone_name, dns_record['name'], e, e))
dns_record = r
st.write('\t%s %30s %6d %-5s %s ; proxied=%s proxiable=%s' % (
dns_record['id'],
dns_record['name'],
dns_record['ttl'],
dns_record['type'],
dns_record['content'],
dns_record['proxied'],
dns_record['proxiable']
))
def dns_cloudflare_test(user, key):
cf = CloudFlare.CloudFlare(email=user, token=key)
try:
cf.zones.get(params={'per_page': 1})
return True
except:
return False
def upsert_cloudflare_cnames(slugs: list = None):
# takes a list instead of a single entry so it can do one call to fetch them all
heroku_app_name = os.environ.get("HEROKU_APP_NAME")
zone_name = os.environ.get("CF_ZONE_NAME")
cloudflare_conn = CloudFlare.CloudFlare()
zone_id = cloudflare_conn.zones.get(params={"name": zone_name})[0]["id"]
# fetch this so we don't try adding entries that are already there
# TODO: if this reaches over 300 we'll need to paginate
zone_dns_records = cloudflare_conn.zones.dns_records.get(
zone_id, params={"per_page": 300})
cloudflare_domains = {x["name"]: x["content"] for x in zone_dns_records}
cloudflare_record_ids = {x["name"]: x["id"] for x in zone_dns_records}
for slug in slugs:
fqdn = f"{slug}.{zone_name}"
content = f"{heroku_app_name}.herokuapp.com"
dns_record = {
"name": f"{slug}",
"type": "CNAME",
"content": content,
"proxied": True
}
try:
if fqdn not in cloudflare_domains:
logger.info("Creating DNS entry for %s → %s", fqdn, content)
cloudflare_conn.zones.dns_records.post(zone_id,
data=dns_record)
elif cloudflare_domains[fqdn] != content:
logger.info("Updating DNS entry for %s → %s", fqdn, content)
record_id = cloudflare_record_ids[fqdn]
cloudflare_conn.zones.dns_records.patch(zone_id,
record_id,
data=dns_record)
except CloudFlare.exceptions.CloudFlareAPIError as error:
logger.warning(error)
def read_records(domain_name):
cf = CloudFlare.CloudFlare(raw=True)
cloudflare_records = {}
page_number = 0
zone_id = _get_zone_id_by_name(domain_name)
while True:
page_number += 1
raw_results = cf.zones.dns_records.get(zone_id,
params={
'page': page_number,
'per_page': 100
})
raw_records = raw_results['result']
for dns_record in raw_records:
cloudflare_records[dns_record['id']] = {
'content': dns_record['content'],
'name': dns_record['name'],
'proxied': dns_record['proxied'],
'ttl': dns_record['ttl'],
'type': dns_record['type']
}
total_pages = raw_results['result_info']['total_pages']
if page_number == total_pages:
break
return cloudflare_records
def api_to_login(request):
try:
email = request.POST.get('usermail')
cf = CloudFlare.CloudFlare(email, request.POST.get('user_api_key'))
response = cf.user.get()
if response['email'] == email:
request.session['is_login'] = True
request.session['user_mail'] = request.POST.get('usermail')
request.session['language'] = request.POST.get('language')
request.session['user_api_key'] = request.POST.get('user_api_key')
request.session.save()
succ_info = json.dumps({"result": "success", "msg": 'none'})
return HttpResponse(succ_info)
else:
err_info = json.dumps({
"result": "error",
"msg": "error,please check your input"
})
return HttpResponse(err_info)
except CloudFlare.exceptions.CloudFlareAPIError as e:
err_info = json.dumps({
"result": "error",
"msg": "error,please check your input"
})
return HttpResponse(err_info)
except Exception as e:
return HttpResponse(err_info)
def allocate_instances(instance_num,
batch_id,
image_tag,
task_name,
timeout=-1,
cf_email="*****@*****.**"):
instance_ips, instance_ids = request_instance(instance_num, image_tag,
task_name, timeout, batch_id)
if os.getenv("CLOUDFLARE_TOKEN") and os.getenv("CLOUDFLARE_ZONE_ID"):
logging.info("registering subdomains on craftassist.io")
cloudflare_token = os.getenv("CLOUDFLARE_TOKEN")
zone_id = os.getenv("CLOUDFLARE_ZONE_ID")
cf = CloudFlare.CloudFlare(email=cf_email, token=cloudflare_token)
dns_records = cf.zones.dns_records.get(zone_id)
# Write the subdomains and batch IDs to input CSV for Mephisto
# CSV file headers
headers = ["subdomain", "batch"]
with open("../../crowdsourcing/droidlet_static_html_task/data.csv",
"w") as fd:
csv_writer = csv.writer(fd, delimiter=",")
csv_writer.writerow(headers)
for x in range(len(instance_ips)):
ip = instance_ips[x]
subdomain = "dashboard-{}-{}".format(batch_id, x)
register_dashboard_subdomain(cf, zone_id, ip, subdomain)
# Write record to Mephisto task input CSV
csv_writer.writerow([subdomain, batch_id])
return instance_ips, instance_ids
def addUser(self):
CLOUDFLARE_TOKEN = Token.objects.values().get(
key='CLOUDFLARE_TOKEN')['value']
CLOUDFLARE_ZONE_ID = Token.objects.values().get(
key='CLOUDFLARE_ZONE_ID')['value']
cf = CloudFlare.CloudFlare(email=EMAIL_USER, token=CLOUDFLARE_TOKEN)
records = cf.zones.dns_records.get(CLOUDFLARE_ZONE_ID,
params={'per_page': 50})
for record in records:
if record['type'] == 'TXT' and record[
'name'] == 'amfoss.in' and record['content'].startswith(
'forward-email'):
newContent = record[
'content'] + ", " + self.customEmail + ":" + self.email
if len(newContent) < 255:
dns_record = {
'name': record['name'],
'type': record['type'],
'content': newContent,
'proxied': record['proxied']
}
try:
dns_record = cf.zones.dns_records.put(
CLOUDFLARE_ZONE_ID, record['id'], data=dns_record)
except CloudFlare.exceptions.CloudFlareAPIError as e:
pass
break
def createCF(customer, eip):
print "Create record:", customer
new_record = {
'type': "A",
'content': eip,
'name': customer,
}
zone_name = "sisense.com"
cf = CloudFlare.CloudFlare(email=cfuser, token=cfpassword)
zones = cf.zones.get(params={'name': zone_name})
zone_id = zones[0]['id']
zone_name = zones[0]['name']
print zone_id, zone_name
dns_records = cf.zones.dns_records.get(
zone_id, params={'name': customer + '.' + zone_name})
if dns_records:
print "already exists", customer
else:
try:
r = cf.zones.dns_records.post(zone_id, data=new_record)
print "created", r['id']
return (r['id'])
except Exception as e:
print e
return (False)
def get_dns_records():
cf = CloudFlare.CloudFlare(raw=True)
zones = get_domains()
records = []
for zone in zones:
zone_id = zone['id']
page_number = 0
while True:
page_number += 1
raw_results = cf.zones.dns_records.get(zone_id,
params={
'per_page': 200,
'page': page_number
})
# Add account_id for opening browser
result = map(
lambda item: dict(item, account_id=zone['account']['id']),
raw_results['result'])
# Filter by record type
records += filter(lambda x: x['type'] in ["CNAME", "A"], result)
records += result
total_pages = raw_results['result_info']['total_pages']
if page_number == total_pages:
break
return records
def lambda_handler(event, context):
config = init_cfg()
logger = setup_logging(config['EXEC_log_level'])
stun_source_list = config['EXEC_stun_source'].split(',')
logger.info(stun_source_list)
IP_list = getIPx(config['EXEC_stun_destination'])
if not IP_list:
logger.error('DNS dig error')
return False
logger.info(IP_list)
if IP_list:
i = 0
for ip in IP_list:
logger.warning(ip)
if not check_stun(ip)[1]:
logger.info(
'stun IP is not in ative state - lets remove it from DNS')
new_IP = get_stun_ip(logger, config, IP_list, stun_source_list)
logger.info(new_IP)
if new_IP:
IP_list[i] = new_IP
i = i + 1
logger.warning(IP_list)
cf = CloudFlare.CloudFlare(token=config['EXEC_CF_API_token'])
cf_DNS_update(logger, config, cf, IP_list)
return
def __init__(self, email, token):
''' Main class constructor.
:param email [Cloudflare registration email]
:param token [Cloudflare Global API token]
'''
self.cloudflare_api = CloudFlare.CloudFlare(email=email, token=token)
self.zones = self.__get_zones()
def get_settings(zone_id):
cf = CloudFlare.CloudFlare()
result = []
zones = get_all_zones()
# there should only be one zone
for zone in zones:
if zone['id'] == zone_id:
zone_name = zone['name']
break
settings = handle_api_call(cf.zones.settings.get, zone_id)
curr_setting = []
for setting in settings:
name = setting['id']
value = setting['value']
editable = setting['editable']
curr_setting.append({
'name': name,
'value': value,
'editable': editable
})
result.append({
'zone_id': zone_id,
'zone_name': zone_name,
'settings': curr_setting
})
return result
def update_cloudflare(hostname, ipaddr):
# print("In update")
params = {'name': CFZONE, 'per_page': 1}
cf = CloudFlare.CloudFlare()
try:
# print(params)
zones = cf.zones.get(params=params)
except CloudFlare.exceptions.CloudFlareAPIError as e:
exit('/zones.get %d %s - api call failed' % (e, e))
except Exception as e:
exit('/zones - %s - api call failed' % (e))
# zone_name = zones[0]['name']
zone_id = zones[0]['id']
dns_record = [{'name': hostname, 'type': 'A', 'content': ipaddr}]
try:
r = cf.zones.dns_records.put(zone_id, data=dns_record)
except CloudFlare.exceptions.CloudFlareAPIError as e:
exit('/zones.post %d %s - api call failed' % (e, e))
except Exception as e:
exit('/zones - %s - api call failed' % (e))
print(r)
return
def get_dns_records(zone_id):
cf = CloudFlare.CloudFlare()
result = []
# dns_records = cf.zones.dns_records.export.get(zone_id)
# if len(zones) != 1:
# return('/zones.get - %s - api call returned %d items' % (zone_name, len(zones)))
# # there should only be one zone
# zone = zones[0]
# zone_name = zone['name']
# zone_id = zone['id']
# print("Zone:\t%s %s" % (zone_id, zone_name))
# params = {'name': dns_name}
dns_records = cf.zones.dns_records.get(zone_id)
if len(dns_records) == 0:
return ('/zones.dns_records.get - %s - no records found' % (dns_name))
for dns_record in dns_records:
# print(dns_record)
result.append({
'zone_id': dns_record['zone_id'],
'id': dns_record['id'],
'name': dns_record['name'],
'type': dns_record['type'],
'content': dns_record['content'],
'ttl': dns_record['ttl'],
'proxied': dns_record['proxied'],
'proxiable': dns_record['proxiable']
})
return result
def __init__(self, config):
super(CloudflareBaseAction, self).__init__(config)
self.api_key = self.config.get('api_key')
self.api_email = self.config.get('api_email')
self.client = CloudFlare.CloudFlare(email=self.api_email,
token=self.api_key,
raw=True)
def update_record(zone_name, record_name, record_type, record_address):
CLOUDFLARE_API_TOKEN = os.environ["CLOUDFLARE_TOKEN"]
cf = CloudFlare.CloudFlare(token=CLOUDFLARE_API_TOKEN)
record = {
"name": record_name,
"type": record_type,
"content": record_address,
"ttl": 1,
"proxied": False,
}
zone_id = None
for zone in cf.zones.get():
if zone["name"] == zone_name:
zone_id = zone["id"]
break
else:
raise ValueError(f"Cloudflare zone {zone_name} not found")
for _record in cf.zones.dns_records.get(zone_id):
if _record["name"] == record_name:
logger.info(
f"record name={record_name} type={record_type} address={record_address} already exists updating"
)
cf.zones.dns_records.put(zone_id, _record["id"], data=_record)
break
else:
logger.info(
f"record name={record_name} type={record_type} address={record_address} does not exists creating"
)
cf.zones.dns_records.post(zone_id, data=record)
def main():
cf = CloudFlare.CloudFlare(raw=True)
page_number = 0
while True:
try:
raw_results = cf.zones.get(params={
'per_page': 5,
'page': page_number
})
except CloudFlare.exceptions.CloudFlareAPIError as e:
exit('/zones.get %d %s - api call failed' % (e, e))
zones = raw_results['result']
domains = []
for zone in zones:
zone_id = zone['id']
zone_name = zone['name']
domains.append(zone_name)
count = raw_results['result_info']['count']
page = raw_results['result_info']['page']
per_page = raw_results['result_info']['per_page']
total_count = raw_results['result_info']['total_count']
total_pages = raw_results['result_info']['total_pages']
print "COUNT=%d PAGE=%d PER_PAGE=%d TOTAL_COUNT=%d TOTAL_PAGES=%d -- %s" % (
count, page, per_page, total_count, total_pages, domains)
if page_number == total_pages:
break
page_number += 1
def run(self):
if tinify.key != None:
# If aws keys are available, use them to fetch the image and write back
if aws_key_id and aws_secret and aws_bucket and aws_region:
source_url_http = urlparse(StaticNode.handle_simple(
self.instance.file.name),
scheme='http').geturl()
source_url_https = urlparse(StaticNode.handle_simple(
self.instance.file.name),
scheme='https').geturl()
source = tinify.from_url(source_url_https)
path = "%s/%s" % (aws_bucket, self.instance.file.name)
source.store(service='s3',
aws_access_key_id=aws_key_id,
aws_secret_access_key=aws_secret,
region=aws_region,
path=path)
if cf_zone_id and cf_api_key and cf_api_email:
cf = CloudFlare.CloudFlare()
cf.zones.purge_cache.delete(
cf_zone_id,
data={'files': [source_url_http, source_url_https]})
# Else we grab the local image, optimize it and override the local file
else:
path = os.getcwd() + self.instance.url
source = tinify.from_file(path)
source.to_file(path)
else:
print "No tinify key"
def domain_get_first(request):
try:
if not user_cf_auth(request):
return redirect('/')
print(request.session['language'])
cf = CloudFlare.CloudFlare(request.session['user_mail'],
request.session['user_api_key'])
zones = cf.zones.get()
if len(zones):
request.session['account_id'] = zones[0]['account']['id']
else:
zones = 0
return render(
request, 'forms.html', {
"zones": zones,
"user_name": request.session['user_mail'],
"lang": request.session['language']
})
except CloudFlare.exceptions.CloudFlareAPIError as e:
return HttpResponse(
'/zones.get %d %s - api call failed, Please try it in a while' %
(e, e))
except Exception as e:
return HttpResponse(
'/zones.get - %s - api call failed, Please try it in a while' %
(e))
def main(domain, name, record_type, ip_url):
cf = CloudFlare.CloudFlare()
zones = cf.zones.get()
# Find the zone id of the domain we want to update
for zone in zones:
if zone["name"] == domain:
zone_id = zone["id"]
break
else:
exit("Zone with name {} not found".format(domain))
dns_record = {
"name": name,
"type": record_type,
"content": get_ip(ip_url),
"proxied": False
# leave TTL at default
}
records = cf.zones.dns_records.get(zone_id)
# Update the record
for record in records:
if record["name"] == name:
record_id = record["id"]
cf.zones.dns_records.put(zone_id, record_id, data=dns_record)
break
# If the record doesn't exist yet, we should create it
else:
print("Created new record for {}".format(name))
cf.zones.dns_records.post(zone_id, data=dns_record)
def delete_type_CNAME_record(domain, **kwargs):
"""
Delete CNAME record to domain
:param domain: domain which will have been deleted
:param dict kwargs: additional params such as email and
token and certtoken for access to Cloudflare API
:return: None
"""
sub_domain, _, main_domain = domain.partition('.')
cf = CloudFlare.CloudFlare(**kwargs)
try:
zone = cf.zones.get(params={'name': main_domain})[0]
except IndexError:
return
for dns_record in cf.zones.dns_records.get(zone['id'], params={
'type': 'CNAME',
'name': domain
}):
cf.zones.dns_records.delete(
zone['id'],
dns_record['id']
)
def main():
# Get current IP address
ip = get_ip()
# Connect to Cloudflare
cf = CloudFlare.CloudFlare()
# Get zones
record_name = os.environ['CF_RECORD_NAME']
zone_name = record_name.split(".")[-2:]
zone_name = zone_name[0] + '.' + zone_name[1]
zone = get_zone(cf, zone_name)
# Get records
if zone:
record = get_record(cf, zone, record_name)
else:
print("No zones found for", zone_name)
exit(1)
# Update A records with new IP
if record and ip:
update_record(cf, record, ip)
else:
print("No records found for", record_name)
exit(1)
