Esempio n. 1
0
def get_next_dynic(argv=[]):
    """Get the next available dynamic nic on this host"""
    cmd = ["ifconfig", "-a"]
    f_cmd_output = (
        utils.subprocess_popen(cmd, stdout=subprocess.PIPE).communicate()[0])
    eths = [lines.split(' ')[0] for lines in f_cmd_output.splitlines()
            if "eth" in lines]
    #print eths
    for eth in eths:
        cmd = ["ethtool", "-i", eth]
        f_cmd_output = (
            utils.subprocess_popen(cmd,
                                   stdout=subprocess.PIPE).communicate()[0])
        bdf = [lines.split(' ')[1] for lines in f_cmd_output.splitlines()
               if "bus-info" in lines]
        #print bdf
        cmd = ["lspci", "-n", "-s", bdf[0]]
        f_cmd_output = (utils.subprocess_popen(cmd, stdout=subprocess.PIPE).
                        communicate()[0])
        deviceid = [(lines.split(':')[3]).split(' ')[0]
                    for lines in f_cmd_output.splitlines()]
        #print deviceid
        if deviceid[0] == "0044":
            cmd = ["/sbin/ip", "link", "show", eth]
            f_cmd_output = (
                utils.subprocess_popen(cmd, stdout=subprocess.PIPE).
                communicate()[0])
            used = [lines for lines in f_cmd_output.splitlines()
                    if "UP" in lines]
            if not used:
                break
    return eth
Esempio n. 2
0
    def test_KillFilter(self):
        p = utils.subprocess_popen(["/bin/sleep", "5"])
        f = filters.KillFilter("root", "/bin/sleep", "-9", "-HUP")
        f2 = filters.KillFilter("root", "/usr/bin/sleep", "-9", "-HUP")
        usercmd = ['kill', '-ALRM', p.pid]
        # Incorrect signal should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        usercmd = ['kill', p.pid]
        # Providing no signal should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        # Providing matching signal should be allowed
        usercmd = ['kill', '-9', p.pid]
        self.assertTrue(f.match(usercmd) or f2.match(usercmd))

        f = filters.KillFilter("root", "/bin/sleep")
        f2 = filters.KillFilter("root", "/usr/bin/sleep")
        usercmd = ['kill', os.getpid()]
        # Our own PID does not match /bin/sleep, so it should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        usercmd = ['kill', 999999]
        # Nonexistant PID should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        usercmd = ['kill', p.pid]
        # Providing no signal should work
        self.assertTrue(f.match(usercmd) or f2.match(usercmd))
Esempio n. 3
0
def execute(cmd, root_helper=None, process_input=None, addl_env=None,
            check_exit_code=True, return_stderr=False):
    if root_helper:
        cmd = shlex.split(root_helper) + cmd
    cmd = map(str, cmd)

    LOG.debug(_("Running command: %s"), cmd)
    env = os.environ.copy()
    if addl_env:
        env.update(addl_env)
    obj = utils.subprocess_popen(cmd, shell=False,
                                 stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE,
                                 env=env)

    _stdout, _stderr = (process_input and
                        obj.communicate(process_input) or
                        obj.communicate())
    obj.stdin.close()
    m = _("\nCommand: %(cmd)s\nExit code: %(code)s\nStdout: %(stdout)r\n"
          "Stderr: %(stderr)r") % {'cmd': cmd, 'code': obj.returncode,
                                   'stdout': _stdout, 'stderr': _stderr}
    LOG.debug(m)
    if obj.returncode and check_exit_code:
        raise RuntimeError(m)

    return return_stderr and (_stdout, _stderr) or _stdout
