def get_clusters_by_property(self, **kwargs):
"""Gets a list of clusters with the given property in kwargs"""
filter_items = {
k: v
for k, v in kwargs.items()
if k in linode_object_cluster_valid_filters and v is not None
}
filter_statement = create_filter_and(ObjectStorageCluster,
filter_items)
try:
# Special case because ID is not filterable
if 'id' in filter_items.keys():
result = ObjectStorageCluster(self.client, kwargs.get('id'))
result._api_get() # Force lazy-loading
return [result]
return self.client.object_storage.clusters(filter_statement)
except IndexError:
return None
except Exception as exception:
self.fail(msg='failed to get clusters {0}'.format(exception))
def _get_matching_cluster(self) -> Optional[List[ObjectStorageCluster]]:
filter_items = {
k: v
for k, v in self.module.params.items()
if k in linode_object_cluster_valid_filters and v is not None
}
filter_statement = create_filter_and(ObjectStorageCluster,
filter_items)
try:
# Special case because ID is not filterable
if 'id' in filter_items.keys():
result = ObjectStorageCluster(self.client,
self.module.params.get('id'))
result._api_get() # Force lazy-loading
return [result]
return self.client.object_storage.clusters(filter_statement)
except IndexError:
return None
except Exception as exception:
return self.fail(
msg='failed to get clusters {0}'.format(exception))
def _get_matching_instance(self) -> Optional[Instance]:
params = self.module.params
filter_items = {
k: v
for k, v in params.items()
if k in linode_instance_valid_filters and v is not None
}
filter_statement = create_filter_and(Instance, filter_items)
try:
# Special case because ID is not filterable
if 'id' in filter_items.keys():
result = Instance(self.client, params.get('id'))
result._api_get() # Force lazy-loading
return result
return self.client.linode.instances(filter_statement)[0]
except IndexError:
return None
except Exception as exception:
return self.fail(
msg='failed to get instance {0}'.format(exception))
def _get_matching_firewall(self) -> Optional[Firewall]:
"""Gets the Firewall with the param properties"""
filter_items = {
k: v
for k, v in self.module.params.items()
if k in linode_firewall_valid_filters and v is not None
}
filter_statement = create_filter_and(Firewall, filter_items)
try:
# Special case because ID is not filterable
if 'id' in filter_items.keys():
result = Firewall(self.client, self.module.params.get('id'))
result._api_get() # Force lazy-loading
return result
return self.client.networking.firewalls(filter_statement)[0]
except IndexError:
return None
except Exception as exception:
return self.fail(
msg='failed to get firewall {0}'.format(exception))
def _get_matching_nodebalancer(self) -> Optional[NodeBalancer]:
filter_items = {k: v for k, v in self.module.params.items()
if k in linode_nodebalancer_valid_filters and v is not None}
filter_statement = create_filter_and(NodeBalancer, filter_items)
try:
# Special case because ID is not filterable
if 'id' in filter_items.keys():
result = NodeBalancer(self.client, self.module.params.get('id'))
result._api_get() # Force lazy-loading
return result
return self.client.nodebalancers(filter_statement)[0]
except IndexError:
return None
except Exception as exception:
return self.fail(msg='failed to get nodebalancer {0}'.format(exception))
def _get_matching_domain(self, spec_args: dict) -> Optional[Domain]:
filter_items = {k: v for k, v in spec_args.items()
if k in linode_domain_valid_filters and v is not None}
filter_statement = create_filter_and(Domain, filter_items)
try:
# Special case because ID is not filterable
if 'id' in filter_items.keys():
result = Domain(self.client, spec_args.get('id'))
result._api_get() # Force lazy-loading
return result
return self.client.domains(filter_statement)[0]
except IndexError:
return None
except Exception as exception:
return self.fail(msg='failed to get domain {0}'.format(exception))
def get_nodebalancer_by_property(self, **kwargs):
"""Gets the NodeBalancer with the given property in kwargs"""
filter_items = {k: v for k, v in kwargs.items()
if k in linode_nodebalancer_valid_filters and v is not None}
filter_statement = create_filter_and(NodeBalancer, filter_items)
try:
# Special case because ID is not filterable
if 'id' in filter_items.keys():
result = NodeBalancer(self.client, kwargs.get('id'))
result._api_get() # Force lazy-loading
return result
return self.client.nodebalancers(filter_statement)[0]
except IndexError:
return None
except Exception as exception:
self.fail(msg='failed to get nodebalancer {0}'.format(exception))
