def create_dns_record(my_token: str, record_name: str,
ip_address: str) -> None:
domain = digitalocean.Domain(token=my_token, name="zulipdev.org")
domain.load()
records = domain.get_records()
delete_existing_records(records, record_name)
wildcard_name = "*." + record_name
delete_existing_records(records, wildcard_name)
print(
f"Creating new A record for {record_name}.zulipdev.org that points to {ip_address}."
)
domain.create_new_domain_record(type="A",
name=record_name,
data=ip_address)
print(
f"Creating new A record for *.{record_name}.zulipdev.org that points to {ip_address}."
)
domain.create_new_domain_record(type="A",
name=wildcard_name,
data=ip_address)
def test_create(self):
data = self.load_from_file('domains/create.json')
url = self.base_url + "domains"
responses.add(responses.POST,
url,
body=data,
status=201,
content_type='application/json')
domain = digitalocean.Domain(name="example.com",
ip_address="1.1.1.1",
token=self.token).create()
self.assert_url_query_equal(responses.calls[0].request.url,
self.base_url + "domains")
self.assertEqual(json.loads(responses.calls[0].request.body), {
'ip_address': '1.1.1.1',
'name': 'example.com'
})
self.assertEqual(domain['domain']['name'], "example.com")
self.assertEqual(domain['domain']['ttl'], 1800)
import digital_ocean_info
trash = digital_ocean_info.domain_name
trash = digital_ocean_info.record_name
trash = digital_ocean_info.token
except ImportError or AttributeError:
# noinspection SpellCheckingInspection
print('Please make sure you have a file called "digital_ocean_info.py"\n'
'With a variable the string variables: domain_name, record_name, and token \n'
'Example:\n'
'domain_name = "mydomain.com"',
'record_name = "vpn"',
'token = "54321abcdigitaloceantoken12345etc"')
digital_ocean_info = 'keeping pycharm happy :)'
exit(1)
domain = digitalocean.Domain(token=digital_ocean_info.token,
name=digital_ocean_info.domain_name)
records = domain.get_records()
dir_path = os.path.dirname(os.path.realpath(__file__))
res = subprocess.check_output([os.path.join(dir_path, 'get_ip.sh')])
external_ip = res.decode('utf-8').replace('"', '').replace('\n', '')
print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print('my external ip: {0}'.format(external_ip))
for record in records:
if record.name == digital_ocean_info.record_name:
print('current ip in record: {0}'.format(record.data))
record.data = external_ip
def setUp(self):
super(TestDomain, self).setUp()
self.domain = digitalocean.Domain(name='example.com', token=self.token)
config = get_config()
api_token = config["digitalocean"]["api_token"]
seen_ips = set()
if not args.force:
print("WOULD DELETE:")
manager = digitalocean.Manager(token=api_token)
my_droplets = manager.get_all_droplets()
for droplet in my_droplets:
seen_ips.add(droplet.ip_address)
if droplet.ipv6:
seen_ips.update(net["ip_address"]
for net in droplet.networks["v6"])
domain = digitalocean.Domain(token=api_token, name="zulipdev.org")
domain.load()
records = domain.get_records()
for record in sorted(records,
key=lambda e: ".".join(reversed(e.name.split(".")))):
if record.type not in ("AAAA", "A"):
continue
elif record.data in seen_ips:
continue
else:
print(f"{record.type} {record.name} = {record.data}")
if args.force:
record.destroy()
if not args.force:
def create_dns_record(my_token, username, ip_address):
print("Creating A record for {0}.zulipdev.org that points to {1}.".format(
username, ip_address))
domain = digitalocean.Domain(token=my_token, name='zulipdev.org')
domain.load()
domain.create_new_domain_record(type='A', name=username, data=ip_address)
def assign_domain(self, domain_name):
domain = digitalocean.Domain(token=DO_TOKEN, name=DO_DOMAIN)
domain.create_new_domain_record(type='A', name=domain_name, data=self.ip_address)
print(" - {}".format(droplet.name))
if "slave" in droplet.name:
slaves_ip.append(droplet.ip_address)
elif "local" in droplet.name:
local_ip = droplet.ip_address
f.write("\n[local]\n{}\n".format(droplet.ip_address))
my_droplets = manager.get_all_droplets()
f.write("\n[slaves]\n")
for ip in slaves_ip:
f.write("{}\n".format(ip))
f.write("\n[swarm]\n")
f.write("{}\n".format(local_ip))
for ip in slaves_ip:
f.write("{}\n".format(ip))
f.close()
domain = digitalocean.Domain(token=TOKEN)
domain.name = "ayoubensalem.com"
domain.ip_address = local_ip
try:
d = domain.create()
except Exception as e:
print(e)
print("=> ayoubensalem.com domain has been created.")
domain.create_new_domain_record(type="A", name="docker", data=local_ip)
print("=> docker.ayoubensalem.com domain has been created. ")
'''
manager = digitalocean.Manager(token=token)
keys = manager.get_all_sshkeys()
droplet = digitalocean.Droplet(token=token,
name='DropletWithSSHKeys',
region='blr1',
image='ubuntu-16-04-x64',
size_slug='1gb',
ssh_keys=keys,
backups=False)
droplet.create()
actions = droplet.get_actions()
for action in actions:
print "Droplet in Progress"
if action.wait():
print "Droplet Created"
my_droplets = manager.get_all_droplets()
index = len(my_droplets) - 1
domain = digitalocean.Domain(name='example.in',
ip_address=my_droplets[index].ip_address,
token=token)
domain.create()
domain.create_new_domain_record(type='CNAME', name='www', data='@')
'''
my_droplets = manager.get_all_droplets()
domain = digitalocean.Domain(name='example.in', ip_address=my_droplets[1].ip_address,token=token)
print "%s,%s"% (domain.name,domain.ip_address)
domain.create()
'''
# Load environment, raise error if not specified
if os.path.isfile("../.env"):
dotenv.load_dotenv()
DO_TOKEN = os.getenv("DO_TOKEN")
DO_DOMAIN = os.getenv("DO_DOMAIN")
IP_TOKEN = os.getenv("IP_TOKEN")
if not bool(DO_TOKEN and DO_DOMAIN):
logging.error("DO_TOKEN and DO_DOMAIN environment variables are required")
raise SystemExit
# Configure validation
R_IPV4 = re.compile(r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$")
# Instantiate app
IP_HANDLER = ipinfo.getHandler(IP_TOKEN)
DOMAIN = digitalocean.Domain(token=DO_TOKEN, name=DO_DOMAIN)
def main():
logging.info("Update started")
# Try to get current IP
try:
ip_address = IP_HANDLER.getDetails().ip
except Exception as e:
logging.error(e)
return None
# Validate IP address
if R_IPV4.match(ip_address) is None:
logging.error(f"{ip_address} is not a valid IP")
def __init__(self, token, domain_name, hostname='@'):
self._domain = digitalocean.Domain(token=token, name=domain_name)
self.hostname = hostname
def dnsrm(domain, subdomain=False, record_type='A'):
if hostproviders[env.host_string] == 'rackspace-cloud':
try:
dom = cdns.find(name=domain)
except exc.NotFound as e:
print "That domain (" + domain + ") wasn't found!"
sys.exit()
if subdomain:
try:
rec = dom.find_record(record_type, name=subdomain)
rec.delete()
except exc.NotFound as e:
print "That record wasn't found... ", e
hprint("This is not a toy!")
sys.exit()
else:
dom.delete()
elif hostproviders[env.host_string] == 'digitalocean':
try:
manager = digitalocean.Manager(
client_id=keychain['digitaloceanuser'],
api_key=keychain['digitaloceanapikey'])
response = manager.get_all_domains()
domainid = [item.id for item in response if item.name == domain]
if len(domainid) > 1:
eprint(
'Major problem, we got more than one matching domain ID back from DO!'
)
elif len(domainid) == 1:
try:
domainid = domainid[0]
domain_object = digitalocean.Domain(
client_id=keychain['digitaloceanuser'],
api_key=keychain['digitaloceanapikey'],
id=domainid)
if subdomain:
response = domain_object.get_records()
record_id = [
item.id for item in response
if item.name + '.' == subdomain
]
if len(record_id) > 1:
eprint(
'Major problem, we got more than one matching domain record ID back from DO!'
)
elif len(record_id) == 1:
record_object = digitalocean.Record(
client_id=keychain['digitaloceanuser'],
api_key=keychain['digitaloceanapikey'],
domain_id=domainid,
id=record_id[0])
record_object.destroy()
hprint("Removed subdomain: " + subdomain +
" from domain: " + domain +
" from Digital Ocean DNS")
else:
eprint("Couldn't find that subdomain captain!")
else:
domain_object.destroy()
hprint("Removed domain: " + domain + " with ID of: " +
str(domainid) + " from Digital Ocean DNS")
except Exception as e:
print "Domain could not be removed from DO:", e
else:
print "This domain was not found on DO:", domain
except Exception as e:
print "Domain could not be retrieved from DO:", e
def dnsmk(domain, subdomain=False, location=False, recordtype='A'):
if not location:
location = gethostipbyhost(nicenametohost(env.host_string))
elif location in hostaliases:
location = gethostipbyhost(nicenametohost(location))
if hostproviders[env.host_string] == 'rackspace-cloud':
if subdomain and subdomain != domain:
print "Creating RackSpace DNS record in " + domain + " for " + subdomain + " at " + location + " type: " + recordtype
try:
dom = cdns.find(name=domain)
except exc.NotFound:
answer = raw_input(
"The domain '%s' was not found. Do you want to create "
"it? [y/n]" % domain_name)
if not answer.lower().startswith("y"):
sys.exit()
try:
dom = cdns.domain(name=domain,
emailAddress=domain + '@allstruck.com',
ttl=900,
comment="Created while creating " +
subdomain)
except exc.DomainCreationFailed as e:
print "RS Domain creation failed:", e
print "RS Domain created:", dom
print
record = {
"type": recordtype,
"name": subdomain,
"data": location,
"ttl": 7000
}
try:
recs = dom.add_records([record])
print recs
print
except exc.DomainRecordAdditionFailed as e:
print "Subdomain creation failed:", e
else:
record = {
"type": recordtype,
"name": domain,
"data": location,
"ttl": 6000
}
try:
dom = cdns.find(name=domain)
print "Creating main record in " + domain
dom.add_records([record])
print "Added main record to existing domain."
except exc.NotFound as e:
print "Creating root domain " + domain
dom = cdns.create(name=domain,
ttl=300,
emailAddress=domain + '@allstruck.com')
dom.add_records([record])
print "Added domain and main record."
print
elif hostproviders[env.host_string] == 'digitalocean':
domanager = digitalocean.Manager(
client_id=keychain['digitaloceanuser'],
api_key=keychain['digitaloceanapikey'])
dodomains = domanager.get_all_domains()
if subdomain and subdomain != domain:
hprint("Creating Digital Ocean DNS record in " + domain + " for " +
subdomain + " at " + location + " type: " + recordtype)
try:
domainid = [
item.id for item in dodomains if item.name == domain
]
domain_name = [
item.name for item in dodomains
if re.search(item.name, domain + '$')
]
if len(domainid) > 1:
eprint(
'Major problem, we got more than one matching domain ID back from DO!'
)
elif len(domainid) == 1:
try:
domainid = domainid[0]
domain_name = domain_name[0]
hprint('Creating record under ' + domain_name + ': ' +
subdomain)
dorecordmk(domainid, recordtype, location, subdomain)
except Exception as e:
print "Record could not be created on DO:", e
else:
print "This domain was not found on DO:", domain
except Exception as e:
print "Error when pulling existing domain ID", e
else:
hprint("Creating Digital Ocean DNS record for " + domain + " at " +
location + " type: " + recordtype)
try:
domainid = [
item.id for item in dodomains
if re.search(item.name, domain + '\.$')
]
domain_name = [
item.name for item in dodomains
if re.search(item.name, domain + '\.$')
]
if len(domainid) > 1:
eprint(
'Major problem, we got more than one matching domain back from DO!'
)
elif len(domainid) == 1:
try:
domainid = domainid[0]
domain_name = domain_name[0]
subdomain = domain.replace('.' + domain_name, '')
lprint('Auto creating subdomain record under ' +
domain_name + ': ' + subdomain)
dorecordmk(domainid, recordtype, location, subdomain)
except Exception as e:
print "Record could not be created on DO:", e
else:
print "This domain does not appear to be a subdomain of another, going to create a new top level record now..."
try:
lprint("Creating domain " + domain + " at " + location)
domain = digitalocean.Domain(
client_id=keychain['digitaloceanuser'],
api_key=keychain['digitaloceanapikey'],
name=domain,
ip_address=location)
domain.create()
except Exception as e:
print "Domain creation failed:", e
print
except Exception as e:
print "Problem with trying to look for matching domain."
import digitalocean
now = datetime.datetime.now()
datetime = now.strftime("%Y-%m-%d_%H:%M")
with open('./keys.json') as f:
keychain = json.load(f)
pyrax.set_setting("debug", True)
pyrax.set_setting("region", "DFW")
pyrax.set_setting("identity_type", "rackspace")
pyrax.set_credentials(keychain['rackspaceuser'],
keychain['rackspaceapikey'])
cf = pyrax.cloudfiles
cs = pyrax.cloudservers
cdns = pyrax.cloud_dns
dodns = digitalocean.Domain(client_id=keychain['digitaloceanuser'],
api_key=keychain['digitaloceanapikey'])
compute = openstack.compute.Compute(username=keychain['rackspaceuser'],
apikey=keychain['rackspaceapikey'])
dns = clouddns.connection.Connection(keychain['rackspaceuser'],
keychain['rackspaceapikey'])
with open('./host-aliases.json') as f:
hostaliases = json.load(f)
for key, val in enumerate(env.hosts):
env.hosts[key] = hostaliases[val]
with open('./host-providers.json') as f:
hostproviders = json.load(f)
# for key, val in enumerate(env.hosts):
# env.hostproviders[key] = hostproviders[val]