Esempio n. 4
0
    def test_KillFilter(self):
        p = utils.subprocess_popen(["/bin/sleep", "5"])
        f = filters.KillFilter("root", "/bin/sleep", "-9", "-HUP")
        f2 = filters.KillFilter("root", "/usr/bin/sleep", "-9", "-HUP")
        usercmd = ['kill', '-ALRM', p.pid]
        # Incorrect signal should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        usercmd = ['kill', p.pid]
        # Providing no signal should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        # Providing matching signal should be allowed
        usercmd = ['kill', '-9', p.pid]
        self.assertTrue(f.match(usercmd) or f2.match(usercmd))

        f = filters.KillFilter("root", "/bin/sleep")
        f2 = filters.KillFilter("root", "/usr/bin/sleep")
        usercmd = ['kill', os.getpid()]
        # Our own PID does not match /bin/sleep, so it should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        usercmd = ['kill', 999999]
        # Nonexistant PID should fail
        self.assertFalse(f.match(usercmd) or f2.match(usercmd))
        usercmd = ['kill', p.pid]
        # Providing no signal should work
        self.assertTrue(f.match(usercmd) or f2.match(usercmd))
Esempio n. 5
0
def get_next_dynic(argv=[]):
    """Get the next available dynamic nic on this host"""
    cmd = ["ifconfig", "-a"]
    f_cmd_output = utils.subprocess_popen(cmd, stdout=subprocess.PIPE).communicate()[0]
    eths = [lines.split(" ")[0] for lines in f_cmd_output.splitlines() if "eth" in lines]
    # print eths
    for eth in eths:
        cmd = ["ethtool", "-i", eth]
        f_cmd_output = utils.subprocess_popen(cmd, stdout=subprocess.PIPE).communicate()[0]
        bdf = [lines.split(" ")[1] for lines in f_cmd_output.splitlines() if "bus-info" in lines]
        # print bdf
        cmd = ["lspci", "-n", "-s", bdf[0]]
        f_cmd_output = utils.subprocess_popen(cmd, stdout=subprocess.PIPE).communicate()[0]
        deviceid = [(lines.split(":")[3]).split(" ")[0] for lines in f_cmd_output.splitlines()]
        # print deviceid
        if deviceid[0] == "0044":
            cmd = ["/sbin/ip", "link", "show", eth]
            f_cmd_output = utils.subprocess_popen(cmd, stdout=subprocess.PIPE).communicate()[0]
            used = [lines for lines in f_cmd_output.splitlines() if "UP" in lines]
            if not used:
                break
    return eth
Esempio n. 6
0
def connect_vm(tenant_id, vm_image_id, service_instance_id, *args):
    """
    Starts a VMs and is connected to southbound network
    """
    l2db.initialize()
    client = Client(HOST, PORT, USE_SSL, format='json', tenant=tenant_id)
    print (_("Connecting %(vm_image_id)s to Service "
             "%(service_instance_id)s") % locals())
    service_logic = servlogcs.ServicesLogistics()
    service_nets = sdb.get_service_bindings(service_instance_id)
    client.create_port(service_nets.mngnet_id)
    client.create_port(service_nets.nbnet_id)
    sb_port_id = client.create_port(service_nets.sbnet_id)
    LOG.debug(_("Operation 'create_port' executed."))
    new_port_id = sb_port_id[servconts.PORT][servconts.ID]
    try:
        create_vm_args = []
        create_vm_args.append(servconts.CREATE_VM_CMD)
        create_vm_args.append(vm_image_id)
        print _("Creating VM with image: %s") % (vm_image_id)
        process = utils.subprocess_popen(create_vm_args,
                                         stdout=subprocess.PIPE)
        result = process.stdout.readlines()
        tokens = re.search("i-[a-f0-9]*", str(result[1]))
        vm_name = tokens.group(0)
        print _("Image: %s instantiated successfully") % (vm_name)
    except Exception as exc:
        print exc

    service_logic.image_status(vm_name)
    print _("Completed")
    print _("Attaching Ports To VM Service interfaces")
    south_net = service_nets.sbnet_id
    attachment = client.show_port_attachment(south_net, new_port_id)
    attachment = attachment[servconts.ATTACHMENT][servconts.ID][:36]
    LOG.debug(_("Plugging virtual interface: %(attachment)s of VM "
                "%(vm_name)s into port: %(new_port_id)s on network: "
                "%(sbnet_id)s"), {'attachment': attachment,
                                  'vm_name': vm_name,
                                  'new_port_id': new_port_id,
                                  'sbnet_id': service_nets.sbnet_id})
    attach_data = {servconts.ATTACHMENT: {servconts.ID: '%s' % attachment}}
    client.attach_resource(service_nets.sbnet_id, new_port_id, attach_data)
    print _("Connect VM Ended")
