def __init__(self, key=None, secret=None, endpoint=None):
if key is None or secret is None or endpoint is None:
self._config = read_config()
self._cs = CloudStack(**self._config)
else:
self._cs = CloudStack(key=key, secret=secret, endpoint=endpoint)
self.vms = []
self.zones = []
self.lbs = []
self.tps = []
self.nws = []
self.svs = []
def _connect(self):
api_key = self.module.params.get('api_key')
api_secret = self.module.params.get('secret_key')
api_url = self.module.params.get('api_url')
api_http_method = self.module.params.get('api_http_method')
if api_key and api_secret and api_url:
self.cs = CloudStack(endpoint=api_url,
key=api_key,
secret=api_secret,
method=api_http_method)
else:
self.cs = CloudStack(**read_config())
def test_request_params_casing(self, get):
cs = CloudStack(endpoint='localhost',
key='foo',
secret='bar',
timeout=20)
get.return_value.status_code = 200
get.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
machines = cs.listVirtualMachines(zoneId=2,
templateId='3',
temPlateidd='4')
self.assertEqual(machines, {})
get.assert_called_once_with(
'localhost',
timeout=20,
verify=True,
cert=None,
params={
'apiKey': 'foo',
'response': 'json',
'command': 'listVirtualMachines',
'signature': 'dMRxAZcs2OPK15WUulzUtnrLWD0=',
'templateId': '3',
'temPlateidd': '4',
'zoneId': '2'
},
)
def __init__(self):
tempdict = {}
path = os.path.dirname(os.path.abspath(__file__))
# Read config
try:
f = open(path + "/../cloudstack.config", "r")
config = f.readlines()
except:
print("Somethings wrong with your config file")
sys.exit(2)
for entry in config:
entry = entry.replace("\n", "")
temarray = entry.split("=")
tempdict[temarray[0]] = temarray[1]
if tempdict['verify'] is None:
tempdict['verify'] = False
self.cs = CloudStack(
endpoint=tempdict['endpoint'],
key=tempdict['key'],
secret=tempdict['secret'],
verify=False
)
def test_signature_v3(self, mock):
cs = CloudStack(endpoint='https://localhost',
key='foo',
secret='bar',
expiration=600)
mock.return_value.status_code = 200
mock.return_value.json.return_value = {
'createnetworkresponse': {},
}
cs.createNetwork(name="", display_text="")
self.assertEqual(1, mock.call_count)
[request], _ = mock.call_args
url = urlparse(request.url)
qs = parse_qs(url.query, True)
self.assertEqual('createNetwork', qs['command'][0])
self.assertEqual('3', qs['signatureVersion'][0])
expires = qs['expires'][0]
# we ignore the timezone for Python2's lack of %z
expires = datetime.datetime.strptime(expires[:19], EXPIRES_FORMAT[:-2])
self.assertTrue(expires > datetime.datetime.utcnow(), expires)
def test_transform_empty(self, mock):
cs = CloudStack(endpoint='https://localhost',
key='foo',
secret='bar',
expiration=-1)
mock.return_value.status_code = 200
mock.return_value.json.return_value = {
'createnetworkresponse': {},
}
cs.createNetwork(name="", display_text="")
self.assertEqual(1, mock.call_count)
[request], kwargs = mock.call_args
self.assertEqual(dict(cert=None, timeout=10, verify=True), kwargs)
self.assertEqual('GET', request.method)
self.assertFalse(request.headers)
url = urlparse(request.url)
qs = parse_qs(url.query, True)
self.assertEqual('createNetwork', qs['command'][0])
self.assertEqual('CistTEiPt/4Rv1v4qSyILvPbhmg=', qs['signature'][0])
self.assertEqual('', qs['name'][0])
self.assertEqual('', qs['display_text'][0])
def test_method(self, mock):
cs = CloudStack(endpoint='https://localhost',
key='foo',
secret='bar',
method='post',
expiration=-1)
mock.return_value.status_code = 200
mock.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
cs.listVirtualMachines(blah='brah')
self.assertEqual(1, mock.call_count)
[request], kwargs = mock.call_args
self.assertEqual(dict(cert=None, timeout=10, verify=True), kwargs)
self.assertEqual('POST', request.method)
self.assertEqual('application/x-www-form-urlencoded',
request.headers['Content-Type'])
qs = parse_qs(request.body, True)
self.assertEqual('listVirtualMachines', qs['command'][0])
self.assertEqual('58VvLSaVUqHnG9DhXNOAiDFwBoA=', qs['signature'][0])
self.assertEqual('brah', qs['blah'][0])
def test_transform_dict(self, mock):
cs = CloudStack(endpoint='https://localhost',
key='foo',
secret='bar',
expiration=-1)
mock.return_value.status_code = 200
mock.return_value.json.return_value = {
'scalevirtualmachineresponse': {},
}
cs.scaleVirtualMachine(id='a',
details={
'cpunumber': 1000,
'memory': '640k'
})
self.assertEqual(1, mock.call_count)
[request], kwargs = mock.call_args
self.assertEqual(dict(cert=None, timeout=10, verify=True), kwargs)
self.assertEqual('GET', request.method)
self.assertFalse(request.headers)
url = urlparse(request.url)
qs = parse_qs(url.query, True)
self.assertEqual('scaleVirtualMachine', qs['command'][0])
self.assertEqual('ZNl66z3gFhnsx2Eo3vvCIM0kAgI=', qs['signature'][0])
self.assertEqual('1000', qs['details[0].cpunumber'][0])
self.assertEqual('640k', qs['details[0].memory'][0])
def test_transform(self, mock):
cs = CloudStack(endpoint='https://localhost',
key='foo',
secret='bar',
expiration=-1)
mock.return_value.status_code = 200
mock.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
cs.listVirtualMachines(foo=["foo", "bar"],
bar=[{
'baz': 'blah',
'foo': 1000
}],
bytes_param=b'blah')
self.assertEqual(1, mock.call_count)
[request], kwargs = mock.call_args
self.assertEqual(dict(cert=None, timeout=10, verify=True), kwargs)
self.assertEqual('GET', request.method)
self.assertFalse(request.headers)
url = urlparse(request.url)
qs = parse_qs(url.query, True)
self.assertEqual('listVirtualMachines', qs['command'][0])
self.assertEqual('ImJ/5F0P2RDL7yn4LdLnGcEx5WE=', qs['signature'][0])
self.assertEqual('1000', qs['bar[0].foo'][0])
self.assertEqual('blah', qs['bar[0].baz'][0])
self.assertEqual('blah', qs['bytes_param'][0])
self.assertEqual('foo,bar', qs['foo'][0])
def test_request_params_casing(self, mock):
cs = CloudStack(endpoint='https://localhost',
key='foo',
secret='bar',
timeout=20,
expiration=-1)
mock.return_value.status_code = 200
mock.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
machines = cs.listVirtualMachines(zoneId=2,
templateId='3',
temPlateidd='4',
pageSize='10',
fetch_list=True)
self.assertEqual(machines, [])
self.assertEqual(1, mock.call_count)
[request], kwargs = mock.call_args
self.assertEqual(dict(cert=None, timeout=20, verify=True), kwargs)
self.assertEqual('GET', request.method)
self.assertFalse(request.headers)
url = urlparse(request.url)
qs = parse_qs(url.query, True)
self.assertEqual('listVirtualMachines', qs['command'][0])
self.assertEqual('mMS7XALuGkCXk7kj5SywySku0Z0=', qs['signature'][0])
self.assertEqual('3', qs['templateId'][0])
self.assertEqual('4', qs['temPlateidd'][0])
def test_transformt(self, get):
cs = CloudStack(endpoint='localhost', key='foo', secret='bar')
get.return_value.status_code = 200
get.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
cs.listVirtualMachines(foo=["foo", "bar"],
bar=[{
'baz': 'blah',
'foo': 'meh'
}])
get.assert_called_once_with(
'localhost',
timeout=10,
cert=None,
verify=True,
params={
'command': 'listVirtualMachines',
'response': 'json',
'bar[0].foo': 'meh',
'bar[0].baz': 'blah',
'foo': 'foo,bar',
'apiKey': 'foo',
'signature': 'UGUVEfCOfGfOlqoTj1D2m5adr2g=',
},
)
def cs_list(method, key_name, **kwargs):
timeout = 300
cs = CloudStack(endpoint=API_MONITORS,
key=APIKEY_MONITORS,
secret=SECRET_MONITORS,
timeout=timeout)
querypage = 1
querypagesize = 500
values = getattr(cs, method)(listall='true',
pagesize=querypagesize,
page=querypage,
**kwargs).get(key_name, [])
if len(values) == querypagesize:
all_values = []
query_tmp = values
while len(query_tmp):
all_values.extend(query_tmp)
querypage = querypage + 1
query_tmp = getattr(cs, method)(listall='true',
pagesize=querypagesize,
page=querypage,
**kwargs).get(key_name, [])
values = all_values
return values
def _connect(self):
api_key = self.module.params.get('api_key')
api_secret = self.module.params.get('api_secret')
api_url = self.module.params.get('api_url')
api_http_method = self.module.params.get('api_http_method')
api_timeout = self.module.params.get('api_timeout')
if api_key and api_secret and api_url:
self.cs = CloudStack(endpoint=api_url,
key=api_key,
secret=api_secret,
timeout=api_timeout,
method=api_http_method)
else:
api_region = self.module.params.get('api_region', 'cloudstack')
self.cs = CloudStack(**read_config(api_region))
def test_request_params(self, mock):
cs = CloudStack(endpoint='https://localhost',
key='foo',
secret='bar',
timeout=20,
expiration=-1)
mock.return_value.status_code = 200
mock.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
machines = cs.listVirtualMachines(listall='true',
headers={'Accept-Encoding': 'br'})
self.assertEqual(machines, {})
self.assertEqual(1, mock.call_count)
[request], kwargs = mock.call_args
self.assertEqual(dict(cert=None, timeout=20, verify=True), kwargs)
self.assertEqual('GET', request.method)
self.assertEqual('br', request.headers['Accept-Encoding'])
url = urlparse(request.url)
qs = parse_qs(url.query, True)
self.assertEqual('listVirtualMachines', qs['command'][0])
self.assertEqual('B0d6hBsZTcFVCiioSxzwKA9Pke8=', qs['signature'][0])
self.assertEqual('true', qs['listall'][0])
def test_method(self, get, post):
cs = CloudStack(endpoint='localhost',
key='foo',
secret='bar',
method='post')
post.return_value.status_code = 200
post.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
cs.listVirtualMachines(blah='brah')
self.assertEqual(get.call_args_list, [])
self.assertEqual(post.call_args_list, [
call('localhost',
timeout=10,
verify=True,
cert=None,
headers=None,
data={
'command': 'listVirtualMachines',
'blah': 'brah',
'apiKey': 'foo',
'response': 'json',
'signature': '58VvLSaVUqHnG9DhXNOAiDFwBoA=',
})
])
def __init__(self):
super().__init__()
self.cs = CloudStack(
endpoint="https://api.exoscale.com/compute",
key=os.getenv("EXOSCALE_API_KEY"),
secret=os.getenv("EXOSCALE_API_SECRET"),
)
def main():
""" main :) """
args = prepare_arguments()
if args.name_outputfile is not None:
outputfile = open(args.name_outputfile, 'w')
else:
outputfile = sys.stdout
# Reads ~/.cloudstack.ini
cs = CloudStack(**read_config())
all_nics = collect_nics(cs)
projects_container = cs.listProjects(listall=True)
projects = projects_container["project"]
for project in sorted(projects, key=lambda key: key["name"]):
project_id = project["id"]
all_nics = all_nics + collect_nics(cs, project_id)
# pprint.pprint(all_nics)
filtered_nics = filter_nics(all_nics, args)
# pprint.pprint(filtered_nics)
print_nics(filtered_nics, outputfile)
if args.name_outputfile is not None:
outputfile.close()
def __init__(
self,
key,
secret,
endpoint="https://api.exoscale.com/v1",
max_retries=None,
trace=False,
):
super().__init__(
endpoint=endpoint,
key=key,
secret=secret,
max_retries=max_retries,
trace=trace,
)
self.cs = CloudStack(
key=key,
secret=secret,
endpoint=endpoint,
session=self.session,
headers={**self.session.headers, **{"User-Agent": self.user_agent}},
trace=self.trace,
fetch_result=True,
)
def __init__(self):
super().__init__()
self.cs = CloudStack(
endpoint=os.getenv("CLOUDSTACK_API_ENDPOINT"),
key=os.getenv("CLOUDSTACK_API_KEY"),
secret=os.getenv("CLOUDSTACK_API_SECRET"),
)
def __init__(self):
parser = argparse.ArgumentParser()
parser.add_argument('--host')
parser.add_argument('--list', action='store_true')
parser.add_argument('--project')
options = parser.parse_args()
try:
self.cs = CloudStack(**read_config())
except CloudStackException as e:
print("Error: Could not connect to CloudStack API", file=sys.stderr)
project_id = ''
if options.project:
project_id = self.get_project_id(options.project)
if options.host:
data = self.get_host(options.host)
print(json.dumps(data, indent=2))
elif options.list:
data = self.get_list()
print(json.dumps(data, indent=2))
else:
print("usage: --list | --host <hostname> [--project <project>]",
file=sys.stderr)
sys.exit(1)
def _connect(self):
api_region = self.module.params.get('api_region') or os.environ.get(
'CLOUDSTACK_REGION')
try:
config = read_config(api_region)
except KeyError:
config = {}
api_config = {
'endpoint':
self.module.params.get('api_url') or config.get('endpoint'),
'key':
self.module.params.get('api_key') or config.get('key'),
'secret':
self.module.params.get('api_secret') or config.get('secret'),
'timeout':
self.module.params.get('api_timeout') or config.get('timeout'),
'method':
self.module.params.get('api_http_method') or config.get('method'),
}
self.result.update({
'api_region': api_region,
'api_url': api_config['endpoint'],
'api_key': api_config['key'],
'api_timeout': api_config['timeout'],
'api_http_method': api_config['method'],
})
if not all(
[api_config['endpoint'], api_config['key'], api_config['secret']]):
self.fail_json(msg="Missing api credentials: can not authenticate")
self.cs = CloudStack(**api_config)
def test_transform_dict(self, get):
cs = CloudStack(endpoint='localhost', key='foo', secret='bar')
get.return_value.status_code = 200
get.return_value.json.return_value = {
'scalevirtualmachineresponse': {},
}
cs.scaleVirtualMachine(id='a',
details={
'cpunumber': 1000,
'memory': '640k'
})
get.assert_called_once_with(
'localhost',
timeout=10,
cert=None,
verify=True,
headers=None,
params={
'command': 'scaleVirtualMachine',
'response': 'json',
'id': 'a',
'details[0].cpunumber': '1000',
'details[0].memory': '640k',
'apiKey': 'foo',
'signature': 'ZNl66z3gFhnsx2Eo3vvCIM0kAgI=',
},
)
def test_transform(self, get):
cs = CloudStack(endpoint='localhost', key='foo', secret='bar')
get.return_value.status_code = 200
get.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
cs.listVirtualMachines(foo=["foo", "bar"],
bar=[{
'baz': 'blah',
'foo': 1000
}],
bytes_param=b'blah')
get.assert_called_once_with(
'localhost',
timeout=10,
cert=None,
verify=True,
headers=None,
params={
'command': 'listVirtualMachines',
'response': 'json',
'bar[0].foo': '1000',
'bar[0].baz': 'blah',
'foo': 'foo,bar',
'bytes_param': b'blah',
'apiKey': 'foo',
'signature': 'ImJ/5F0P2RDL7yn4LdLnGcEx5WE=',
},
)
def test_request_params_casing(self, get):
cs = CloudStack(endpoint='localhost',
key='foo',
secret='bar',
timeout=20)
get.return_value.status_code = 200
get.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
machines = cs.listVirtualMachines(zoneId=2,
templateId='3',
temPlateidd='4',
pageSize='10',
fetch_list=True)
self.assertEqual(machines, [])
get.assert_called_once_with(
'localhost',
timeout=20,
verify=True,
cert=None,
headers=None,
params={
'apiKey': 'foo',
'response': 'json',
'command': 'listVirtualMachines',
'signature': 'mMS7XALuGkCXk7kj5SywySku0Z0=',
'templateId': '3',
'temPlateidd': '4',
'zoneId': '2',
'page': '1',
'pageSize': '10',
},
)
def test_request_params(self, get):
cs = CloudStack(endpoint='localhost',
key='foo',
secret='bar',
timeout=20)
get.return_value.status_code = 200
get.return_value.json.return_value = {
'listvirtualmachinesresponse': {},
}
machines = cs.listVirtualMachines(listall='true',
headers={'Accept-Encoding': 'br'})
self.assertEqual(machines, {})
get.assert_called_once_with(
'localhost',
timeout=20,
verify=True,
cert=None,
headers={
'Accept-Encoding': 'br',
},
params={
'apiKey': 'foo',
'response': 'json',
'command': 'listVirtualMachines',
'listall': 'true',
'signature': 'B0d6hBsZTcFVCiioSxzwKA9Pke8=',
},
)
def test_error(self, get):
get.return_value.status_code = 530
get.return_value.json.return_value = {
'listvirtualmachinesresponse': {'errorcode': 530,
'uuidList': [],
'cserrorcode': 9999,
'errortext': 'Fail'}}
cs = CloudStack(endpoint='localhost', key='foo', secret='bar')
self.assertRaises(CloudStackException, cs.listVirtualMachines)
def test_bad_content_type(self, get):
get.return_value.status_code = 502
get.return_value.headers = CaseInsensitiveDict(
**{"content-type": "text/html;charset=utf-8"})
get.return_value.text = ("<!DOCTYPE html><title>502</title>"
"<h1>Gateway timeout</h1>")
cs = CloudStack(endpoint='https://localhost', key='foo', secret='bar')
self.assertRaises(CloudStackException, cs.listVirtualMachines)
def __init__(self, zoneid, debug):
self.zoneid = zoneid
self._debug = debug
self._config = read_config()
self._cs = CloudStack(**self._config)
self._vms = {}
self._zones = {}
self._lbs = {}
self._templates = {}
self._offerings = {}
self._networks = {}
def __init__(self):
parser = argparse.ArgumentParser()
parser.add_argument('--host')
parser.add_argument('--list', action='store_true')
parser.add_argument('--project')
options = parser.parse_args()
try:
self.cs = CloudStack(**read_config())
except CloudStackException, e:
print >> sys.stderr, "Error: Could not connect to CloudStack API"
def __init__(self, endpoint=None, key=None, secret=None, profile=None, timeout=60, dry_run=True,
log_to_slack=False):
if profile:
(endpoint, key, secret) = _load_cloud_monkey_profile(profile)
self.endpoint = endpoint
self.key = key
self.secret = secret
self.timeout = timeout
self.dry_run = dry_run
self.log_to_slack = log_to_slack
self.cs = CloudStack(self.endpoint, self.key, self.secret, self.timeout)
