def update(self, tpl_id, data):
"""
update config template
:type data['name']: string
:param data['name']: template name
:type data['template']: string
:param data['template']:
:type data['snippet']: string
:param data['snippet']:
:type data['audit_comment']: string
:param data['audit_comment']:
:type data['template_kind_id']: string
:param data['template_kind_id']: not relevant for snippet
:type data['template_combinations_attributes']: string
:param data['template_combinations_attributes']: Array of template combinations (hostgroup_id, environment_id)
:type data['operatingsystem_ids']: string
:param data['operatingsystem_ids']: Array of operating systems ID to associate the template with
"""
path = "/api/config_templates/%s" % (tpl_id)
data = slice_dict(data, \
'name', 'template', 'snippet', 'audit_comment', \
'template_kind_id', 'template_combinations_attributes', \
'operatingsystem_ids', allow_none=False)
return self.server.PUT(path, {"config_template": data})[1]
def create(self, data):
"""
:type data['name']: string
"""
path = "/api/architectures/"
data = slice_dict(data, 'name')
return self.server.POST(path, {'architecture': data})[1]
def update(self, arch_id, data):
"""
:type arch_id: string
:param arch_id: architecture identifier
:type data['name']: string
"""
path = "/api/architectures/%s/" % str(arch_id)
data = slice_dict(data, 'name')
return self.server.PUT(path, {'architecture': data})[1]
def show(self, proxy_id, queries=None):
"""
show smart proxy
:type data['proxy_id']: string
:param data['proxy_id']: domain name (no slashes)
"""
path = "/api/smart_proxies/%s" % (proxy_id)
queries = slice_dict(queries or {}, 'id')
return self.server.GET(path, queries)[1]
def revision(self, queries):
"""
revision config template
:type data['version']: string
:param data['version']: template version
"""
path = "/api/config_templates/revision"
queries = slice_dict(queries, 'version')
return self.server.GET(path, queries)[1]
def list(self, queries=None):
"""
list smart proxy
:type data['search']: string
:param data['search']: Filter results
:type data['order']: string
:param data['order']: Sort results
"""
path = "/api/smart_proxies"
queries = slice_dict(queries or {}, 'search', 'order')
return self.server.GET(path, queries)[1]
def list(self, queries):
"""
list domain
:type queries['search']: string
:param queries['search']: Filter results
:type queries['order']: string
:param queries['order']: Sort results
"""
path = "/api/domains"
queries = slice_dict(queries, 'search', 'order', allow_none=False)
return self.server.GET(path, queries)[1]
def list(self, queries):
"""
list config template
:type queries['search']: string
:param queries['search']: filter results
:type queries['order']: string
:param queries['order']: sort results
"""
path = "/api/config_templates"
queries = slice_dict(queries, 'search', 'order', allow_none=False)
return self.server.GET(path, queries)[1]
def list(self, queries=None):
"""
List subnets
:type data['search']: string
:param data['search']: <p>Filter results</p>
:type data['order']: string
:param data['order']: <p>Sort results</p>
"""
path = "/api/subnets"
if queries:
queries = slice_dict(queries, "search", "order")
return self.server.GET(path, queries)[1]
def create(self, data):
"""
The fullname field is used for human readability in reports
and other pages that refer to domains, and also available as
an external node parameter
:type data['name']: string
:param data['name']: The smart proxy name
:type data['url']: string
:param data['url']: The smart proxy URL starting with 'http://' or 'https://'
"""
path = "/api/smart_proxies"
data = slice_dict(data, 'name', 'url')
return self.server.POST(path, {"smart_proxy": data})[1]
def update(self, proxy_id, data):
"""
update smart proxy
:type data['proxy_id']: string
:param data['proxy_id']: domain name (no slashes)
:type data['name']: string
:param data['name']: The smart proxy name
:type data['url']: string
:param data['url']: The smart proxy URL starting with 'http://' or 'https://'
"""
path = "/api/smart_proxies/%s" % (proxy_id)
data = slice_dict(data, 'name', 'url')
return self.server.PUT(path, {"smart_proxy": data})[1]
def update(self, resource_id, data):
"""
:type resource_id: string
:param resource_id: compute resource identifier
:type data['name']: string
:type data['provider']: string
:param data['provider']: Provider type, one of: Libvirt Ovirt EC2 Vmware Openstack Rackspace
:type data['url']: string
:param data['url']: URL for Libvirt, Ovirt, and Openstack
:type data['description']: string
:type data['user']: string
:param data['user']: Username for Ovirt, EC2, Vmware, Openstack. Access Key for EC2.
:type data['password']: string
:param data['password']: Password for Ovirt, EC2, Vmware, Openstack. Secret key for EC2
:type data['uuid']: string
:param data['uuid']: for Ovirt, Vmware Datacenter
:type data['region']: string
:param data['region']: for EC2 only
:type data['tenant']: string
:param data['tenant']: for Openstack only
:type data['server']: string
:param data['server']: for Vmware
"""
data = slice_dict(data,
'name',
'url',
'description',
'user',
'password',
'uuid',
'region',
'tenant',
'server'
)
return self.server.PUT(self.__path(resource_id), {'compute_resource': data})[1]
def create(self, data):
"""
create config template
:type data['name']: string
:param data['name']: template name
:type data['template']: string
:param data['template']:
:type data['snippet']: string
:param data['snippet']:
:type data['audit_comment']: string
"""
path = "/api/config_templates"
data = slice_dict(data, \
'name', 'template', 'snippet', 'audit_comment', \
'template_kind_id', 'template_combinations_attributes', \
'operatingsystem_ids')
return self.server.POST(path, {"config_template": data})[1]
def create(self, data):
"""
:type name: string
:type provider: string
:param provider: Provider type, one of: Libvirt Ovirt EC2 Vmware Openstack Rackspace
:type url: string
:param url: URL for Libvirt, Ovirt, and Openstack
:type description: string
:type user: string
:param user: Username for Ovirt, EC2, Vmware, Openstack. Access Key for EC2.
:type password: string
:param password: Password for Ovirt, EC2, Vmware, Openstack. Secret key for EC2
:type uuid: string
:param uuid: for Ovirt, Vmware Datacenter
:type region: string
:param region: for EC2 only
:type tenant: string
:param tenant: for Openstack only
:type server: string
:param server: for Vmware
"""
data = slice_dict(data,
'name',
'provider',
'url',
'description',
'user',
'password',
'uuid',
'region',
'tenant',
'server'
)
return self.server.POST(self.__path(), {'compute_resource': data})[1]
def update(self, domain_id, data):
"""
update domain
:type domain_id: string
:type data['name']: string
:param data['name']: The full DNS Domain name
:type data['fullname']: string
:param data['fullname']: Full name describing the domain
:type data['dns_id']: string
:param data['dns_id']: DNS Proxy to use within this domain
:type data['domain_parameters_attributes']: string
:param data['domain_parameters_attributes']: Array of parameters (name, value)
"""
path = "/api/domains/%s" % str(domain_id)
data = slice_dict(data, 'name', 'fullname', 'dns_id')
return self.server.PUT(path, {"domain": data})[1]
def create(self, data):
"""
The fullname< field is used for human readability in reports
and other pages that refer to domains, and also available
as an external node parameter
:type data['name']: string
:param data['name']: The full DNS Domain name
:type data['fullname']: string
:param data['fullname']: Full name describing the domain
:type data['dns_id']: string
:param data['dns_id']: DNS Proxy to use within this domain
:type data['domain_parameters_attributes']: string
:param data['domain_parameters_attributes']: Array of parameters (name, value)
"""
path = "/api/domains"
data = slice_dict(data, 'name', 'fullname', 'dns_id')
return self.server.POST(path, {"domain": data})[1]
def test_slices_dict_with_one_of_its_original_keys(self):
self.assertEqual(
slice_dict(self.test_dict, "A", "Z"),
{"A": "a"}
)
def test_slices_dict_with_all_its_original_keys_and_filtered_nones(self):
self.assertEqual(
slice_dict(self.test_dict, "A", "B", "C", "D", allow_none=False),
{"A": "a", "B": "b", "C": "c"}
)
def test_slices_dict_with_all_its_original_keys(self):
self.assertEqual(
slice_dict(self.test_dict, "A", "B", "C", "D"),
self.test_dict
)
def test_slices_dict(self):
self.assertEqual(
slice_dict(self.test_dict, "A"),
{"A": "a"}
)
def test_returns_empty_dict_if_no_keys_specified(self):
self.assertEqual(
slice_dict(self.test_dict),
{}
)
def create(self, data):
"""
Create a subnet
:type data['name']: string
:param data['name']: <p>Subnet name</p>
:type data['network']: string
:param data['network']: <p>Subnet network</p>
:type data['mask']: string
:param data['mask']: <p>Netmask for this subnet</p>
:type data['gateway']: string
:param data['gateway']: <p>Primary DNS for this subnet</p>
:type data['dns_primary']: string
:param data['dns_primary']: <p>Primary DNS for this subnet</p>
:type data['dns_secondary']: string
:param data['dns_secondary']: <p>Secondary DNS for this subnet</p>
:type data['from']: string
:param data['from']: <p>Starting IP Address for IP auto suggestion</p>
:type data['to']: string
:param data['to']: <p>Ending IP Address for IP auto suggestion</p>
:type data['vlanid']: string
:param data['vlanid']: <p>VLAN ID for this subnet</p>
:type data['domain_ids']: string
:param data['domain_ids']: <p>Domains in which this subnet is part</p>
:type data['dhcp_id']: string
:param data['dhcp_id']: <p>DHCP Proxy to use within this subnet</p>
:type data['tftp_id']: string
:param data['tftp_id']: <p>TFTP Proxy to use within this subnet</p>
:type data['dns_id']: string
:param data['dns_id']: <p>DNS Proxy to use within this subnet</p>
"""
path = "/api/subnets"
data = slice_dict(
data,
"name",
"network",
"mask",
"gateway",
"dns_primary",
"dns_secondary",
"from",
"to",
"vlanid",
"domain_ids",
"dhcp_id",
"tftp_id",
"dns_id",
)
return self.server.POST(path, {"subnet": data})[1]