Esempio n. 7
0
 def image_shutdown_verification(self, image_name):
     """
     Verifies that the VM has been properly shutdown
     """
     try:
         service_args = []
         service_args.append(servconts.DESCRIBE_VM_CMD)
         service_args.append(image_name)
         counter = 0
         flag = False
         while not flag and counter <= 5:
             counter = counter + 1
             time.sleep(2.5)
             process = utils.subprocess_popen(service_args,
                                              stdout=subprocess.PIPE)
             result = process.stdout.readlines()
             if not result:
                 flag = True
     except Exception, exc:
         print exc
Esempio n. 8
0
def connect_vm(tenant_id, vm_image_id, service_instance_id, *args):
    """
    Starts a VMs and is connected to southbound network
    """
    l2db.initialize()
    client = Client(HOST, PORT, USE_SSL, format='json', tenant=tenant_id)
    print("Connecting %s to Service %s " % (vm_image_id, service_instance_id))
    service_logic = servlogcs.ServicesLogistics()
    service_nets = sdb.get_service_bindings(service_instance_id)
    client.create_port(service_nets.mngnet_id)
    client.create_port(service_nets.nbnet_id)
    sb_port_id = client.create_port(service_nets.sbnet_id)
    LOG.debug("Operation 'create_port' executed.")
    new_port_id = sb_port_id[servconts.PORT][servconts.ID]
    try:
        create_vm_args = []
        create_vm_args.append(servconts.CREATE_VM_CMD)
        create_vm_args.append(vm_image_id)
        print("Creating VM with image: %s" % (vm_image_id))
        process = utils.subprocess_popen(create_vm_args,
                                         stdout=subprocess.PIPE)
        result = process.stdout.readlines()
        tokens = re.search("i-[a-f0-9]*", str(result[1]))
        vm_name = tokens.group(0)
        print("Image: %s instantiated successfully" % (vm_name))
    except Exception as exc:
        print exc

    service_logic.image_status(vm_name)
    print "Completed"
    print "Attaching Ports To VM Service interfaces"
    south_net = service_nets.sbnet_id
    attachment = client.show_port_attachment(south_net, new_port_id)
    attachment = attachment[servconts.ATTACHMENT][servconts.ID][:36]
    LOG.debug(("Plugging virtual interface: %s of VM %s "
               "into port: %s on network: %s") %
              (attachment, vm_name, new_port_id, service_nets.sbnet_id))
    attach_data = {servconts.ATTACHMENT: {servconts.ID: '%s' % attachment}}
    client.attach_resource(service_nets.sbnet_id, new_port_id, attach_data)
    print("Connect VM Ended")
Esempio n. 9
0
 def image_status(self, image_name):
     """
     Checks the status of the image
     """
     try:
         service_args = []
         service_args.append(servconts.DESCRIBE_VM_CMD)
         service_args.append(image_name)
         counter = 0
         flag = False
         while not flag and counter <= 10:
             counter = counter + 1
             time.sleep(2.5)
             process = utils.subprocess_popen(service_args,
                                              stdout=subprocess.PIPE)
             result = process.stdout.readlines()
             if result:
                 tokens = re.search("running", str(result[1]))
                 if tokens:
                     service_status = tokens.group(0)
                     if service_status == "running":
                         flag = True
     except Exception as exc:
         print exc
