def delete(self, schema_object=None):
""" Client method to perform DELETE operation """
neutron_cluster_node = self.read()
result_obj = super(ClusterNodes, self).delete(schema_object)
conn = self.get_connection()
neutron_client = neutron.Neutron(neutron_cluster_node.host_address,
conn.username, conn.password)
neutron_client.delete_neutron(neutron_cluster_node.host_address,
conn.username, conn.password)
time.sleep(30)
self.reboot_cluster()
time.sleep(60)
return result_obj
def create(self, r_schema):
add_member_to_cluster_schema = r_schema
result_obj = super(ClusterNodes,
self).create(add_member_to_cluster_schema)
data = None
if result_obj.status_code == int(403):
result = neutron_result.Result()
data = result_obj.get_response_data()
result.set_data(data, self.accept_type)
if add_member_to_cluster_schema.cert_thumbprint == '' or \
add_member_to_cluster_schema.cert_thumbprint is None:
add_member_to_cluster_schema.cert_thumbprint = result.errorData.thumbprint
result_obj = super(ClusterNodes,
self).create(add_member_to_cluster_schema)
data = result_obj.get_response_data()
conn = self.get_connection()
neutron_instance = neutron.Neutron(conn.ip, conn.username,
conn.password)
done = 0
retries = 0
tasks = NeutronTasks(neutron_instance)
task_schema = NeutronTasksSchema()
task_schema.set_data(data, self.accept_type)
while done == 0:
tasks.id = task_schema.id
if task_schema.status == "success":
done = 1
else:
if task_schema.status != "running":
break
time.sleep(30)
task_schema = tasks.read()
retries = retries + 1
if retries > 5:
break
tasks_response = NeutronTasksResponse(tasks)
tasks_response_schema = tasks_response.read()
result_obj.response = tasks_response_schema.get_data(self.accept_type)
self.id = tasks_response_schema.id
result_obj.response_data = result_obj.response
return result_obj
"""
super(LogicalSwitch, self).__init__()
self.log = logger.setup_logging(self.__class__.__name__)
self.schema_class = 'logical_switch_schema.LogicalSwitchSchema'
if neutron is not None:
self.set_connection(neutron.get_connection())
self.set_state_endpoint('/lswitches/%s/state')
self.set_create_endpoint('/lswitches')
self.id = None
if __name__ == '__main__':
import neutron
import base_client
log = logger.setup_logging('Neutron IPSet Test')
neutron_object = neutron.Neutron("10.110.31.147", "admin", "default")
ls = LogicalSwitch(neutron=neutron_object)
#Create New IPSet
py_dict = {
'transport_zone_binding': [{
'transport_zone_id':
'tz-40c99b73-a476-43db-995c-9a41aab59016'
}],
'display_name':
'ls_1'
}
result_objs = base_client.bulk_create(ls, [py_dict])
self.set_result(self.response, result_obj)
result_obj.set_response_data(schema_object._member_id)
return result_obj
def get_id(self, response=None):
return response
if __name__ == '__main__':
import neutron
import base_client
from service import Service
from servicegroup import ServiceGroup
log = logger.setup_logging('Neutron ServiceGroup Test')
neutron_object = neutron.Neutron("10.112.11.7", "admin", "default")
#Create Two Services for Service Group Testing
service_client_1 = Service(neutron=neutron_object)
py_dict = {'display_name': 'Service-1', 'value': '1234', \
'application_protocol': 'TCP', 'source_port': '2345'}
result_objs = base_client.bulk_create(service_client_1, [py_dict])
print "Create Service Status code: %s" % result_objs[0].status_code
print "Service id: %s" % service_client_1.id
#Create composite service group for testing
composite_service_group_client = ServiceGroup(neutron=neutron_object)
py_dict = {
'display_name': 'Composite Service Group - 1',
'description': 'SG Description'
}
"""
super(IPSet, self).__init__()
self.log = logger.setup_logging(self.__class__.__name__)
self.schema_class = 'ipset_schema.IPSetSchema'
if neutron is not None:
self.set_connection(neutron.get_connection())
self.set_create_endpoint('/groupings/ipsets')
self.id = None
if __name__ == '__main__':
import base_client
log = logger.setup_logging('Neutron IPSet Test')
neutron_object = neutron.Neutron("10.110.30.213:443", "localadmin",
"default")
ipset_client = IPSet(neutron=neutron_object)
#Create New IPSet
py_dict = {
'schema': 'IPSet',
'display_name': 'IPSet-1',
'value': '192.168.0.101'
}
result_objs = base_client.bulk_create(ipset_client, [py_dict])
print "Create IPSet Status code: %s" % result_objs[0].status_code
print "Create result response: %s" % result_objs[0].response
print "IPSet id: %s" % ipset_client.id
#Update IPSet
py_dict1 = {
self.set_create_endpoint('/element-managers/nvp')
def create(self, r_schema):
nvp_registration_schema = r_schema
result_obj = super(NVPRegistration,
self).create(nvp_registration_schema)
if result_obj.status_code == int(403):
result = neutron_result.Result()
result.set_data(result_obj.get_response_data(), self.accept_type)
if nvp_registration_schema.cert_thumbprint == '' or \
nvp_registration_schema.cert_thumbprint is None:
nvp_registration_schema.cert_thumbprint = result.errorData.thumbprint
result_obj = super(NVPRegistration,
self).create(nvp_registration_schema)
return result_obj
if __name__ == '__main__':
import base_client
nc = neutron.Neutron("10.24.115.115:8082", "root", "vmware")
nvp_register = NVPRegistration(neutron=nc)
py_dict = {
'ipaddress': '192.168.2.3',
'username': '******',
'password': '******',
'role': 'API_PROVIDER'
}
base_client.bulk_create(nvp_register, [py_dict])
import global_deployment_container
import deployment_container_schema
from vsm import VSM
if __name__=='__main__':
vsm_obj = VSM("10.67.120.30:443", "admin", "default", version="4.0")
gdc_obj = global_deployment_container.GlobalDeploymentContainer(vsm_obj)
py_dict = dict(name='nsx-dc', description='nsx-dc', hypervisortype='vsphere',
keyvaluearray=[{'key': 'computeResource', 'value': 'domain-c23'}, {'key': 'storageResource', 'value': 'datastore-15'}])
gdc_schema = deployment_container_schema.DeploymentContainerSchema(py_dict)
print gdc_schema.get_data('xml')
result = gdc_obj.create(gdc_schema)
print result.__dict__
neutron_obj = neutron.Neutron("10.67.120.30", "admin", "default")
sic = segment_id_pools.SegmentIDPools(neutron_obj)
si = segment_id_pools_schema.SegmentIDPoolsSchema( { 'schema' : '/v1/schema/SegmentIDPool', 'start': 5000, 'end': 10000 } )
result = sic.create(si)
print "segment create status = %s" % str(result.status_code)
mpc = multicast_pools.MulticastPools(neutron_obj)
mp = multicast_pools_schema.MulticastPoolsSchema( { 'schema' : '/v1/schema/MulticastAddressPool', 'start': '224.0.0.1', 'end': '224.0.0.254' } )
result = mpc.create(mp)
print "multicast status = %s" % str(result.status_code)
tzc = transport_zone.TransportZone(neutron_obj)
tz = transport_zone_schema.TransportZoneSchema({'display_name' : 'name', 'schema' : '/v1/schema/TransportZone', 'transport_zone_type' : 'vxlan' })
result = tzc.create(tz)
print "tz status = %s" % str(result.status_code)
@param neutron object on which TransportZone object has to be configured
"""
super(TransportZone, self).__init__()
self.log = logger.setup_logging(self.__class__.__name__)
self.schema_class = 'transport_zone_schema.TransportZoneSchema'
if neutron is not None:
self.set_connection(neutron.get_connection())
self.set_create_endpoint('/transport-zones')
self.set_state_endpoint('/transport-zones/%s/state')
self.id = None
if __name__ == '__main__':
from bulk_get_schemas import BulkGetSchemas
import neutron
log = logger.setup_logging('Neutron IPSet Test')
neutron_object = neutron.Neutron("10.110.27.173", "localadmin", "default")
tz = TransportZone(neutron_object)
bulk_get_tz = BulkGetSchemas(TransportZoneSchema())
tz_list = tz.base_query()
bulk_get_tz.set_data(tz_list, tz.accept_type)
print bulk_get_tz
print bulk_get_tz.print_object()
for tz_schema in bulk_get_tz.results:
tz.id = tz_schema.id
state_schema = tz.get_state()
print state_schema.state
self).create(vsm_registration_schema)
if result_obj.status_code == int(403):
result = neutron_result.Result()
result.set_data(result_obj.get_response_data(), self.accept_type)
if vsm_registration_schema.cert_thumbprint == '' or \
vsm_registration_schema.cert_thumbprint is None:
vsm_registration_schema.cert_thumbprint = result.errorData.thumbprint
result_obj = super(VSMRegistration,
self).create(vsm_registration_schema)
return result_obj
if __name__ == '__main__':
import base_client
nc = neutron.Neutron("10.110.27.77:443", "localadmin", "default")
vsm_register = VSMRegistration(neutron=nc)
#vsm_register_schema = registration_schema.Registration()
#vsm_register_schema.set_data_json('{"name":"10.110.28.190","vsmUuid":"uuid-2","ipaddress":"10.110.28.190"}')
py_dict = {
'schema': '/v1/schema/VSMConfig',
'display_name': 'vsm-3',
'address': '10.110.27.60',
'user': '******',
'password': '******',
'cert_thumbprint': ''
}
base_client.bulk_create(vsm_register, [py_dict])
#print vsm_register_schema.ipaddress
#print 'Status code: ' + str(vsm_register.result.status_code)
