def load_droplets_from_digital_ocean(self):
''' Use dopy to get droplet information from DigitalOcean and save data in cache files '''
manager = DoManager(self.client_id, self.api_key)
self.data['droplets'] = self.sanitize_list(manager.all_active_droplets())
self.index['host_to_droplet'] = self.build_index(self.data['droplets'], 'ip_address', 'id', False)
self.build_inventory()
self.write_to_cache()
def execute(self):
selected_region = self.region
api_key = os.getenv('DIGITALOCEAN_TOKEN')
client = DoManager(None, api_key, 2)
if not self.instance_families:
instances = [
item["slug"] for item in client.sizes()
if selected_region in item["regions"]
]
else:
selected_family = self.instance_families
instances = [
instance for instance in [
item["slug"].split("-", 1) for item in client.sizes()
if selected_region in item["regions"]
] if len(instance) > 1 if instance[0] in selected_family
]
instances.sort()
instances = ['-'.join([s[0], s[1]]) for s in instances]
return instances
def __init__(self):
super(DigitalOceanProvider, self).__init__(self.NAME, DOGeneral, DOExt)
if (not self.env.initialized) or (not self.env.general) or (not self.env.general.api_token):
g = self._input_general_env_conf()
else:
g = self.env.general
self.manager = DoManager(None, g.api_token, api_version=2)
def load_all_data_from_digital_ocean(self):
''' Use dopy to get all the information from DigitalOcean and save data in cache files '''
manager = DoManager(self.client_id, self.api_key)
self.data = {}
self.data['droplets'] = self.sanitize_list(
manager.all_active_droplets())
self.data['regions'] = self.sanitize_list(manager.all_regions())
self.data['images'] = self.sanitize_list(
manager.all_images(filter=None))
self.data['sizes'] = self.sanitize_list(manager.sizes())
self.data['ssh_keys'] = self.sanitize_list(manager.all_ssh_keys())
self.data['domains'] = self.sanitize_list(manager.all_domains())
self.index = {}
self.index['region_to_name'] = self.build_index(
self.data['regions'], 'id', 'name')
self.index['size_to_name'] = self.build_index(self.data['sizes'], 'id',
'name')
self.index['image_to_name'] = self.build_index(self.data['images'],
'id', 'name')
self.index['image_to_distro'] = self.build_index(
self.data['images'], 'id', 'distribution')
self.index['host_to_droplet'] = self.build_index(
self.data['droplets'], 'ip_address', 'id', False)
self.build_inventory()
self.write_to_cache()
def execute(self):
api_key = os.getenv('DIGITALOCEAN_TOKEN')
client = DoManager(None, api_key, 2)
regions = [region["slug"] for region in client.all_regions()]
return regions
def load_droplets_from_digital_ocean(self):
''' Use dopy to get droplet information from DigitalOcean and save data in cache files '''
manager = DoManager(None, self.access_token, api_version=2)
self.data['droplets'] = manager.all_active_droplets()
self.index['host_to_droplet'] = self.build_index(
self.data['droplets'], 'ip_address', 'id', False)
self.build_inventory()
self.write_to_cache()
def load_droplet_variables_for_host(self):
'''Generate a JSON reponse to a --host call'''
host = self.to_safe(str(self.args.host))
if not host in self.index['host_to_droplet']:
# try updating cache
if not self.args.force_cache:
self.load_all_data_from_digital_ocean()
if not host in self.index['host_to_droplet']:
# host might not exist anymore
return {}
droplet = None
if self.cache_refreshed:
for drop in self.data['droplets']:
if drop['ip_address'] == host:
droplet = self.sanitize_dict(drop)
break
else:
# Cache wasn't refreshed this run, so hit DigitalOcean API
manager = DoManager(self.client_id, self.api_key)
droplet_id = self.index['host_to_droplet'][host]
droplet = self.sanitize_dict(manager.show_droplet(droplet_id))
if not droplet:
return {}
# Put all the information in a 'do_' namespace
info = {}
for k, v in droplet.items():
info['do_' + k] = v
# Generate user-friendly variables (i.e. not the ID's)
if droplet.has_key('region_id'):
info['do_region'] = self.index['region_to_name'].get(
droplet['region_id'])
if droplet.has_key('size_id'):
info['do_size'] = self.index['size_to_name'].get(
droplet['size_id'])
if droplet.has_key('image_id'):
info['do_image'] = self.index['image_to_name'].get(
droplet['image_id'])
info['do_distro'] = self.index['image_to_distro'].get(
droplet['image_id'])
return info
def __init__(self):
''' Main execution path '''
# DigitalOceanInventory data
self.data = {} # All DigitalOcean data
self.inventory = {} # Ansible Inventory
# Define defaults
self.cache_path = '.'
self.cache_max_age = 0
self.use_private_network = False
self.group_variables = {}
# Read settings, environment variables, and CLI arguments
self.read_settings()
self.read_environment()
self.read_cli_args()
# Verify credentials were set
if not hasattr(self, 'api_token'):
sys.stderr.write(
'''Could not find values for DigitalOcean api_token.
They must be specified via either ini file, command line argument (--api-token),
or environment variables (DO_API_TOKEN)\n''')
sys.exit(-1)
# env command, show DigitalOcean credentials
if self.args.env:
print("DO_API_TOKEN=%s" % self.api_token)
sys.exit(0)
# Manage cache
self.cache_filename = self.cache_path + "/ansible-digital_ocean.cache"
self.cache_refreshed = False
if self.is_cache_valid():
self.load_from_cache()
if len(self.data) == 0:
if self.args.force_cache:
sys.stderr.write(
'''Cache is empty and --force-cache was specified\n''')
sys.exit(-1)
self.manager = DoManager(None, self.api_token, api_version=2)
# Pick the json_data to print based on the CLI command
if self.args.droplets:
self.load_from_digital_ocean('droplets')
json_data = {'droplets': self.data['droplets']}
elif self.args.regions:
self.load_from_digital_ocean('regions')
json_data = {'regions': self.data['regions']}
elif self.args.images:
self.load_from_digital_ocean('images')
json_data = {'images': self.data['images']}
elif self.args.sizes:
self.load_from_digital_ocean('sizes')
json_data = {'sizes': self.data['sizes']}
elif self.args.ssh_keys:
self.load_from_digital_ocean('ssh_keys')
json_data = {'ssh_keys': self.data['ssh_keys']}
elif self.args.domains:
self.load_from_digital_ocean('domains')
json_data = {'domains': self.data['domains']}
elif self.args.all:
self.load_from_digital_ocean()
json_data = self.data
elif self.args.host:
json_data = self.load_droplet_variables_for_host()
else: # '--list' this is last to make it default
self.load_from_digital_ocean('droplets')
self.build_inventory()
json_data = self.inventory
if self.cache_refreshed:
self.write_to_cache()
if self.args.pretty:
print(json.dumps(json_data, sort_keys=True, indent=2))
else:
print(json.dumps(json_data))
def setup(cls, api_token):
cls.manager = DoManager(None, api_token, api_version=2)
from os import getenv
from dopy.manager import DoManager
NAME = "serenata-update"
def destroy_droplet(manager):
droplet_id = None
for droplet in manager.all_active_droplets():
if droplet["name"] == NAME:
droplet_id = droplet["id"]
break
if not droplet_id:
print("Droplet {} not found.".format(NAME))
return
output = manager.destroy_droplet(droplet_id)
print("Droplet {} ({}) deleted.".format(NAME, droplet_id))
return output
if __name__ == "__main__":
manager = DoManager(None, getenv("DO_API_TOKEN"), api_version=2)
destroy_droplet(manager)
def setup(cls, api_token):
cls.manager = DoManager(None, api_token, api_version=2)
DomainRecord.manager = cls.manager
def setup(cls, client_id, api_key):
cls.manager = DoManager(client_id, api_key)
def setup(cls, client_id, api_key):
cls.manager = DoManager(client_id, api_key)
DomainRecord.manager = cls.manager
def setup_manager_hook(app): global manager manager = DoManager(None, token, api_version=2)
def __init__(self, credentials):
super().__init__(credentials)
self.name = 'DigitalOcean'
self.do_session = DoManager(None, self.access_key, api_version=2)
"""
dependencias:
sudo pip install dopy pyopenssl ndg-httpsclient pyasn1
"""
import os
from dopy.manager import DoManager
import urllib3.contrib.pyopenssl
urllib3.contrib.pyopenssl.inject_into_urllib3()
cliend_id = os.getenv("DO_CLIENT_ID")
api_key = os.getenv("DO_API_KEY")
do = DoManager(cliend_id, api_key)
keys = do.all_ssh_keys()
print "Nome da chave ssh\tid"
for key in keys:
print "%s\t%d" % (key["name"], key["id"])
print "Nome da imagem\tid"
imgs = do.all_images()
for img in imgs:
if img["slug"] == "ubuntu-14-04-x64":
print "%s\t%d" % (img["name"], img["id"])
print "Nome da regiao\tid"
regions = do.all_regions()
for region in regions:
if region["slug"] == "nyc2":
print "%s\t%d" % (region["slug"], region["id"])
logger = logging.getLogger("game_events")
logging.basicConfig(level=logging.INFO)
# Configures logging.
client = discord.Client(loop=loop)
# Defines the Discord client.
config = yaml.load(
open("config.yaml", "r")
)
# Loads the config.
do_client = DoManager(
None,
config["DIGITALOCEAN_API_KEY"],
api_version=2
)
# Defines the DigitalOcean client.
class BrandedEmbed(discord.Embed):
def __init__(self, user, **kwargs):
super().__init__(**kwargs)
self.set_author(
name=user.name,
icon_url=user.avatar_url
)
self.set_footer(
text=f"{client.user.name} - Created by JakeMakesStuff#0001"
)