Esempio n. 10
0
def insert_inpath_service(tenant_id, service_image_id,
                          management_net_name, northbound_net_name,
                          southbound_net_name, *args):
    """Inserting a network service between two networks"""
    print ("Creating Network for Services and Servers")
    service_logic = servlogcs.ServicesLogistics()
    net_list = {}
    multiport_net_list = []
    networks_name_list = [management_net_name, northbound_net_name,
                          southbound_net_name]
    client = Client(HOST, PORT, USE_SSL, format='json', tenant=tenant_id)
    for net in networks_name_list:
        data = {servconts.NETWORK: {servconts.NAME: net}}
        net_list[net] = client.create_network(data)
        net_list[net][servconts.PORTS] = []
        LOG.debug("Network %s Created with ID: %s " % (
            net, net_list[net][servconts.NETWORK][servconts.ID]))
    print "Completed"
    print ("Creating Ports on Services and Server Networks")
    LOG.debug("Operation 'create_port' executed.")
    if not service_logic.verify_plugin(const.UCS_PLUGIN):
        for net in networks_name_list:
            net_list[net][servconts.PORTS].append
            (client.create_port
            (net_list[net][servconts.NETWORK][servconts.ID]))
        LOG.debug("Operation 'create_port' executed.")
    else:
        for net in networks_name_list:
            nets = net_list[net][servconts.NETWORK][servconts.ID]
            multiport_net_list.append(nets)
        data = create_multiport(tenant_id, multiport_net_list)
        net_idx = 0
        for net in networks_name_list:
            port_id = data[servconts.PORTS][net_idx][servconts.ID]
            net_list[net][servconts.PORTS].append(port_id)
            LOG.debug("Port UUID: %s on network: %s" %
                      (data[servconts.PORTS][net_idx][servconts.ID], net))
            net_idx = net_idx + 1
    print "Completed"
    try:
        create_vm_args = []
        create_vm_args.append(servconts.CREATE_VM_CMD)
        create_vm_args.append(service_image_id)
        print ("Creating VM with image: %s" % (service_image_id))
        process = utils.subprocess_popen(create_vm_args,
                                         stdout=subprocess.PIPE)
        result = process.stdout.readlines()
        tokens = re.search("i-[a-f0-9]*", str(result[1]))
        service_vm_name = tokens.group(0)
        print ("Image: %s instantiated successfully" % (service_vm_name))

    except Exception as exc:
        print exc

    service_logic.image_status(service_vm_name)
    print "Completed"
    print "Attaching Ports To VM Service interfaces"
    try:
        idx = 0
        for net in networks_name_list:
            network_id = net_list[net][servconts.NETWORK][servconts.ID]
            port_id = net_list[net][servconts.PORTS][idx]
            attachment = client.show_port_attachment(network_id, port_id)
            attachment = attachment[servconts.ATTACHMENT][servconts.ID][:36]
            LOG.debug(("Plugging virtual interface: %s of VM %s"
                       "into port: %s on network: %s") %
                      (attachment, service_vm_name, port_id, net))
            attach_data = {servconts.ATTACHMENT: {servconts.ID: '%s' %
                                                  attachment}}
            client.attach_resource(network_id, port_id, attach_data)
    except Exception as exc:
        print exc
    print "Completed"
    try:
        LOG.debug("Registering Service in DB")
        l2db.initialize()
        for uuid_net in db.network_id(networks_name_list[0]):
            mngnet_id = str(uuid_net.uuid)
        for uuid_net in db.network_id(networks_name_list[1]):
            nbnet_id = str(uuid_net.uuid)
        for uuid_net in db.network_id(networks_name_list[2]):
            sbnet_id = str(uuid_net.uuid)
        sdb.add_services_binding(service_vm_name, mngnet_id, nbnet_id,
                                 sbnet_id)
    except Exception as exc:
        print exc
