Example #1
0
def main():
    parser = argparse.ArgumentParser()
    defaults = {
        "api-server": "127.0.0.1",
        "api-port": 8082,
        "project": "default-domain:default-project",
        "network": "default-network",
    }
    parser.set_defaults(**defaults)
    parser.add_argument("-s", "--api-server", help="API server address")
    parser.add_argument("-p", "--api-port", type=int, help="API server port")
    parser.add_argument("-n", "--network", help="Primary network")
    parser.add_argument("--project", help="Network project")
    parser.add_argument("--start", action="store_true", help="Create namespace")
    parser.add_argument("--stop", action="store_true", help="Delete namespace")
    parser.add_argument("container_id", metavar="container-id", help="Container ID")

    args = parser.parse_args(sys.argv[1:])
    if not args.start and not args.stop:
        print "Please specify --start or --stop action"
        sys.exit(1)

    manager = LxcManager()
    provisioner = Provisioner(api_server=args.api_server, api_port=args.api_port)
    instance_name = "%s-%s" % (socket.gethostname(), args.container_id)
    pid_str = subprocess.check_output("docker inspect -f '{{.State.Pid}}' %s" % args.container_id, shell=True)
    pid = int(pid_str)

    subprocess.check_output("ln -sf /proc/%d/ns/net /var/run/netns/%s" % (pid, args.container_id), shell=True)

    if args.start:
        vm = provisioner.virtual_machine_locate(instance_name)
        network = build_network_name(args.project, args.network)
        vmi = provisioner.vmi_locate(vm, network, "veth0")
        ifname = manager.create_interface(args.container_id, "veth0", vmi)
        interface_register(vm, vmi, ifname)
        subprocess.check_output("ip netns exec %s dhclient veth0" % args.container_id, shell=True)
    elif args.stop:
        vm = provisioner.virtual_machine_lookup(instance_name)

        vmi_list = vm.get_virtual_machine_interfaces()
        for ref in vmi_list:
            uuid = ref["uuid"]
            interface_unregister(uuid)

        manager.clear_interfaces(args.container_id)

        for ref in vmi_list:
            provisioner.vmi_delete(ref["uuid"])

        provisioner.virtual_machine_delete(vm)
        subprocess.check_output("ip netns delete %s" % args.container_id, shell=True)
def daemon_start():
    """
    Creates a virtual-machine and vmi object in the API server.
    Creates a namespace and a veth interface pair.
    Associates the veth interface in the master instance with the vrouter.
    """
    parser = argparse.ArgumentParser()
    defaults = {
        "api-server": "127.0.0.1",
        "api-port": 8082,
        "project": "default-domain:default-project",
        "network": "default-network",
    }
    parser.set_defaults(**defaults)
    parser.add_argument("-s", "--api-server", help="API server address")
    parser.add_argument("-p", "--api-port", type=int, help="API server port")
    parser.add_argument("--project", help="OpenStack project name")
    parser.add_argument("-n", "--network", help="Primary network")
    parser.add_argument("-o", "--outbound", help="Outbound traffic network")
    parser.add_argument("daemon", help="Deamon Name")

    arguments = parser.parse_args(sys.argv[1:])

    manager = LxcManager()
    provisioner = Provisioner(api_server=arguments.api_server, api_port=arguments.api_port)
    vrouter_name = socket.gethostname()
    instance_name = "%s-%s" % (vrouter_name, arguments.daemon)
    project_fq_name = arguments.project.split(":")
    project = provisioner.project_lookup(project_fq_name)
    vm = provisioner.virtual_machine_locate(vrouter_name, instance_name, project)

    network = build_network_name(arguments.project, arguments.network)

    vmi = provisioner.vmi_locate(vm, network, "veth0", project)
    vmi_out = None
    if arguments.outbound:
        outbound_name = build_network_name(arguments.project, arguments.outbound)
        vmi_out = provisioner.vmi_locate(vm, outbound_name, "veth1")

    manager.namespace_init(arguments.daemon)
    ifname = manager.interface_update(arguments.daemon, vmi, "veth0")
    interface_register(vm, vmi, ifname, project=project)

    if vmi_out:
        ifname = manager.interface_update(arguments.daemon, vmi_out, "veth1")
        interface_register(vm, vmi_out, ifname)

    single_interface = arguments.outbound is None
    ip_prefix = provisioner.get_interface_ip_prefix(vmi)
    manager.interface_config(arguments.daemon, "veth0", advertise_default=single_interface, ip_prefix=ip_prefix)
    if vmi_out:
        manager.interface_config(arguments.daemon, "veth1")