Esempio n. 11
0
def insert_inpath_service(tenant_id, service_image_id, management_net_name,
                          northbound_net_name, southbound_net_name, *args):
    """Inserting a network service between two networks"""
    print("Creating Network for Services and Servers")
    service_logic = servlogcs.ServicesLogistics()
    net_list = {}
    multiport_net_list = []
    networks_name_list = [
        management_net_name, northbound_net_name, southbound_net_name
    ]
    client = Client(HOST, PORT, USE_SSL, format='json', tenant=tenant_id)
    for net in networks_name_list:
        data = {servconts.NETWORK: {servconts.NAME: net}}
        net_list[net] = client.create_network(data)
        net_list[net][servconts.PORTS] = []
        LOG.debug("Network %s Created with ID: %s " %
                  (net, net_list[net][servconts.NETWORK][servconts.ID]))
    print "Completed"
    print("Creating Ports on Services and Server Networks")
    LOG.debug("Operation 'create_port' executed.")
    if not service_logic.verify_plugin(const.UCS_PLUGIN):
        for net in networks_name_list:
            net_list[net][servconts.PORTS].append
            (client.create_port(
                net_list[net][servconts.NETWORK][servconts.ID]))
        LOG.debug("Operation 'create_port' executed.")
    else:
        for net in networks_name_list:
            nets = net_list[net][servconts.NETWORK][servconts.ID]
            multiport_net_list.append(nets)
        data = create_multiport(tenant_id, multiport_net_list)
        net_idx = 0
        for net in networks_name_list:
            port_id = data[servconts.PORTS][net_idx][servconts.ID]
            net_list[net][servconts.PORTS].append(port_id)
            LOG.debug("Port UUID: %s on network: %s" %
                      (data[servconts.PORTS][net_idx][servconts.ID], net))
            net_idx = net_idx + 1
    print "Completed"
    try:
        create_vm_args = []
        create_vm_args.append(servconts.CREATE_VM_CMD)
        create_vm_args.append(service_image_id)
        print("Creating VM with image: %s" % (service_image_id))
        process = utils.subprocess_popen(create_vm_args,
                                         stdout=subprocess.PIPE)
        result = process.stdout.readlines()
        tokens = re.search("i-[a-f0-9]*", str(result[1]))
        service_vm_name = tokens.group(0)
        print("Image: %s instantiated successfully" % (service_vm_name))

    except Exception as exc:
        print exc

    service_logic.image_status(service_vm_name)
    print "Completed"
    print "Attaching Ports To VM Service interfaces"
    try:
        idx = 0
        for net in networks_name_list:
            network_id = net_list[net][servconts.NETWORK][servconts.ID]
            port_id = net_list[net][servconts.PORTS][idx]
            attachment = client.show_port_attachment(network_id, port_id)
            attachment = attachment[servconts.ATTACHMENT][servconts.ID][:36]
            LOG.debug(("Plugging virtual interface: %s of VM %s"
                       "into port: %s on network: %s") %
                      (attachment, service_vm_name, port_id, net))
            attach_data = {
                servconts.ATTACHMENT: {
                    servconts.ID: '%s' % attachment
                }
            }
            client.attach_resource(network_id, port_id, attach_data)
    except Exception as exc:
        print exc
    print "Completed"
    try:
        LOG.debug("Registering Service in DB")
        l2db.initialize()
        for uuid_net in db.network_id(networks_name_list[0]):
            mngnet_id = str(uuid_net.uuid)
        for uuid_net in db.network_id(networks_name_list[1]):
            nbnet_id = str(uuid_net.uuid)
        for uuid_net in db.network_id(networks_name_list[2]):
            sbnet_id = str(uuid_net.uuid)
        sdb.add_services_binding(service_vm_name, mngnet_id, nbnet_id,
                                 sbnet_id)
    except Exception as exc:
        print exc