Example #3
0
 def keepalive(self):
     self.vrouter_client.periodic_connection_check()
     current_agent_connection = self.vrouter_client._client
     if not current_agent_connection:
         # vrouter agent is down, Try checking...
         return
     if self.vrouter_agent_connection != current_agent_connection:
         # Initial connection object to vrouter agent is different from
         # the current object, vrouter agent is restarted, plug the netns
         # vif's again.
         interface_register(self.vm, self.vmi, self.ifname, project=self.project)
         if self.vmi_out:
             interface_register(self.vm, self.vmi_out, self.ifname_out, project=self.project)
         self.vrouter_agent_connection = current_agent_connection
def daemon_start():
    """
    Creates a virtual-machine and vmi object in the API server.
    Creates a namespace and a veth interface pair.
    Associates the veth interface in the master instance with the vrouter.
    """
    parser = argparse.ArgumentParser()
    defaults = {
        "username": None,
        "password": None,
        "api-server": "127.0.0.1",
        "api-port": 8082,
        "project": "default-domain:default-project",
        "network": "default-network",
        "monitor": False,
    }
    parser.set_defaults(**defaults)
    parser.add_argument("-U", "--username", help="Username of the tenant")
    parser.add_argument("-P", "--password", help="Password for the user")
    parser.add_argument("-s", "--api-server", help="API server address")
    parser.add_argument("-p", "--api-port", type=int, help="API server port")
    parser.add_argument("--project", help="OpenStack project name")
    parser.add_argument("-n", "--network", help="Primary network")
    parser.add_argument("-o", "--outbound", help="Outbound traffic network")
    parser.add_argument(
        "-M", "--monitor", action="store_true", help="Monitor the vrouter agent connection to replug the vif's."
    )
    parser.add_argument("daemon", help="Deamon Name")

    arguments = parser.parse_args(sys.argv[1:])

    manager = LxcManager()
    project_name = get_project_name(arguments.project, arguments.network)
    provisioner = Provisioner(
        username=arguments.username,
        password=arguments.password,
        api_server=arguments.api_server,
        api_port=arguments.api_port,
        project=project_name,
    )
    vrouter_name = socket.gethostname()
    instance_name = "%s-%s" % (vrouter_name, arguments.daemon)
    vm = provisioner.virtual_machine_locate(vrouter_name, instance_name)

    network = build_network_name(arguments.project, arguments.network)

    vmi, project = provisioner.vmi_locate(vm, network, "veth0")
    vmi_out = None
    if arguments.outbound:
        outbound_name = build_network_name(arguments.project, arguments.outbound)
        vmi_out, project = provisioner.vmi_locate(vm, outbound_name, "veth1")

    manager.namespace_init(arguments.daemon)
    ifname = manager.interface_update(arguments.daemon, vmi, "veth0")
    interface_register(vm, vmi, ifname, project=project)

    vmi_out_kwargs = {}
    if vmi_out:
        ifname = manager.interface_update(arguments.daemon, vmi_out, "veth1")
        interface_register(vm, vmi_out, ifname, project=project)
        vmi_out_kwargs = {"vmi_out": vmi_out, "ifname_out": ifname}

    single_interface = arguments.outbound is None
    ip_prefix = provisioner.get_interface_ip_prefix(vmi)
    manager.interface_config(arguments.daemon, "veth0", advertise_default=single_interface, ip_prefix=ip_prefix)
    if vmi_out:
        manager.interface_config(arguments.daemon, "veth1")

    if arguments.monitor:
        netns_monitor = NetnsMonitor(project, vm, vmi, ifname, **vmi_out_kwargs)
        netns_monitor.monitor()