diff --git a/MANIFEST b/MANIFEST
index 2905cd925..ea4e194d6 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -55,6 +55,6 @@ lib/Ravada/I18N/ca.po
 lib/Ravada/NetInterface.pm
 lib/Ravada/Auth.pm
 lib/Ravada/Domain.pm
-lib/Ravada/Network.pm
+lib/Ravada/Routes.pm
 script/rvd_front
 script/rvd_back
diff --git a/README.md b/README.md
index 37dd586cc..cb2aaf52e 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# ravada 
+# ravada
 
 [![GitHub version](https://img.shields.io/badge/version-1.8.0-brightgreen.svg)](https://github.com/UPC/ravada/releases) [![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://github.com/UPC/ravada/blob/master/LICENSE)
 [![Documentation Status](https://readthedocs.org/projects/ravada/badge/?version=latest)](http://ravada.readthedocs.io/en/latest/?badge=latest)
@@ -10,34 +10,38 @@
 
 ## Remote Virtual Desktops Manager
 
-Ravada is a software that allows the user to connect to a
-remote virtual desktop.
-Ravada is meant for sysadmins who have some background in GNU/Linux, and want to deploy a VDI project.
+Ravada is an open-source project that provides a web-based user interface for managing and accessing virtual machines (VMs) based on the QEMU/KVM virtualization technology. Ravada aims to simplify the management of virtual machines by offering a user-friendly interface accessible through a web browser.Ravada is meant for sysadmins who have some background in GNU/Linux, and want to deploy a VDI project.
 
-Its back-end has been designed and implemented in order to allow future hypervisors to be added to the framework. Currently, it supports KVM and LXC is in the works.
+Users can use Ravada to create, configure, and manage virtual machines without the need for a dedicated desktop client. It provides features such as remote console access, snapshot management, and the ability to manage multiple VMs from a central interface. Ravada's back-end has been designed and implemented in order to allow future hypervisors to be added to the framework. Currently, it supports KVM and LXC is in the works.
 
 The client only requirements are: a web-browser and a remote viewer supporting the spice protocol.
 
 In the current release we use the
 KVM Hypervisors: [KVM](http://www.linux-kvm.org/) as the backend for the Virtual Machines.
- [LXC](https://linuxcontainers.org/) support is currently in development.
+[LXC](https://linuxcontainers.org/) support is currently in development.
 
 ### Features
 
- * KVM backend for Windows and Linux Virtual machines
- * LDAP and SQL authentication
- * Kiosk mode
- * Remote Access with [Spice](http://www.spice-space.org/) for Windows and Linux
- * Light and fast virtual machine clones for each user
- * Instant clone creation
- * USB redirection
- * Easy and customizable end users interface
- * Administration from a web browser
+- KVM backend for Windows and Linux Virtual machines
+- LDAP and SQL authentication
+- Kiosk mode
+- Remote Access with [Spice](http://www.spice-space.org/) for Windows and Linux
+- Light and fast virtual machine clones for each user
+- Instant clone creation
+- USB redirection
+- Easy and customizable end users interface
+- Administration from a web browser
 
 ## Install
 
 Read [INSTALL](http://ravada.readthedocs.io/en/latest/docs/INSTALL.html).
 
+Install Ravada in [Ubuntu](https://ravada.readthedocs.io/en/latest/docs/INSTALL_Ubuntu.html)
+Install Ravada in [Debian](https://ravada.readthedocs.io/en/latest/docs/INSTALL_Debian.html)
+Install Ravada on [Fedora](https://ravada.readthedocs.io/en/latest/docs/INSTALL_Fedora.html)
+Install Ravada on [Rocky Linux 9 or RHEL9](https://ravada.readthedocs.io/en/latest/docs/INSTALL_Rocky9.html#install-ravada-on-rocky-linux-9-or-rhel9)
+Install Ravada - [Ubuntu Xenial](https://ravada.readthedocs.io/en/latest/docs/INSTALL_ubuntu_xenial.html)
+Install Ravada from [dockers](https://ravada.readthedocs.io/en/latest/docs/INSTALLfromDockers.html).
 
 ### Production
 
@@ -48,6 +52,11 @@ for production fine-tuning guidelines.
 
 See [operation](http://ravada.readthedocs.io/en/latest/docs/operation.html).
 
+- [Create users](https://ravada.readthedocs.io/en/latest/docs/INSTALL_Ubuntu.html)
+- [Import KVM virtual machines](https://ravada.readthedocs.io/en/latest/docs/INSTALL_Ubuntu.html)
+- [View all rvd_back options](https://ravada.readthedocs.io/en/latest/docs/operation.html#view-all-rvd-back-options)
+- [Admin Operations](https://ravada.readthedocs.io/en/latest/docs/operation.html#admin)
+
 ### Update
 
 See [update](http://ravada.readthedocs.io/en/latest/docs/update.html).
diff --git a/lib/Ravada.pm b/lib/Ravada.pm
index 04ca89227..55677e24e 100644
--- a/lib/Ravada.pm
+++ b/lib/Ravada.pm
@@ -1651,6 +1651,13 @@ sub _add_indexes_generic($self) {
             ,"index(date_changed)"
             ,"index(id_owner)"
         ]
+        ,bundles => [
+            "unique (name)"
+        ]
+        ,domains_bundle => [
+            "index(id_domain)"
+            ,"unique (id_bundle, id_domain)"
+        ]
     );
     my $if_not_exists = '';
     $if_not_exists = ' IF NOT EXISTS ' if $CONNECTOR->dbh->{Driver}{Name} =~ /sqlite|mariadb/i;
@@ -2382,6 +2389,21 @@ sub _sql_create_tables($self) {
             }
         ]
         ,
+        [
+            bundles => {
+                id => 'integer PRIMARY KEY AUTO_INCREMENT',
+                name => 'char(255) NOT NULL',
+                private_network => 'integer NOT NULL default 0'
+            }
+        ],
+        [
+            domains_bundle => {
+                id => 'integer PRIMARY KEY AUTO_INCREMENT',
+                id_bundle => 'integer NOT NULL references `bundles` (`id`) ON DELETE CASCADE',
+                id_domain => 'integer NOT NULL references `domains` (`id`) ON DELETE CASCADE',
+            }
+        ]
+        ,
         [virtual_networks => {
                 id => 'integer PRIMARY KEY AUTO_INCREMENT',
                 ,id_vm => 'integer NOT NULL references `vms` (`id`) ON DELETE CASCADE',
@@ -2888,6 +2910,7 @@ sub _upgrade_tables {
     $self->_upgrade_table('domains','has_backups','int not null default 0');
     $self->_upgrade_table('domains','auto_compact','int default NULL');
     $self->_upgrade_table('domains','date_status_change' , 'datetime');
+    $self->_upgrade_table('domains','show_clones' , 'int not null default 1');
 
     $self->_upgrade_table('domains_network','allowed','int not null default 1');
 
@@ -3290,6 +3313,13 @@ sub create_domain {
         $base = Ravada::Domain->open($id_base)
             or confess "Unknown base id: $id_base";
         $vm = $base->_vm;
+
+        my $net_bundle = $self->_net_bundle($base, $id_owner);
+        if ($net_bundle) {
+            unlock_hash(%args);
+            $args{options}->{network} = $net_bundle->{name};
+            lock_hash(%args);
+        }
     }
     my $user = Ravada::Auth::SQL->search_by_id($id_owner)
         or confess "Error: Unkown user '$id_owner'";
@@ -4623,6 +4653,25 @@ sub _cmd_remove {
     $self->remove_domain(name => $request->args('name'), uid => $request->args('uid'));
 }
 
+sub _cmd_remove_clones($self, $request) {
+
+    my $uid = $request->args('uid');
+    my $user = Ravada::Auth::SQL->search_by_id($uid);
+
+    my $id_domain = $request->args('id_domain');
+
+    die "Error: user ".$user->name." not authorized to remove clones"
+    unless $user->is_admin();
+
+    my $domain = Ravada::Front::Domain->open($id_domain);
+    for my $clone ( $domain->clones ) {
+        Ravada::Request->remove_domain(
+            uid => $uid
+            ,name => $clone->{name}
+        );
+    }
+}
+
 sub _cmd_restore_domain($self,$request) {
     my $domain = Ravada::Domain->open($request->args('id_domain'));
     return $domain->restore(Ravada::Auth::SQL->search_by_id($request->args('uid')));
@@ -4713,22 +4762,66 @@ sub _cmd_clone($self, $request) {
 
     $args->{alias} = $alias if $alias;
 
+    my $net_bundle = $self->_net_bundle($domain, $user);
+
+    $args->{options}->{network} = $net_bundle->{name} if $net_bundle;
+
     my $clone = $domain->clone(
         name => $name
         ,%$args
     );
 
     $request->id_domain($clone->id) if $clone;
+    my $req_next = $request;
 
     Ravada::Request->start_domain(
         uid => $user->id
         ,id_domain => $clone->id
         ,remote_ip => $request->defined_arg('remote_ip')
-        ,after_request => $request->id
+        ,after_request => $req_next->id
     ) if $request->defined_arg('start');
 
 }
 
+sub _net_bundle($self, $domain, $user0) {
+    my $bundle = $domain->bundle();
+
+    return unless $bundle && exists $bundle->{private_network}
+    && $bundle->{private_network};
+
+    my $user = $user0;
+    $user = Ravada::Auth::SQL->search_by_id($user0) if !ref($user);
+
+    my ($net) = grep { $_->{id_owner} == $user->id }
+        $domain->_vm->list_virtual_networks();
+
+    return $net if $net;
+
+    my $req_new_net = Ravada::Request->new_network(
+        uid => Ravada::Utils::user_daemon->id
+        ,id_vm => $domain->_vm->id
+        ,name => $bundle->{name}."-".$user->name
+    );
+    $self->_cmd_new_network($req_new_net);
+    my $data = decode_json($req_new_net->output);
+    $req_new_net->status('done');
+
+    my $req_network = Ravada::Request->create_network(
+        uid => Ravada::Utils::user_daemon->id
+        ,id_vm => $domain->_vm->id
+        ,data => $data
+    );
+    $self->_cmd_create_network($req_network);
+    $req_network->status('done');
+
+    ($net) = grep { $_->{name} eq $data->{name} }
+        $domain->_vm->list_virtual_networks();
+
+    $domain->_vm->_update_network_db($net, {id_owner => $user->id });
+
+    return $net;
+}
+
 sub _new_clone_name($self, $base,$user) {
     my $name;
     my $alias = $base->name;
@@ -5486,7 +5579,7 @@ sub _cmd_check_storage($self, $request) {
             my $path = ''.$vm->_storage_path($storage);
             _check_mounted($path,\%fstab,\%mtab);
             my ($ok,$err) = $vm->write_file("$path/check_storage",$contents);
-            die "Error on starage pool $storage : $err. Retry.\n" if $err;
+            die "Error on storage pool $storage : $err. Retry.\n" if $err;
         }
     }
 }
@@ -5859,7 +5952,10 @@ sub _refresh_active_vms ($self) {
             next;
         }
         $active_vm{$vm->id} = 1;
-        $vm->list_virtual_networks();
+        eval {
+            $vm->list_virtual_networks();
+        };
+        warn $@ if $@;
     }
     return \%active_vm;
 }
@@ -5911,6 +6007,7 @@ sub _refresh_down_nodes($self, $request = undef ) {
         my $vm;
         eval { $vm = Ravada::VM->open($id) };
         warn $@ if $@;
+        $vm->is_active() if $vm;
     }
 }
 
@@ -6271,6 +6368,8 @@ sub _req_method {
          ,pause => \&_cmd_pause
         ,create => \&_cmd_create
         ,remove => \&_cmd_remove
+        ,remove_domain => \&_cmd_remove
+        ,remove_clones => \&_cmd_remove_clones
         ,restore_domain => \&_cmd_restore_domain
         ,resume => \&_cmd_resume
        ,dettach => \&_cmd_dettach
@@ -6525,6 +6624,7 @@ sub _enforce_limits_active($self, $request) {
 
     my %domains;
     for my $domain ($self->list_domains( active => 1 )) {
+        next if $domain->is_in_bundle();
         push @{$domains{$domain->id_owner}},$domain;
         $domain->client_status();
     }
diff --git a/lib/Ravada/Auth/SQL.pm b/lib/Ravada/Auth/SQL.pm
index e737dd168..50f0ea64f 100644
--- a/lib/Ravada/Auth/SQL.pm
+++ b/lib/Ravada/Auth/SQL.pm
@@ -1106,7 +1106,7 @@ sub can_remove_clones($self, $id_domain=undef) {
     return $self->can_do('remove_clones') if !$id_domain;
 
     my $domain = Ravada::Front::Domain->open($id_domain);
-    confess "ERROR: domain is not a base "  if !$domain->id_base;
+    confess "ERROR: domain ".$domain->name." is not a base "  if !$domain->id_base;
 
     return 1 if $self->can_remove_clone_all();
 
diff --git a/lib/Ravada/Domain.pm b/lib/Ravada/Domain.pm
index 342549496..43fdeb229 100644
--- a/lib/Ravada/Domain.pm
+++ b/lib/Ravada/Domain.pm
@@ -529,8 +529,9 @@ sub _search_already_started($self, $fast = 0) {
     $sth->execute($self->_vm->type);
     my %started;
     while (my ($id) = $sth->fetchrow) {
-        my $vm = Ravada::VM->open($id);
-        next if !$vm->enabled;
+        my $vm;
+        eval { $vm = Ravada::VM->open($id) };
+        next if !$vm || !$vm->enabled;
 
         my $vm_active;
         eval {
@@ -539,7 +540,7 @@ sub _search_already_started($self, $fast = 0) {
         my $error = $@;
         if ($error) {
             warn $error;
-            $vm->enabled(0) if !$vm->is_local;
+            $vm->enabled(0) if !$vm->is_local && !$vm->ping;
             next;
         }
         next if !$vm_active;
@@ -2069,6 +2070,8 @@ sub info($self, $user) {
         id => $self->id
         ,name => $self->name
         ,is_base => $self->is_base
+        ,is_public => $self->is_public
+        ,show_clones => $self->show_clones
         ,id_base => $self->id_base
         ,is_active => $is_active
         ,is_hibernated => $self->is_hibernated
@@ -2404,13 +2407,15 @@ sub _remove_domain_cascade($self,$user, $cascade = 1) {
         next if $instance->{id_vm} == $self->_vm->id;
         my $vm;
         eval { $vm = Ravada::VM->open($instance->{id_vm}) };
-        die $@ if $@ && $@ !~ /I can't find VM/i;
-        next if !$vm || !$vm->is_active;
+        die $@ if $@ && $@ !~ /I can't find VM ||libvirt error code: 38,/i;
         my $domain;
         $@ = '';
         eval { $domain = $vm->search_domain($domain_name) } if $vm;
         warn $@ if $@;
-        $domain->remove($user, $cascade) if $domain;
+        eval {
+            $domain->remove($user, $cascade) if $domain;
+        };
+        warn $@ if $@;
         $sth_delete->execute($instance->{id});
     }
 }
@@ -2873,6 +2878,8 @@ sub clone {
     my $volatile = delete $args{volatile};
     my $id_owner = delete $args{id_owner};
     my $alias = delete $args{alias};
+    my $options = delete $args{options};
+    my $storage = delete $args{storage};
 
     confess "ERROR: Unknown args ".join(",",sort keys %args)
         if keys %args;
@@ -2906,6 +2913,9 @@ sub clone {
     push @args_copy, ( remote_ip => $remote_ip) if $remote_ip;
     push @args_copy, ( from_pool => $from_pool) if defined $from_pool;
     push @args_copy, ( add_to_pool => $add_to_pool) if defined $add_to_pool;
+    push @args_copy, ( storage => $storage)     if $storage;
+    push @args_copy, ( options => $options)     if $options;
+
     if ( $self->volatile_clones && !defined $volatile ) {
         $volatile = 1;
     }
@@ -2956,6 +2966,7 @@ sub _copy_clone($self, %args) {
     my $id_owner = delete $args{id_owner};
     $id_owner = $user->id if (! $id_owner);
     my $alias = delete $args{alias};
+    my $options = delete $args{options};
 
     confess "ERROR: Unknown arguments ".join(",",sort keys %args)
         if keys %args;
@@ -2966,6 +2977,7 @@ sub _copy_clone($self, %args) {
     push @copy_arg, ( alias => $alias )   if $alias;
     push @copy_arg, ( memory => $memory ) if $memory;
     push @copy_arg, ( volatile => $volatile ) if $volatile;
+    push @copy_arg, ( options => $options ) if $options;
 
     $request->status("working","Copying domain ".$self->name
         ." to $name")   if $request;
@@ -3249,7 +3261,10 @@ sub _around_is_active($orig, $self) {
         }
     }
     my $is_active = 0;
+    eval {
     $is_active = $self->$orig();
+    };
+    warn $@ if $@;
 
     return $is_active if $self->readonly
         || !$self->is_known
@@ -4490,6 +4505,10 @@ sub is_public {
     return $self->_data('is_public');
 }
 
+sub show_clones($self,$value=undef) {
+    return $self->_data('show_clones',$value);
+}
+
 =head2 is_volatile
 
 Returns if the domain is volatile, so it will be removed on shutdown
@@ -5310,7 +5329,8 @@ sub _pre_clone($self,%args) {
 
     confess "ERROR: Missing user owner of new domain"   if !$user;
 
-    for (qw(is_pool start add_to_pool from_pool with_cd volatile id_owner alias)) {
+    for (qw(is_pool start add_to_pool from_pool with_cd volatile id_owner
+        alias storage options)) {
         delete $args{$_};
     }
     confess "ERROR: Unknown arguments ".join(",",sort keys %args)   if keys %args;
@@ -7712,4 +7732,29 @@ sub list_shares($self) {
     return @shares;
 }
 
+sub bundle($self) {
+    my $sth = $self->_dbh->prepare("SELECT * FROM bundles "
+        ." WHERE id IN (SELECT id_bundle FROM domains_bundle "
+        ."              WHERE id_domain=?)"
+    );
+    $sth->execute($self->id);
+    my $bundle = $sth->fetchrow_hashref;
+    return if !keys %$bundle;
+    lock_hash(%$bundle);
+    return $bundle;
+
+}
+
+sub is_in_bundle($self) {
+    my $id=( $self->id_base or $self->id);
+    my $sth = $self->_dbh->prepare("SELECT id FROM bundles "
+        ." WHERE id IN (SELECT id_bundle FROM domains_bundle "
+        ."              WHERE id_domain=?)"
+    );
+    $sth->execute($id);
+    my ($id_bundle) = $sth->fetchrow;
+    return $id_bundle;
+
+}
+
 1;
diff --git a/lib/Ravada/Domain/Void.pm b/lib/Ravada/Domain/Void.pm
index 7a07f59b2..2eae1a04f 100644
--- a/lib/Ravada/Domain/Void.pm
+++ b/lib/Ravada/Domain/Void.pm
@@ -692,7 +692,9 @@ sub list_volumes_info($self, $attribute=undef, $value=undef) {
         } else {
             $dev->{driver}->{type} = 'void';
         }
-        $dev->{storage_pool} = $self->_vm->_find_storage_pool($dev->{file});
+        $dev->{storage_pool} = $self->_vm->_find_storage_pool($dev->{file})
+        if $dev->{file};
+
         my $vol = Ravada::Volume->new(
             file => $dev->{file}
             ,info => $dev
@@ -739,7 +741,7 @@ sub _new_mac($mac='ff:54:00:a7:49:71') {
     return join(":",@macparts);
 }
 
-sub _set_default_info($self, $listen_ip=undef) {
+sub _set_default_info($self, $listen_ip=undef, $network=undef) {
     my $info = {
             max_mem => 512*1024
             ,memory => 512*1024,
@@ -754,12 +756,22 @@ sub _set_default_info($self, $listen_ip=undef) {
     $self->_set_display($listen_ip);
     my $hardware = $self->_value('hardware');
 
+    my @nets = $self->_vm->list_virtual_networks();
+    my ($net) = grep { $_->{name} eq 'default'} @nets;
+    $net = $nets[0] if !$net;
+    if ($network) {
+        ($net) = grep { $_->{name} eq $network } @nets;
+
+        die "Error: network $network not found ".join(" , ",@nets)
+        if !$net;
+    }
+
     $hardware->{network}->[0] = {
         hwaddr => $info->{mac}
         ,address => $info->{ip}
         ,type => 'nat'
         ,driver => 'virtio'
-        ,name => "net1"
+        ,name => $net->{name}
     };
     $self->_store(hardware => $hardware );
 
diff --git a/lib/Ravada/Front.pm b/lib/Ravada/Front.pm
index d949c05ca..1aacabcde 100644
--- a/lib/Ravada/Front.pm
+++ b/lib/Ravada/Front.pm
@@ -130,14 +130,14 @@ Returns: listref of machines
 
 sub list_machines_user($self, $user, $access_data={}) {
     my $sth = $CONNECTOR->dbh->prepare(
-        "SELECT id,name,alias,is_public, description, screenshot, id_owner, is_base, date_changed"
+        "SELECT id,name,alias,is_public, description, screenshot, id_owner, is_base, date_changed, show_clones"
         ." FROM domains "
         ." WHERE ( is_base=1 OR ( id_base IS NULL AND id_owner=?))"
         ." ORDER BY alias"
     );
-    my ($id, $name, $alias, $is_public, $description, $screenshot, $id_owner, $is_base, $date_changed);
+    my ($id, $name, $alias, $is_public, $description, $screenshot, $id_owner, $is_base, $date_changed, $show_clones);
     $sth->execute($user->id);
-    $sth->bind_columns(\($id, $name, $alias, $is_public, $description, $screenshot, $id_owner, $is_base, $date_changed));
+    $sth->bind_columns(\($id, $name, $alias, $is_public, $description, $screenshot, $id_owner, $is_base, $date_changed,$show_clones));
 
     my $bookings_enabled = $self->setting('/backend/bookings');
     my @list;
@@ -154,7 +154,13 @@ sub list_machines_user($self, $user, $access_data={}) {
         push @clones,$self->_search_shared($id, $user->id);
 
         my ($clone) = ($clones[0] or undef);
-        next unless $clone || $user->is_admin || ($is_public && $user->allowed_access($id)) || ($id_owner == $user->id);
+
+        next unless
+        $clone && $show_clones
+        || $user->is_admin
+        || ($is_public && $user->allowed_access($id))
+        || ($id_owner == $user->id);
+
         $name = $alias if defined $alias;
         my $base = { id => $id, name => Encode::decode_utf8($name)
             , alias => Encode::decode_utf8($alias or $name)
@@ -322,7 +328,7 @@ sub list_domains($self, %args) {
 
     my $query = "SELECT d.name,d.alias, d.id, id_base, is_base, id_vm, status, is_public "
         ."      ,vms.name as node , is_volatile, client_status, id_owner "
-        ."      ,comment, is_pool"
+        ."      ,comment, is_pool, show_clones"
         ."      ,d.date_changed"
         ." FROM domains d LEFT JOIN vms "
         ."  ON d.id_vm = vms.id ";
@@ -1873,6 +1879,58 @@ sub upload_users($self, $users, $type, $create=0) {
     return ($found, $count, \@error);
 }
 
+=head2 create_bundle
+
+Creates a new bundle
+
+Arguments: name
+
+=cut
+
+sub create_bundle($self,$name) {
+    my $sth = $self->_dbh->prepare(
+        "INSERT INTO bundles (name) values (?)"
+    );
+    $sth->execute($name);
+
+    $sth = $self->_dbh->prepare(
+        "SELECT id FROM bundles WHERE name=?"
+    );
+    $sth->execute($name);
+    my ($id)= $sth->fetchrow;
+    return $id;
+}
+
+=head2 bundle_private_network
+
+Sets the bundle network to private
+
+Arguments : id_bundle, value ( defaults 1 )
+
+=cut
+
+sub bundle_private_network($self, $id_bundle, $value=1){
+    my $sth = $self->_dbh->prepare(
+        "UPDATE bundles set private_network=? WHERE id=?");
+    $sth->execute($value, $id_bundle);
+}
+
+=head2 add_to_bundle
+
+Adds a domain to a bundle
+
+Arguments : id_bundle, id_domain
+
+=cut
+
+sub add_to_bundle ($self, $id_bundle, $id_domain){
+    my $sth = $self->_dbh->prepare(
+        "INSERT INTO domains_bundle (id_bundle, id_domain ) VALUES(?,?)"
+    );
+    $sth->execute($id_bundle, $id_domain);
+
+}
+
 =head2 version
 
 Returns the version of the main module
diff --git a/lib/Ravada/Request.pm b/lib/Ravada/Request.pm
index 4040031bb..74f0e3c18 100644
--- a/lib/Ravada/Request.pm
+++ b/lib/Ravada/Request.pm
@@ -105,6 +105,8 @@ our %VALID_ARG = (
                 ,start => 2,
                 ,remote_ip => 2
                 ,with_cd => 2
+                ,storage => 2
+                ,options => 2
     }
     ,change_owner => {uid => 1, id_domain => 1}
     ,add_hardware => {uid => 1, id_domain => 1, name => 1, number => 2, data => 2 }
@@ -174,6 +176,7 @@ our %VALID_ARG = (
     ,remove_network => { uid => 1, id => 1, id_vm => 2, name => 2 }
     ,change_network => { uid => 1, data => 1 }
 
+    ,remove_clones => { uid => 1, id_domain => 1 }
 );
 
 $VALID_ARG{shutdown} = $VALID_ARG{shutdown_domain};
@@ -707,7 +710,7 @@ sub _duplicated_request($self=undef, $command=undef, $args=undef) {
     }
     confess "Error: missing command " if !$command;
     #    delete $args_d->{uid} unless $command eq 'clone';
-    delete $args_d->{uid} if $command eq 'set_base_vm';
+    delete $args_d->{uid} if $command =~ /(cleanup|refresh_vms|set_base_vm)/;
     delete $args_d->{at};
     delete $args_d->{status};
     delete $args_d->{timeout};
@@ -823,8 +826,10 @@ sub _new_request {
     ." WHERE id=?");
     $sth->execute($self->{id});
 
-
-    my $request = $self->open($self->{id});
+    my $request;
+    eval { $request = $self->open($self->{id}) };
+    warn $@ if $@ && $@ !~ /I can't find id=/;
+    return if !$request;
     $request->_validate();
     $request->status('requested') if $request->status ne'done';
 
diff --git a/lib/Ravada/VM.pm b/lib/Ravada/VM.pm
index d958a6355..3ba8bb4ed 100644
--- a/lib/Ravada/VM.pm
+++ b/lib/Ravada/VM.pm
@@ -234,6 +234,7 @@ sub open {
     $args{security} = decode_json($row->{security}) if $row->{security};
 
     my $vm = $self->new(%args);
+    return if !$vm || !$vm->vm;
     $VM{$args{id}} = $vm unless $args{readonly};
     return $vm;
 
@@ -555,6 +556,7 @@ sub _around_create_domain {
     $domain->display($owner)    if $domain->is_active;
 
     $domain->is_pool(1) if $add_to_pool;
+
     return $domain;
 }
 
@@ -846,7 +848,7 @@ sub _ip_a($self, $dev) {
     my ($out, $err) = $self->run_command_cache("/sbin/ip","-o","a");
     die $err if $err;
     for my $line ( split /\n/,$out) {
-        my ($ip) = $line =~ m{^\d+:\s+$dev.*inet (.*?)/};
+        my ($ip) = $line =~ m{^\d+:\s+$dev.*inet\d* (.*?)/};
         return $ip if $ip;
     }
     warn "Warning $dev not found in active interfaces";
@@ -963,13 +965,13 @@ sub _check_require_base {
     delete $args{start};
     delete $args{remote_ip};
 
-    delete @args{'_vm','name','vm', 'memory','description','id_iso','listen_ip','spice_password','from_pool', 'volatile', 'alias','storage', 'options'};
+    delete @args{'_vm','name','vm', 'memory','description','id_iso','listen_ip','spice_password','from_pool', 'volatile', 'alias','storage', 'options', 'network'};
 
     confess "ERROR: Unknown arguments ".join(",",keys %args)
         if keys %args;
 
     my $base = Ravada::Domain->open($id_base);
-    my %ignore_requests = map { $_ => 1 } qw(clone refresh_machine set_base_vm start_clones shutdown_clones shutdown force_shutdown refresh_machine_ports set_time open_exposed_ports manage_pools screenshot);
+    my %ignore_requests = map { $_ => 1 } qw(clone refresh_machine set_base_vm start_clones shutdown_clones shutdown force_shutdown refresh_machine_ports set_time open_exposed_ports manage_pools screenshot remove_clones);
     my @requests;
     for my $req ( $base->list_requests ) {
         push @requests,($req) if !$ignore_requests{$req->command};
@@ -1502,6 +1504,7 @@ sub _update_network_db($self, $old, $new0) {
         $sql = "UPDATE virtual_networks set $sql WHERE id=?";
         my $sth = $self->_dbh->prepare($sql);
         my @values = map { $new->{$_} } sort keys %$new;
+
         $sth->execute(@values, $id);
     }
 }
diff --git a/lib/Ravada/VM/KVM.pm b/lib/Ravada/VM/KVM.pm
index c6a25320f..f08557677 100644
--- a/lib/Ravada/VM/KVM.pm
+++ b/lib/Ravada/VM/KVM.pm
@@ -1245,6 +1245,11 @@ sub _domain_create_from_base {
     my $volatile = $base->volatile_clones;
     $volatile = delete $args{volatile} if exists $args{volatile} && defined $args{volatile};
 
+    my $options = delete $args{options};
+    my $network = delete $options->{network};
+
+    die "Error: I can't set more options ".Dumper($options) if keys %$options;
+
     my $vm = $self->vm;
     my $storage = $self->storage_pool;
 
@@ -1262,6 +1267,8 @@ sub _domain_create_from_base {
 
     _xml_modify_disk($xml, \@device_disk);#, \@swap_disk);
 
+    $self->_xml_set_network($xml, $network) if $network;
+
     my ($domain, $spice_password)
         = $self->_domain_create_common($xml,%args, is_volatile=>$volatile, base => $base);
     $domain->_insert_db(name=> $args{name}, id_base => $base->id, id_owner => $args{id_owner}
@@ -1878,8 +1885,9 @@ sub _xml_modify_options($self, $doc, $options=undef) {
 }
 
 sub _xml_set_network($self, $doc, $network) {
-    my ($net_source) = $doc->findnodes('/domain/devices/interface/source');
-    $net_source->setAttribute('network' => $network);
+    for my $net_source ( $doc->findnodes('/domain/devices/interface/source')) {
+        $net_source->setAttribute('network' => $network);
+    }
 }
 
 sub _xml_set_arch($self, $doc, $arch) {
@@ -2984,8 +2992,11 @@ sub list_virtual_networks($self) {
     for my $net ($self->vm->list_all_networks()) {
         my $doc = XML::LibXML->load_xml(string => $net->get_xml_description);
         my ($ip_doc) = $doc->findnodes("/network/ip");
-        my $ip = $ip_doc->getAttribute('address');
-        my $netmask = $ip_doc->getAttribute('netmask');
+        my ($ip, $netmask) = ('','');
+        if ($ip_doc) {
+            $ip = $ip_doc->getAttribute('address');
+            $netmask = $ip_doc->getAttribute('netmask');
+        }
         my $data= {
             is_active => $net->is_active()
             ,autostart => $net->get_autostart()
@@ -2996,13 +3007,15 @@ sub list_virtual_networks($self) {
             ,ip_netmask => $netmask
             ,internal_id => ''.$net->get_uuid_string
         };
-        my ($dhcp_range) = $ip_doc->findnodes("dhcp/range");
-        my ($start,$end);
-        if ($dhcp_range) {
-            $start = $dhcp_range->getAttribute('start');
-            $end = $dhcp_range->getAttribute('end');
-            $data->{dhcp_start} = $start if defined $start;
-            $data->{dhcp_end} = $end if defined $end;
+        if ($ip_doc) {
+            my ($dhcp_range) = $ip_doc->findnodes("dhcp/range");
+            my ($start,$end);
+            if ($dhcp_range) {
+                $start = $dhcp_range->getAttribute('start');
+                $end = $dhcp_range->getAttribute('end');
+                $data->{dhcp_start} = $start if defined $start;
+                $data->{dhcp_end} = $end if defined $end;
+            }
         }
         push @networks,($data);
     }
@@ -3019,7 +3032,16 @@ sub new_network($self, $name='net') {
     );
     my $new = {ip_netmask => '255.255.255.0'};
     for my $field ( keys %base) {
-        my %old = map { $_->{$field} => 1 } @networks;
+        my %old;
+        for my $current (@networks ) {
+            my $value = $current->{$field};
+            $old{$value}=1;
+            if ($field eq 'ip_address') {
+                $value =~ s/(.*)\.\d+$/$1/;
+                $old{$value}=1;
+            }
+
+        }
         my ($last) = reverse sort keys %old;
         my ($z,$n) = $last =~ /.*?(0*)(\d+)/;
         $z=$last if !defined $z;
@@ -3033,12 +3055,17 @@ sub new_network($self, $name='net') {
         }
         my $value;
         for ( 0 .. 255 ) {
+            my $value_ip;
             if (ref($template)) {
-                $value = $template->[0].$n.$template->[2]
+                $value = $template->[0].$n.$template->[2];
+                if ($field eq 'ip_address') {
+                    $value_ip = $template->[0].$n;
+                }
             } else {
                 $value = $template.$n;
             }
-            last if !exists $old{$value};
+            last if !exists $old{$value}
+            && (!defined $value_ip || !exists $old{$value_ip});
             $n++;
         }
         $new->{$field} = $value;
diff --git a/lib/Ravada/VM/Void.pm b/lib/Ravada/VM/Void.pm
index 5e562c56a..243675334 100644
--- a/lib/Ravada/VM/Void.pm
+++ b/lib/Ravada/VM/Void.pm
@@ -97,6 +97,10 @@ sub create_domain {
     my $id = delete $args{id};
     my $storage = delete $args{storage};
 
+    my $options = delete $args{options};
+    my $network;
+    $network = $options->{network} if $options && exists $options->{network};
+
     my $domain = Ravada::Domain::Void->new(
                                            %args
                                            , domain => $args{name}
@@ -110,7 +114,8 @@ sub create_domain {
     return $domain if $out && exists $args{config};
 
     die "Error: Domain $args{name} already exists " if $out;
-    $domain->_set_default_info($listen_ip);
+
+    $domain->_set_default_info($listen_ip, $network);
     $domain->_store( autostart => 0 );
     $domain->_store( is_active => $active );
     $domain->set_memory($args{memory}) if $args{memory};
@@ -167,6 +172,11 @@ sub create_domain {
         my $drivers = {};
         $drivers = $domain_base->_value('drivers');
         $domain->_store( drivers => $drivers );
+        if ( $network ) {
+            for my $index ( 0 .. scalar(@{$clone_hw->{network}})-1) {
+                $domain->change_hardware('network', $index ,{name => $network})
+            }
+        }
     } elsif (!exists $args{config}) {
         $storage = $self->default_storage_pool_name() if !$storage;
         my ($vda_name) = "$args{name}-vda-".Ravada::Utils::random_name(4).".void";
diff --git a/lib/Ravada/WebSocket.pm b/lib/Ravada/WebSocket.pm
index 96ae5a663..b1398df17 100644
--- a/lib/Ravada/WebSocket.pm
+++ b/lib/Ravada/WebSocket.pm
@@ -238,8 +238,7 @@ sub _list_host_devices($rvd, $args) {
 
     my @found;
     while (my $row = $sth->fetchrow_hashref) {
-        $row->{devices} = decode_json($row->{devices}) if $row->{devices};
-        $row->{_domains} = _list_domains_with_device($rvd, $row->{id});
+        _list_domains_with_device($rvd, $row);
         push @found, $row;
         next unless _its_been_a_while_channel($args->{channel});
         my $req = Ravada::Request->list_host_devices(
@@ -250,17 +249,65 @@ sub _list_host_devices($rvd, $args) {
     return \@found;
 }
 
-sub _list_domains_with_device($rvd,$id_hd) {
-    my $sth=$rvd->_dbh->prepare("SELECT d.name FROM domains d,host_devices_domain hdd"
+sub _list_domains_with_device($rvd,$row) {
+    my $id_hd = $row->{id};
+
+    my %devices;
+    eval {
+        my $devices = decode_json($row->{devices});
+        %devices = map { $_ => { name => $_ } } @$devices;
+    } if $row->{devices};
+    my $sth=$rvd->_dbh->prepare("SELECT d.id,d.name,d.is_base, d.status, l.id, l.name "
+        ." FROM host_devices_domain hdd, domains d"
+        ." LEFT JOIN host_devices_domain_locked l"
+        ."    ON d.id=l.id_domain "
         ." WHERE  d.id= hdd.id_domain "
         ."  AND hdd.id_host_device=?"
+        ."  ORDER BY d.name"
     );
     $sth->execute($id_hd);
+    my ( @domains, @bases);
+    while ( my ($id,$name,$is_base, $status, $is_locked, $device) = $sth->fetchrow ) {
+        $is_locked = 0 if !$is_locked || $status ne 'active';
+        $device = '' if !$device;
+        my $domain = {     id => $id       ,name => $name, is_locked => $is_locked
+                      ,is_base => $is_base ,device => $device
+        };
+        $devices{$device}->{domain} = $domain if exists $devices{$device} && $is_locked;
+        if ($is_base) {
+            push @bases, ($domain);
+        } else {
+            push @domains, ($domain);
+        }
+    }
+    for my $dev ( values %devices ) {
+        _get_domain_with_device($rvd, $dev);
+    }
+
+    $row->{_domains} = \@domains;
+    $row->{_bases} = \@bases;
+    $row->{devices} = [values %devices];
+}
+
+sub _get_domain_with_device($rvd, $dev) {
+    my $sql =
+        "SELECT d.id, d.name, d.is_base, d.status "
+        ." FROM host_devices_domain_locked l, domains d "
+        ." WHERE l.id_domain = d.id "
+        ."   AND l.name=?"
+        ;
+
+    my $sth = $rvd->_dbh->prepare($sql);
+    $sth->execute($dev->{name});
     my @domains;
-    while ( my ($name) = $sth->fetchrow ) {
-        push @domains,($name);
+    while ( my ($id,$name,$is_base, $status, $is_locked, $device) = $sth->fetchrow ) {
+        $is_locked = 0 if !$is_locked || $status ne 'active';
+        $device = '' if !$device;
+        my $domain = {     id => $id       ,name => $name, is_locked => $is_locked
+                      ,is_base => $is_base ,device => $device
+        };
+        $dev->{domain} = $domain;# if $is_locked;
     }
-    return \@domains;
 }
 
 sub _list_requests($rvd, $args) {
diff --git a/public/js/ravada.js b/public/js/ravada.js
index 258e43de5..34f2b1404 100644
--- a/public/js/ravada.js
+++ b/public/js/ravada.js
@@ -322,6 +322,7 @@
             $scope.searching_ldap_attributes = true;
             $scope.shared_user_found=false;
             $scope.storage_pools=['default'];
+            $scope.shared_user_count = -1
 
             $scope.getUnixTimeFromDate = function(date) {
                 date = (date instanceof Date) ? date : date ? new Date(date) : new Date();
diff --git a/script/rvd_front b/script/rvd_front
index fadf3e42c..23369e6ec 100644
--- a/script/rvd_front
+++ b/script/rvd_front
@@ -1074,13 +1074,20 @@ get '/machine/view/(:id).(:type)' => sub {
     my ($domain) = _search_requested_machine($c);
     return access_denied($c)    if !$domain;
 
-    return access_denied($c) unless $USER->is_admin
-                              || $domain->id_owner == $USER->id
-                              || $USER->can_view_all
-                              || $USER->can_start_machine($domain)
-                              ;
-
-    return view_machine($c);
+    return view_machine($c) if $USER->is_admin
+                              || $USER->can_view_all;
+
+    if ( $domain->id_owner == $USER->id || $USER->can_start_machine($domain) ) {
+        if ( $domain->id_base) {
+            my $base = Ravada::Front::Domain->open($domain->id_base);
+            if ($base->is_public || $base->show_clones()) {
+                return view_machine($c);
+            }
+        } else {
+                return view_machine($c);
+        }
+    }
+    return access_denied($c);
 };
 
 any '/machine/clone/(:id).(:type)' => sub {
@@ -1091,6 +1098,8 @@ any '/machine/clone/(:id).(:type)' => sub {
     if ( $USER && $USER->can_clone() && !$USER->is_temporary() ) {
         my $base = Ravada::Front::Domain->open($c->stash('id'));
         if (!$base->is_public) {
+            return access_denied($c) if !$base->show_clones;
+
             my @clones = $base->clones();
             my ($clone) = grep { $_->{id_owner} == $USER->id } @clones;
             return access_denied($c) if !$clone;
diff --git a/t/30_request.t b/t/30_request.t
index 9297b5248..ee9a51739 100644
--- a/t/30_request.t
+++ b/t/30_request.t
@@ -324,6 +324,22 @@ sub test_force() {
 
 }
 
+sub test_refresh_vms() {
+    my $req = Ravada::Request->refresh_vms();
+    ok($req);
+    wait_request( debug => 0);
+    is($req->error, '') or exit;
+
+    $req->status('waiting');
+
+    my $req1 = Ravada::Request->refresh_vms();
+    ok($req1);
+    is($req1->id, $req->id) or exit;
+    wait_request( debug => 0);
+    is($req1->error, '') or exit;
+
+}
+
 sub test_dupe_open_exposed($vm) {
     my $req1 = Ravada::Request->open_exposed_ports(
         id_domain => 1
@@ -351,6 +367,8 @@ remove_old_disks();
 
 test_force();
 
+test_refresh_vms();
+
 for my $vm_name ( vm_names() ) {
     my $vm;
     eval {
@@ -379,6 +397,11 @@ for my $vm_name ( vm_names() ) {
     
         my $domain_base = test_req_create_base($vm);
         if ($domain_base) {
+            my $req_rm = Ravada::Request->remove_clones(
+                uid => user_admin->id
+                ,id_domain => $domain_base->id
+                ,at => time + 300
+            );
             $domain_base->is_public(1);
             is ($domain_base->_vm->readonly, 0) or next;
 
@@ -392,6 +415,9 @@ for my $vm_name ( vm_names() ) {
             is(scalar @{rvd_front->list_domains( id => $domain_clone->id)}, 0) or exit;
 
             test_req_many_clones($vm, $domain_base);
+            is($req_rm->status,'requested');
+            $req_rm->at(time + 1);
+            wait_request(debug => 1);
             test_req_remove_domain_name($vm, $domain_base->name);
         }
 
diff --git a/t/device/10_templates.t b/t/device/10_templates.t
index 0776258f5..b74df5022 100644
--- a/t/device/10_templates.t
+++ b/t/device/10_templates.t
@@ -583,14 +583,102 @@ sub _mangle_dom_hd_kvm($domain) {
     $domain->reload_config($xml);
 }
 
-sub test_templates_change_devices($vm) {
-    return if $vm->type ne 'Void';
+sub _create_host_devices($vm, $n) {
+    if ($vm->type eq 'Void') {
+        return _create_host_devices_void($vm,$n);
+    } elsif ($vm->type eq 'KVM') {
+        return _create_host_devices_kvm($vm,$n);
+    } else {
+        die "Error: I don't know how to create host devices for ".$vm->type;
+    }
+}
+
+sub _create_host_devices_void($vm, $n) {
+    my $path  = "/var/tmp/$</ravada/dev";
+    my @hds;
+    for my $count ( 1 .. $n ) {
+        my $hd = _mock_hd($vm , $path);
+        push @hds,($hd);
+    }
+    return @hds;
+}
+
+sub _create_host_devices_kvm($vm,$n) {
+    my $templates = Ravada::HostDevice::Templates::list_templates($vm->type);
+    ok(@$templates);
+
+    my ($template) = grep { $_->{list_command} =~ /lspci/ } @$templates;
+
+    my @hds;
+    for ( 1 .. $n ) {
+        my $id_hd = $vm->add_host_device(template => $template->{name});
+        my $hd = Ravada::HostDevice->search_by_id($id_hd);
+
+        my $config = config_host_devices('pci');
+        $hd->_data('list_filter' => $config);
+        push @hds,($hd);
+    }
+
+    return @hds;
+
+}
+
+sub test_frontend_list($vm) {
+
+    my ($hd1, $hd2) = _create_host_devices($vm, 2);
+
+    if (scalar($hd1->list_devices) != scalar($hd2->list_devices)) {
+        die "Error: expecting the same count of devices in both mock hds";
+    }
+
+    my $domain = _create_domain_hd($vm, $hd1);
+    $domain->start(user_admin);
+
+    my $ws_args = {
+            channel => '/'.$vm->id
+            ,login => user_admin->name
+    };
+    my $front_devices = Ravada::WebSocket::_list_host_devices(rvd_front(), $ws_args);
+    is(scalar(@$front_devices),2) or exit;
+
+    my ($dev_attached) = ($domain->list_host_devices_attached);
+
+    my $found=0;
+    for my $fd ( @$front_devices ) {
+        for my $dev ( @{$fd->{devices}} ) {
+            if ($dev->{name} eq $dev_attached->{name}) {
+                ok($dev->{domain} , "Expecting domains listed in ".$dev->{name}) or next;
+                is($dev->{domain}->{id}, $domain->id,"Expecting ".$domain->name." attached in ".$dev->{name});
+                $found++ if $dev->{domain}->{id} == $domain->id;
+            }
+        }
+    }
+    is($found,2) or die Dumper($front_devices);
+
+    remove_domain($domain);
+
+    _remove_host_devices($vm);
+}
+
+sub _mock_hd($vm, $path) {
+
+    my ($template, $name) = _mock_devices($vm , $path);
+
+    my $id_hd = $vm->add_host_device(template => $template->{name});
+    my $hd = Ravada::HostDevice->search_by_id($id_hd);
+
+    $hd->_data(list_command => "ls $path");
+    $hd->_data(list_filter => $name);
+
+    return $hd;
+}
+
+sub _mock_devices($vm, $path) {
     my $templates = Ravada::HostDevice::Templates::list_templates($vm->type);
     ok(@$templates);
 
     my ($template) = grep { $_->{list_command} eq 'lsusb' } @$templates;
 
-    my $path  = "/var/tmp/$</ravada/dev";
     make_path($path) if !-e $path;
 
     my $name = base_domain_name()." Mock_device ID";
@@ -610,6 +698,15 @@ sub test_templates_change_devices($vm) {
         close $out;
     }
 
+    return ($template, $name);
+}
+
+sub test_templates_change_devices($vm) {
+    return if $vm->type ne 'Void';
+
+    my $path  = "/var/tmp/$</ravada/dev";
+    my ($template, $name) = _mock_devices($vm, $path);
+
     $vm->add_host_device(template => $template->{name});
     my ($hostdev) = $vm->list_host_devices();
     $hostdev->_data(list_command => "ls $path");
@@ -666,7 +763,11 @@ sub test_templates_change_filter($vm) {
 
         $domain->remove(user_admin);
     }
+    _remove_host_devices($vm);
 
+}
+
+sub _remove_host_devices($vm) {
     for my $hd ( $vm->list_host_devices ) {
         my $req = Ravada::Request->remove_host_device(
             uid => user_admin->id
@@ -676,7 +777,6 @@ sub test_templates_change_filter($vm) {
         is($req->status,'done');
         is($req->error, '') or exit;
     }
-
 }
 
 sub test_templates($vm) {
@@ -705,8 +805,11 @@ sub test_templates($vm) {
 
         _fix_host_device($host_device) if $vm->type eq 'KVM';
 
+        warn 11;
         test_hd_in_domain($vm, $host_device);
+        warn 12;
         test_hd_dettach($vm, $host_device);
+        warn 13;
 
         my $req = Ravada::Request->list_host_devices(
             uid => user_admin->id
@@ -833,13 +936,26 @@ for my $vm_name ( vm_names()) {
 
         diag("Testing host devices in $vm_name");
 
+        test_frontend_list($vm);
+
+        warn 1;
+
         test_templates_gone_usb_2($vm);
+
+        warn 2;
+
         test_templates_gone_usb($vm);
+        warn 3;
         test_templates_changed_usb($vm);
 
+        warn 4;
         test_templates_start_nohd($vm);
+        warn 5;
         test_templates_change_filter($vm);
+
+        warn 6;
         test_templates($vm);
+        warn 7;
         test_templates_change_devices($vm);
 
     }
diff --git a/t/front/40_list_domains.t b/t/front/40_list_domains.t
index 9068fa289..248a1eb1a 100644
--- a/t/front/40_list_domains.t
+++ b/t/front/40_list_domains.t
@@ -187,6 +187,75 @@ sub test_list_bases_many_clones($vm) {
 
 }
 
+sub test_list_bases_show_clones($vm) {
+    my $base = create_domain($vm);
+
+    my $list = rvd_front->list_machines_user(user_admin);
+
+    $base->prepare_base(user_admin);
+
+    my $clone1 = $base->clone(user => user_admin
+    , name => new_domain_name);
+
+    $list = rvd_front->list_machines_user(user_admin);
+    my ($entry) = grep { $_->{id} == $base->id} @$list;
+
+    ok($entry);
+
+    $base->is_public(0);
+    $base->show_clones(1);
+
+    $list = rvd_front->list_machines_user(user_admin);
+    ($entry) = grep { $_->{id} == $base->id} @$list;
+    ok($entry);
+
+    $base->show_clones(0);
+
+    $list = rvd_front->list_machines_user(user_admin);
+    ($entry) = grep { $_->{id} == $base->id} @$list;
+    ok($entry);
+
+    my $user = create_user();
+    $list = rvd_front->list_machines_user($user);
+    ($entry) = grep { $_->{id} == $base->id} @$list;
+    ok(!$entry);
+
+    $base->is_public(1);
+    $list = rvd_front->list_machines_user($user);
+    ($entry) = grep { $_->{id} == $base->id} @$list;
+    ok($entry);
+
+    is(scalar(@{$entry->{list_clones}}),0);
+
+    my $clone2 = $base->clone(user => $user
+    , name => new_domain_name);
+
+    $list = rvd_front->list_machines_user($user);
+    ($entry) = grep { $_->{id} == $base->id} @$list;
+    ok($entry);
+    ok($entry->{list_clones}->[0]);
+    is($entry->{list_clones}->[0]->{name},$clone2->name) or die Dumper($entry);
+    is($entry->{list_clones}->[0]->{id},$clone2->id) or die Dumper($entry);
+
+    $base->is_public(0);
+    $base->show_clones(1);
+
+    $list = rvd_front->list_machines_user($user);
+    ($entry) = grep { $_->{id} == $base->id} @$list;
+    ok($entry) or die Dumper($list);
+
+    ok($entry->{list_clones}->[0]);+    is($entry->{list_clones}->[0]->{name},$clone2->name) or die Dumper($entry);
+    is($entry->{list_clones}->[0]->{id},$clone2->id) or die Dumper($entry);
+
+    $base->show_clones(0);
+
+    $list = rvd_front->list_machines_user($user);
+    ($entry) = grep { $_->{id} == $base->id} @$list;
+    ok(!$entry);
+
+    remove_domain($base);
+}
+
 #########################################################
 
 remove_old_domains();
@@ -219,6 +288,8 @@ for my $vm_name (reverse sort @VMS) {
 
         use_ok($CLASS);
 
+        test_list_bases_show_clones($vm);
+
         test_list_bases_many_clones($vm);
 
         my $domain = test_create_domain($vm_name);
diff --git a/t/kvm/pcie.t b/t/kvm/pcie.t
new file mode 100644
index 000000000..6bb7fa5e7
--- /dev/null
+++ b/t/kvm/pcie.t
@@ -0,0 +1,261 @@
+use warnings;
+use strict;
+
+use Carp qw(confess);
+use Data::Dumper;
+use Test::More;
+
+use lib 't/lib';
+use Test::Ravada;
+
+no warnings "experimental::signatures";
+use feature qw(signatures);
+
+#################################################################
+
+sub test_pcie($vm) {
+    my $base = create_domain_v2(vm => $vm, id_iso => search_id_iso('Alpine%64'));
+    $base->prepare_base(user_admin);
+
+    my $clone = Ravada::Request->clone(
+            id_domain => $base->id
+            ,uid => user_admin->id
+    );
+    wait_request();
+}
+
+sub test_pcie_2($vm) {
+
+    my $name = new_domain_name();
+    my $device_disk = $vm->create_volume(
+        name => $name
+        ,size => 1024 * 1024
+        ,xml => "etc/xml/dsl-volume.xml");
+
+    my $string=<<EOT;
+<domain type='kvm' id='50'>
+  <name>$name</name>
+  <uuid>55b671a7-77c8-4447-b21e-1771055f8bff</uuid>
+  <memory unit='KiB'>135168</memory>
+  <currentMemory unit='KiB'>135168</currentMemory>
+  <vcpu placement='static'>1</vcpu>
+  <resource>
+    <partition>/machine</partition>
+  </resource>
+  <sysinfo type='smbios'>
+    <oemStrings>
+      <entry>hostname: $name</entry>
+    </oemStrings>
+  </sysinfo>
+  <os>
+    <type arch='x86_64' machine='pc-q35-6.2'>hvm</type>
+    <loader readonly='yes' type='pflash'>/usr/share/OVMF/OVMF_CODE_4M.fd</loader>
+    <nvram template='/usr/share/OVMF/OVMF_VARS_4M.fd'>/var/lib/libvirt/qemu/nvram/$name.fd</nvram>
+    <smbios mode='sysinfo'/>
+  </os>
+  <features>
+    <acpi/>
+    <apic/>
+  </features>
+  <cpu mode='custom' match='exact' check='full'>
+    <model fallback='forbid'>qemu64</model>
+    <feature policy='require' name='x2apic'/>
+    <feature policy='require' name='hypervisor'/>
+    <feature policy='require' name='lahf_lm'/>
+    <feature policy='disable' name='svm'/>
+  </cpu>
+  <clock offset='utc'>
+    <timer name='rtc' tickpolicy='catchup'/>
+    <timer name='pit' tickpolicy='delay'/>
+    <timer name='hpet' present='no'/>
+  </clock>
+  <on_poweroff>destroy</on_poweroff>
+  <on_reboot>restart</on_reboot>
+  <on_crash>destroy</on_crash>
+  <pm>
+    <suspend-to-mem enabled='no'/>
+    <suspend-to-disk enabled='no'/>
+  </pm>
+  <devices>
+    <emulator>/usr/bin/kvm-spice</emulator>
+    <controller type='pci' index='0' model='pcie-root'>
+      <alias name='pcie.0'/>
+    </controller>
+    <controller type='pci' index='1' model='pcie-root-port'>
+      <model name='pcie-root-port'/>
+      <target chassis='1' port='0x8'/>
+      <alias name='pci.1'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x01' function='0x0' multifunction='on'/>
+    </controller>
+    <controller type='pci' index='2' model='pcie-root-port'>
+      <model name='pcie-root-port'/>
+      <target chassis='2' port='0x9'/>
+      <alias name='pci.2'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x01' function='0x1'/>
+    </controller>
+    <controller type='pci' index='3' model='pcie-root-port'>
+      <model name='pcie-root-port'/>
+      <target chassis='3' port='0xa'/>
+      <alias name='pci.3'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x01' function='0x2'/>
+    </controller>
+    <controller type='pci' index='4' model='pcie-root-port'>
+      <model name='pcie-root-port'/>
+      <target chassis='4' port='0xb'/>
+      <alias name='pci.4'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x01' function='0x3'/>
+    </controller>
+    <controller type='virtio-serial' index='0'>
+      <alias name='virtio-serial0'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x06' function='0x0'/>
+    </controller>
+    <controller type='usb' index='0' model='qemu-xhci'>
+      <alias name='usb'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x08' function='0x0'/>
+    </controller>
+    <controller type='sata' index='0'>
+      <alias name='ide'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x1f' function='0x2'/>
+    </controller>
+    <interface type='network'>
+      <mac address='52:54:00:c2:ca:7a'/>
+      <source network='default' portid='6ece46b8-9b93-4ba8-9a5c-771087abbf3c' bridge='virbr0'/>
+      <target dev='vnet48'/>
+      <model type='rtl8139'/>
+      <alias name='net0'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x03' function='0x0'/>
+    </interface>
+    <serial type='pty'>
+      <source path='/dev/pts/14'/>
+      <target type='isa-serial' port='0'>
+        <model name='isa-serial'/>
+      </target>
+      <alias name='serial0'/>
+    </serial>
+    <console type='pty' tty='/dev/pts/14'>
+      <source path='/dev/pts/14'/>
+      <target type='serial' port='0'/>
+      <alias name='serial0'/>
+    </console>
+    <channel type='spicevmc'>
+      <target type='virtio' name='com.redhat.spice.0' state='disconnected'/>
+      <alias name='channel0'/>
+      <address type='virtio-serial' controller='0' bus='0' port='1'/>
+    </channel>
+    <channel type='unix'>
+      <source mode='bind' path='/var/lib/libvirt/qemu/channel/target/domain-50-tst_pcie/org.qemu.guest_agent.0'/>
+      <target type='virtio' name='org.qemu.guest_agent.0' state='disconnected'/>
+      <alias name='channel1'/>
+      <address type='virtio-serial' controller='0' bus='0' port='2'/>
+    </channel>
+    <input type='mouse' bus='ps2'>
+      <alias name='input0'/>
+    </input>
+    <input type='keyboard' bus='ps2'>
+      <alias name='input1'/>
+    </input>
+    <graphics type='spice' port='5901' autoport='yes'>
+      <listen type='address'/>
+      <image compression='auto_glz'/>
+      <jpeg compression='auto'/>
+      <zlib compression='auto'/>
+      <playback compression='on'/>
+      <streaming mode='filter'/>
+    </graphics>
+    <sound model='ich6'>
+      <alias name='sound0'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x04' function='0x0'/>
+    </sound>
+    <audio id='1' type='spice'/>
+    <video>
+      <model type='qxl' ram='65536' vram='65536' vgamem='16384' heads='1' primary='yes'/>
+      <alias name='video0'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x02' function='0x0'/>
+    </video>
+    <redirdev bus='usb' type='spicevmc'>
+      <alias name='redir0'/>
+      <address type='usb' bus='0' port='1'/>
+    </redirdev>
+    <redirdev bus='usb' type='spicevmc'>
+      <alias name='redir1'/>
+      <address type='usb' bus='0' port='2'/>
+    </redirdev>
+    <redirdev bus='usb' type='spicevmc'>
+      <alias name='redir2'/>
+      <address type='usb' bus='0' port='3'/>
+    </redirdev>
+    <redirdev bus='usb' type='spicevmc'>
+      <alias name='redir3'/>
+      <address type='usb' bus='0' port='4'/>
+    </redirdev>
+    <memballoon model='virtio'>
+      <alias name='balloon0'/>
+      <address type='pci' domain='0x0000' bus='0x00' slot='0x07' function='0x0'/>
+    </memballoon>
+  </devices>
+  <seclabel type='dynamic' model='apparmor' relabel='yes'>
+    <label>libvirt-55b671a7-77c8-4447-b21e-1771055f8bc3</label>
+    <imagelabel>libvirt-55b671a7-77c8-4447-b21e-1771055f8bc3</imagelabel>
+  </seclabel>
+  <seclabel type='dynamic' model='dac' relabel='yes'>
+    <label>+64055:+132</label>
+    <imagelabel>+64055:+132</imagelabel>
+  </seclabel>
+</domain>
+EOT
+    my $xml = XML::LibXML->load_xml(string => $string);
+    Ravada::VM::KVM::_xml_modify_disk($xml,[$device_disk]);
+    my $dom;
+    eval { $dom = $vm->vm->define_domain($xml) };
+    ok(!$@,"Expecting error='' , got '".($@ or '')."'") or return
+    ok($dom,"Expecting a VM defined from string ") or return;
+
+    eval{ $dom->create };
+    ok(!$@,"Expecting error='' , got '".($@ or '')."'");
+
+    my $base = Ravada::Domain::KVM->new(domain => $dom
+                , storage => $vm->storage_pool
+                , _vm => $vm
+    );
+    $base->_insert_db(name => $name, id_owner => user_admin->id);
+
+    $base->shutdown_now(user_admin);
+
+    $base->prepare_base(user_admin);
+
+    my $req_clone = Ravada::Request->clone(
+            id_domain => $base->id
+            ,uid => user_admin->id
+    );
+    wait_request(debug => 0);
+    is($req_clone->status,'done');
+    is($req_clone->error,'') or exit;
+
+}
+
+#################################################################
+
+clean();
+for my $vm_name ( 'KVM'  ) {
+
+    SKIP: {
+    my $vm = rvd_back->search_vm($vm_name);
+
+    my $msg = "SKIPPED test: No $vm_name VM found ";
+    if ($vm_name ne 'Void' && $>) {
+            $msg = "SKIPPED: Test must run as root";
+            $vm = undef;
+    }
+
+    diag($msg)      if !$vm;
+    skip $msg,10    if !$vm;
+
+    diag("Testing $vm_name bundle");
+
+    test_pcie_2($vm);
+    test_pcie($vm);
+    }
+}
+
+end();
+done_testing();
diff --git a/t/lib/Test/Ravada.pm b/t/lib/Test/Ravada.pm
index 7ac192c18..3da2546a8 100644
--- a/t/lib/Test/Ravada.pm
+++ b/t/lib/Test/Ravada.pm
@@ -74,6 +74,7 @@ create_domain
     remove_old_domains_req
     remove_domain_and_clones_req
     remove_domain
+    remove_volatile_clones
     mojo_init
     mojo_clean
     mojo_create_domain
@@ -89,6 +90,8 @@ create_domain
 
     remove_qemu_pools
 
+    remove_networks_req
+
     mangle_volume
     test_volume_contents
     test_volume_format
@@ -728,10 +731,41 @@ sub remove_old_domains_req($wait=1, $run_request=0) {
 
 }
 
+sub remove_volatile_clones(@bases) {
+
+    for my $base0 (@bases) {
+        confess if !defined $base0;
+        my $base = $base0;
+
+        my $id = $base0->{id};
+        $id = $base0->id if !defined $id;
+
+        $base = Ravada::Front::Domain->open($id)
+        unless ref($base) =~ /^Ravada::/;
+
+        next if !$base;
+        for my $clone ($base->clones) {
+            next unless $clone->{is_volatile};
+            Ravada::Request->remove_domain(
+                    uid => user_admin->id
+                    ,name => $clone->{name}
+            );
+        }
+    }
+}
+
 sub remove_domain(@bases) {
 
-    for my $base (@bases) {
-        confess if !defined $base;
+    for my $base0 (@bases) {
+        confess if !defined $base0;
+        my $base = $base0;
+
+        my $id = $base0->{id};
+        $id = $base0->id if !defined $id;
+
+        $base = Ravada::Domain->open($id)
+        unless ref($base) =~ /^Ravada::/;
+
         for my $clone ($base->clones) {
             my $d_clone = Ravada::Domain->open($clone->{id});
             if ( $d_clone ) {
@@ -953,7 +987,7 @@ sub mojo_clean($wait=1) {
 
 sub mojo_check_login( $t, $user=$MOJO_USER , $pass=$MOJO_PASSWORD ) {
     $t->ua->get("/user.json");
-    return if $t->tx->res->code =~ /^(101|200|302)$/;
+    return if $t->tx && $t->tx->res->code =~ /^(101|200|302)$/;
     mojo_login($t, $user,$pass);
 }
 
@@ -1030,7 +1064,7 @@ sub _wait_mojo_request($t, $url) {
     }
     my $req = Ravada::Request->open($body_json->{request});
     for ( 1 .. 180 ) {
-        last if $req->status eq 'done';
+        last if $req->status eq 'done' || $req->at_time;
         sleep 1;
         diag("Waiting for request "
             .$req->id." ".$req->command." ".$req->status." ".$req->error) if !($_ % 10);
@@ -1307,6 +1341,7 @@ sub wait_request {
             next if $@ && $@ =~ /I can't find id=$req_id/;
             die $@ if $@;
             next if $skip{$req->command};
+            next if $req->at_time && $req->status eq 'requested';
             if ( $req->status ne 'done' ) {
                 my $run_at = '';
                 if ($req->status eq 'requested') {
@@ -1371,7 +1406,7 @@ sub wait_request {
             for my $req (@$request) {
                 $req = Ravada::Request->open($req) if !ref($req);
                 next if !$req->id || $skip{$req->command};
-                if ($req->status ne 'done') {
+                if ($req->status ne 'done' && !$req->at_time) {
                     $done_all = 0;
                     if ( $debug && (time%5 == 0) ) {
                         diag("Waiting for request ".$req->id." ".$req->command);
@@ -1416,6 +1451,7 @@ sub fast_forward_requests() {
     my $sth = $CONNECTOR->dbh->prepare("UPDATE requests "
         ." SET at_time=0 WHERE status = 'requested' AND at_time>0 "
         ."    AND command <> 'open_exposed_ports'"
+        ."    AND command <> 'remove_clones'"
     );
     eval {
     $sth->execute();
@@ -1495,13 +1531,28 @@ sub remove_void_networks($vm=undef) {
 
     opendir my $dir, $dir_net or die "$! $dir_net";
     while(my $filename = readdir $dir) {
+        next unless $filename =~ /^$base.*\.yml$/;
         my $file = "$dir_net/$filename";
-        next unless $file =~ /^$base.*\.yml$/;
         unlink $file or warn "$! $file";
     }
 
 }
 
+sub remove_networks_req() {
+    my $sth = connector()->dbh->prepare("SELECT id,id_vm,name FROM virtual_networks "
+        ." WHERE name like ? "
+    );
+    $sth->execute(base_domain_name."%");
+    while (my ($id, $id_vm, $name) = $sth->fetchrow) {
+        my $req = Ravada::Request->remove_network(
+            uid => user_admin()->id
+            ,id => $id
+            ,id_vm => $id_vm
+        );
+    }
+    wait_request();
+}
+
 sub remove_qemu_networks($vm=undef) {
     return if !$VM_VALID{'KVM'} || $>;
     if (!defined $vm) {
@@ -2578,6 +2629,7 @@ sub _check_leftovers_users {
 
 sub _check_iptables() {
     return if $>;
+    return if !$VM_VALID{KVM};
     for my $table ( 'mangle', 'nat') {
         my @cmd = ("iptables" ,"-t", $table,"-L","POSTROUTING");
         my ($in, $out, $err);
diff --git a/t/mojo/10_login.t b/t/mojo/10_login.t
index b1ee549ca..a7d555b74 100644
--- a/t/mojo/10_login.t
+++ b/t/mojo/10_login.t
@@ -282,6 +282,7 @@ sub test_login_non_admin($t, $base, $clone){
 
     mojo_check_login($t, $name, $pass);
     $base->is_public(0);
+    $base->show_clones(1);
 
     $t->get_ok("/machine/clone/".$base->id.".html")
     ->status_is(200);
@@ -365,10 +366,15 @@ sub test_login_non_admin_req($t, $base, $clone){
 
     mojo_check_login($t, $name, $pass);
     $base->is_public(0);
+    $base->show_clones(1);
 
     $t->get_ok("/machine/clone/".$base->id.".html")
     ->status_is(200);
     die "Error cloning ".$base->id if $t->tx->res->code() != 200;
+
+    $base->show_clones(0);
+    $t->get_ok("/machine/clone/".$base->id.".html")
+    ->status_is(403);
 }
 
 
@@ -1123,6 +1129,7 @@ for my $vm_name (reverse @{rvd_front->list_vm_types} ) {
     test_grant_access($t, $base0);
 
     if ($vm_name eq 'KVM') {
+        _init_mojo_client();
         test_new_machine_default($t, $vm_name);
         test_new_machine_default($t, $vm_name, 1); # with empty iso file
         test_new_machine_advanced_options($t, $vm_name);
diff --git a/t/mojo/15_list_bases.t b/t/mojo/15_list_bases.t
new file mode 100644
index 000000000..7bfca48e7
--- /dev/null
+++ b/t/mojo/15_list_bases.t
@@ -0,0 +1,158 @@
+use warnings;
+use strict;
+
+use Carp qw(confess);
+use Data::Dumper;
+use HTML::Lint;
+use Test::More;
+use Test::Mojo;
+use Mojo::File 'path';
+use Mojo::JSON qw(decode_json);
+
+use lib 't/lib';
+use Test::Ravada;
+
+no warnings "experimental::signatures";
+use feature qw(signatures);
+
+my $SECONDS_TIMEOUT = 15;
+
+my $t;
+
+my $URL_LOGOUT = '/logout';
+my ($USERNAME, $PASSWORD);
+my $SCRIPT = path(__FILE__)->dirname->sibling('../script/rvd_front');
+
+########################################################################################
+
+sub _create_base($vm_name) {
+    my $name = new_domain_name();
+
+    my $iso_name = 'Alpine%';
+    mojo_check_login($t);
+    $t->post_ok('/new_machine.html' => form => {
+            backend => $vm_name
+            ,id_iso => search_id_iso($iso_name)
+            ,name => $name
+            ,disk => 1
+            ,ram => 1
+            ,swap => 1
+            ,start => 0
+            ,submit => 1
+        }
+    )->status_is(302);
+    die $t->tx->res->body if $t->tx->res->code() != 302;
+    wait_request();
+    my $base=_wait_domain($name);
+
+    die "Error: $name not created" if !$base;
+    mojo_request($t, 'prepare_base',{ id_domain => $base->id });
+    for ( 1 .. 120 ) {
+        return $base if $base->is_base;
+        sleep 1;
+    }
+    die "Error: $name not prepared" if !$base->is_base;
+    return $base;
+}
+
+sub test_list_machines_user($vm_name) {
+    mojo_check_login($t, $USERNAME, $PASSWORD);
+    my $base = _create_base($vm_name);
+    $base->is_public(1);
+
+    $t->ua->get($URL_LOGOUT);
+    my $user = create_user();
+
+    mojo_login($t, $user->name,$$);
+
+    $t->get_ok("/list_machines_user.json")->status_is(200);
+    my $body = $t->tx->res->body;
+    my $bases0;
+    eval { $bases0 = decode_json($body) };
+    is($@, '') or return;
+
+    my ($base_f) = grep { $_->{id} == $base->id } @$bases0;
+    ok($base_f) or die "Expecting ".$base->name." in listing";
+
+    $t->get_ok("/machine/clone/".$base->id.".html")
+        ->status_is(200);
+
+    return if $t->tx->res->code != 200;
+
+    $base->is_public(0);
+    $base->show_clones(0);
+
+    $t->get_ok("/machine/clone/".$base->id.".html")
+        ->status_is(403);
+
+    my $clone = _wait_domain($base->name."-".$user->name);
+    ok($clone) or exit;
+
+    $t->get_ok("/machine/view/".$clone->id.".html")
+        ->status_is(403);
+
+    $base->show_clones(1);
+    $t->get_ok("/machine/clone/".$base->id.".html")
+        ->status_is(200);
+
+    $t->get_ok("/machine/view/".$clone->id.".html")
+        ->status_is(200);
+
+    my $user2 = create_user();
+
+    mojo_login($t, $user2->name,$$);
+
+    $t->get_ok("/list_machines_user.json")->status_is(200);
+    $body = $t->tx->res->body;
+    eval { $bases0 = decode_json($body) };
+    is($@, '') or return;
+
+    my ($base_f2) = grep { $_->{id} == $base->id } @$bases0;
+    ok(!$base_f2) or die "Expecting ".$base->name." in listing";
+
+    $t->get_ok("/machine/clone/".$base->id.".html")
+        ->status_is(403);
+}
+
+sub _wait_domain($name) {
+    for ( 1 .. 120 ) {
+        my $domain = rvd_front->search_domain($name);
+        return $domain if $domain;
+        sleep 1;
+        diag("waiting for $name");
+    }
+}
+
+########################################################################################
+
+$ENV{MOJO_MODE} = 'development';
+init('/etc/ravada.conf',0);
+my $connector = rvd_back->connector;
+like($connector->{driver} , qr/mysql/i) or BAIL_OUT;
+
+if (!ping_backend()) {
+    diag("SKIPPED: no backend");
+    done_testing();
+    exit;
+}
+$Test::Ravada::BACKGROUND=1;
+
+remove_old_domains_req(1); # 0=do not wait for them
+
+$t = Test::Mojo->new($SCRIPT);
+$t->ua->inactivity_timeout(900);
+$t->ua->connect_timeout(60);
+
+$USERNAME = user_admin->name;
+$PASSWORD = "$$ $$";
+
+for my $vm_name (reverse @{rvd_front->list_vm_types} ) {
+
+    diag("Testing new machine in $vm_name");
+
+    test_list_machines_user($vm_name);
+}
+remove_old_domains_req(0); # 0=do not wait for them
+remove_old_users();
+
+done_testing();
diff --git a/t/mojo/30_settings.t b/t/mojo/30_settings.t
index f7983bc47..4698c4786 100644
--- a/t/mojo/30_settings.t
+++ b/t/mojo/30_settings.t
@@ -512,7 +512,39 @@ sub clean_clones() {
     }
 }
 
+sub _create_storage_pool($id_vm , $vm_name) {
+    $t->get_ok("/list_storage_pools/$vm_name");
+    my $sp = decode_json($t->tx->res->body);
+    my $name = new_pool_name();
+    my ($found) = grep { $_->{name} eq $name } @$sp;
+    return $name if $found;
+
+    my $dir0 = "/var/tmp/$$/";
+
+    mkdir $dir0 if !-e $dir0;
+
+    my $dir = $dir0."/".new_pool_name();
+
+    mkdir $dir or die "$! $dir" if !-e $dir;
+
+
+    my $req = Ravada::Request->create_storage_pool(
+        uid => user_admin->id
+        ,id_vm => $id_vm
+        ,name => $name
+        ,directory => $dir
+    );
+    wait_request( );
+    is($req->error,'');
+
+    return $name;
+}
+
 sub test_storage_pools($vm_name) {
+
+    my $id_vm = _id_vm($vm_name);
+    my $sp_name = _create_storage_pool($id_vm, $vm_name);
+
     $t->get_ok("/list_storage_pools/$vm_name");
 
     is($t->tx->res->code(),200) or die $t->tx->res->body;
@@ -520,8 +552,6 @@ sub test_storage_pools($vm_name) {
     my $sp = decode_json($t->tx->res->body);
     ok(scalar(@$sp));
 
-    my $id_vm = _id_vm($vm_name);
-
     $t->get_ok("/list_storage_pools/$id_vm");
 
     is($t->tx->res->code(),200) or die $t->tx->res->body;
@@ -532,11 +562,6 @@ sub test_storage_pools($vm_name) {
 
     my ($sp_inactive) = grep { $_->{name} ne 'default' } @$sp_id;
 
-    if ( !$sp_inactive ) {
-#        warn "Warning: no sp in addition to 'default' in ".Dumper($sp_id);
-        $sp_inactive = $sp_id->[0];
-    }
-
     my $name_inactive= $sp_inactive->{name};
     die "Error, no name in ".Dumper($sp_inactive) if !$name_inactive;
 
diff --git a/t/mojo/40_anonymous.t b/t/mojo/40_anonymous.t
index cd5180ea5..54c997ba9 100644
--- a/t/mojo/40_anonymous.t
+++ b/t/mojo/40_anonymous.t
@@ -129,5 +129,8 @@ for my $route ( qw( list_bases_anonymous request/1.json ws/subscribe anonymous_l
     is(list_anonymous_users(), $n_anonymous, $url);
 }
 
+wait_request();
+remove_volatile_clones(@$bases);
+
 remove_old_domains_req(0);
 done_testing();
diff --git a/t/mojo/60_upload.t b/t/mojo/60_upload.t
index 20ca42bd4..22ec204fc 100644
--- a/t/mojo/60_upload.t
+++ b/t/mojo/60_upload.t
@@ -226,5 +226,4 @@ for my $type ( 'ldap', 'sso' ) {
     test_upload_users( $type, 0 ,1 ); # do not create users in Ravada
 }
 
-end();
 done_testing();
diff --git a/t/mojo/70_volatile.t b/t/mojo/70_volatile.t
index 1f2bf9bb1..8450d0609 100644
--- a/t/mojo/70_volatile.t
+++ b/t/mojo/70_volatile.t
@@ -29,7 +29,7 @@ my ($USERNAME, $PASSWORD);
 sub _wait_ip($id_domain0, $seconds=60) {
 
     my $domain;
-    for ( 1 .. $seconds ) {
+    for my $count ( 0 .. $seconds ) {
         my $id_domain = $id_domain0;
 
         if ($id_domain0 !~ /^\d+$/) {
@@ -42,8 +42,13 @@ sub _wait_ip($id_domain0, $seconds=60) {
             ,uid => user_admin->id
         );
 
+        my $info;
+        eval {
         $domain = Ravada::Front::Domain->open($id_domain);
-        my $info = $domain->info(user_admin);
+        $info = $domain->info(user_admin);
+        };
+        warn $@ if $@ && $@ !~ /Unknown domain/;
+        return if $@ || ($count && !$domain->is_active);
         return $info->{ip} if exists $info->{ip} && $info->{ip};
         diag("Waiting for ".$domain->name. " ip") if !(time % 10);
         sleep 1;
@@ -115,6 +120,7 @@ sub bases($vm_name) {
         }
         ok($base, "Expecting domain $name created") or exit;
         push @bases,($base);
+        last if scalar(@bases)>1 && !$ENV{TEST_LONG};
     }
     for my $base (@bases) {
         if ($base->id_base) {
@@ -125,7 +131,7 @@ sub bases($vm_name) {
     return @bases;
 }
 
-sub _set_base_vms($vm_name, $id_base) {
+sub _set_base_vms($vm_name, $id_base, $network) {
     my $sth = connector->dbh->prepare("SELECT id FROM vms WHERE vm_type=?");
     $sth->execute($vm_name);
     while ( my ($id_vm) = $sth->fetchrow) {
@@ -135,8 +141,18 @@ sub _set_base_vms($vm_name, $id_base) {
     $sth->execute($vm_name);
     while ( my ($id_vm) = $sth->fetchrow) {
         $t->post_ok("/node/enable/$id_vm.json");
+
+        my $req = Ravada::Request->create_network(
+        uid => user_admin->id
+        ,id_vm => $id_vm
+        ,data => $network
+        );
+        wait_request(check_error => 0);
+
         my $id_req = mojo_request($t,"set_base_vm", { id_vm => $id_vm, id_domain => $id_base, value => 1 }, 0);
-        mojo_request($t,"clone", { id_domain => $id_base , after_request => $id_req, name => new_domain_name() });
+        mojo_request($t,"clone", { id_domain => $id_base , after_request => $id_req, name => new_domain_name()
+                    ,options => { network => $network->{name} }
+            });
     }
 
 }
@@ -149,32 +165,80 @@ sub _id_vm($vm_name) {
     return $id;
 }
 
+sub _count_nodes($vm_name) {
+    my $sth = connector->dbh->prepare(
+        "SELECT count(*) FROM vms WHERE vm_type=?"
+        ."  AND is_active=1 AND enabled=1"
+    );
+    $sth->execute($vm_name);
+    my ($count) = $sth->fetchrow;
+    warn "No nodes found for vm_type=$vm_name" if !$count;
+    return ($count or 1);
+}
+
+sub _new_network($id_vm) {
+
+    my $req_new = Ravada::Request->new_network(
+        uid => user_admin->id
+        ,id_vm => $id_vm
+        ,name => base_domain_name()
+    );
+    wait_request(debug => 0);
+    like($req_new->output , qr/\d+/) or exit;
+
+    my $net = decode_json($req_new->output);
+    my $name = $net->{name};
+
+    my $user = create_user();
+    my $req = Ravada::Request->create_network(
+        uid => user_admin->id
+        ,id_vm => $id_vm
+        ,data => $net
+    );
+    wait_request(check_error => 0);
+
+    die $req->error if $req->error;
+
+    return $net;
+}
+
 sub test_clone($vm_name, $n=10) {
     my $id_vm = _id_vm($vm_name);
 
     my @bases = bases($vm_name);
 
+    my $network = _new_network($id_vm);
+    my $network_name = $network->{name};
+
     for my $base ( @bases ) {
         mojo_request($t,"prepare_base", {id_domain => $base->id });
         $base->is_public(1);
         $base->volatile_clones(1);
 
         is($base->_data('id_vm'), $id_vm) or die $base->name;
+
+        Ravada::Request->remove_clones(
+            uid => user_admin->id
+            ,id_domain => $base->id
+            ,at => time + 300+_count_nodes($vm_name)*2
+        );
+
     }
 
     for my $base (@bases) {
-        _set_base_vms($vm_name, $base->id);
+        _set_base_vms($vm_name, $base->id, $network);
         is($base->_data('id_vm'), $id_vm) or die $base->name;
     }
 
     my $times = 2;
     $times = 20 if $ENV{TEST_LONG};
 
-    my $seconds = 2;
+    my $seconds = 0;
     LOOP: for my $count0 ( 0 .. $times ) {
-        for my $count1 ( 0 .. $n*scalar(@bases) ) {
+        for my $count1 ( 0 .. $n*_count_nodes($vm_name) ) {
             for my $base ( @bases ) {
                 next if !$base->is_base;
+
                 next if $base->list_requests > 10;
                 last LOOP if _too_loaded("clone");
                 my $user = create_user(new_domain_name(),$$);
@@ -189,6 +253,7 @@ sub test_clone($vm_name, $n=10) {
                     ,remote_ip => "192.168.122.$ip"
                     ,start => 1
                     ,name => $name
+                    ,options => { network => $network_name }
                 );
                 delete_request('set_time','force_shutdown');
                 next if $vm_name eq 'Void';
@@ -362,6 +427,8 @@ if (!ping_backend()) {
 }
 $Test::Ravada::BACKGROUND=1;
 
+remove_networks_req();
+
 $t = Test::Mojo->new($SCRIPT);
 $t->ua->inactivity_timeout(900);
 $t->ua->connect_timeout(60);
@@ -381,6 +448,7 @@ for my $vm_name (@{rvd_front->list_vm_types} ) {
 }
 
 remove_old_domains_req(0); # 0=do not wait for them
+remove_networks_req();
 
 end();
 done_testing();
diff --git a/t/nodes/20_dead_node.t b/t/nodes/20_dead_node.t
index 3de2d6cdb..aa2b07dd1 100644
--- a/t/nodes/20_dead_node.t
+++ b/t/nodes/20_dead_node.t
@@ -40,7 +40,9 @@ sub test_down_node($vm, $node) {
     is($req->status, 'done');
     like($req->error, qr{^($|checked)},"Expecting no error after refresh vms");
 
+    warn 1;
     is($clone[0]->is_active, 0, "Expecting clone not active after node shutdown");
+    warn 2;
 
     my@req;
     for (@clone) {
@@ -49,6 +51,7 @@ sub test_down_node($vm, $node) {
         ));
     }
     for my $req (@req) {
+        warn $req->command;
         rvd_back->_process_requests_dont_fork();
         next if $req->status ne 'done';
         is($req->error ,'');
diff --git a/t/vm/94_ports_exposed.t b/t/vm/94_ports_exposed.t
index 7f1977518..04a7cf9ae 100644
--- a/t/vm/94_ports_exposed.t
+++ b/t/vm/94_ports_exposed.t
@@ -81,7 +81,7 @@ sub test_expose_port($vm) {
     is(scalar(@prerouting),1);
     my @out= split /\n/, `iptables-save`;
     my @forward = (grep /-s $remote_ip2\/32 -d $internal_ip.* --dport 22.*-j ACCEPT/, @out);
-    is(scalar(@forward),1) or die Dumper([grep /FORWARD/,@out]);
+    is(scalar(@forward),1,"-s $remote_ip2\/32 -d $internal_ip.* --dport 22.*-j ACCEPT") or die Dumper([grep /FORWARD/,@out]);
 }
 
 sub _wait_ip2($vm_name, $domain) {
diff --git a/t/vm/bundle.t b/t/vm/bundle.t
new file mode 100644
index 000000000..22888a7d3
--- /dev/null
+++ b/t/vm/bundle.t
@@ -0,0 +1,269 @@
+use warnings;
+use strict;
+
+use Carp qw(confess);
+use Data::Dumper;
+use Test::More;
+
+use lib 't/lib';
+use Test::Ravada;
+
+no warnings "experimental::signatures";
+use feature qw(signatures);
+
+#################################################################
+
+sub _req_clone($user, @base) {
+    for my $base (@base) {
+        my $req = Ravada::Request->clone(
+        uid => $user->id
+        ,id_domain => $base->id
+        ,name => new_domain_name
+        );
+    }
+    wait_request( debug => 0);
+}
+
+sub _req_create($user, @base) {
+    for my $base (@base) {
+        my $req = Ravada::Request->create_domain(
+        id_owner => $user->id
+        ,id_base => $base->id
+        ,name => new_domain_name
+        );
+    }
+    wait_request( debug => 0);
+}
+
+
+sub test_bundle_2($vm, $n, $do_clone=0, $volatile=0) {
+    my $name = new_domain_name();
+    my $id_bundle = rvd_front->create_bundle($name);
+    rvd_front->bundle_private_network($id_bundle,1);
+
+    my @bases;
+    for my $count ( 1 .. $n ) {
+        my $base1 = create_domain_v2(vm => $vm);
+        $base1->prepare_base(user_admin);
+        $base1->is_public(1);
+        $base1->volatile_clones(1) if $volatile;
+
+        rvd_front->add_to_bundle($id_bundle, $base1->id);
+
+        push @bases,($base1);
+    }
+
+    my $user = create_user();
+    if ($do_clone) {
+        _req_clone($user, @bases);
+    } else {
+        _req_create($user, @bases);
+    }
+
+    my $net;
+    for my $base ( @bases ) {
+
+        my @clone1 = grep { $_->{id_owner} == $user->id }
+            $base->clones();
+
+        is(scalar(@clone1),1) or exit;
+
+        if($net) {
+            $net = _check_net_private($clone1[0], $net);
+        } else {
+            $net = _check_net_private($clone1[0]);
+        }
+
+        Ravada::Request->enforce_limits();
+        wait_request();
+    }
+}
+
+sub test_bundle($vm, $do_clone=0, $volatile=0) {
+
+    my $base1 = create_domain_v2(vm => $vm);
+    $base1->prepare_base(user_admin);
+    $base1->is_public(1);
+    $base1->volatile_clones(1) if $volatile;
+
+    my $base2a = create_domain($vm);
+    Ravada::Request->add_hardware(
+        uid => user_admin->id
+        ,name => 'network'
+        ,id_domain => $base2a->id
+    );
+    wait_request( debug => 0);
+    my $base2 = Ravada::Domain->open($base2a->id);
+    $base2->prepare_base(user_admin);
+    $base2->is_public(1);
+    $base2->volatile_clones(1) if $volatile;
+
+    my $name = new_domain_name();
+    my $id_bundle = rvd_front->create_bundle($name);
+    rvd_front->bundle_private_network($id_bundle,1);
+
+    rvd_front->add_to_bundle($id_bundle, $base1->id);
+    rvd_front->add_to_bundle($id_bundle, $base2->id);
+
+    my $user = create_user();
+
+    my @networks0 = $vm->list_virtual_networks();
+
+    if ($do_clone) {
+        _req_clone($user, $base1, $base2);
+    } else {
+        _req_create($user, $base1, $base2);
+    }
+
+    my @clone1 = grep { $_->{id_owner} == $user->id } $base1->clones();
+    my @clone2 = grep { $_->{id_owner} == $user->id } $base2->clones();
+    is(scalar(@clone1),1);
+    is(scalar(@clone2),1);
+
+    my @networks1 = $vm->list_virtual_networks();
+    is(scalar(@networks1), scalar(@networks0)+1);
+
+    my $net = _check_net_private($clone1[0]);
+    _check_net_private($clone2[0], $net);
+    is($clone1[0]->{is_volatile} , $volatile);
+    is($clone2[0]->{is_volatile} , $volatile);
+
+    my @nets_2 = _get_net($clone2[0]);
+    is(scalar(@nets_2),2) or die $clone2[0]->{name};
+
+    remove_domain(@clone1);
+    remove_domain(@clone2);
+
+    if ($do_clone) {
+        _req_clone($user, $base2, $base1);
+    } else {
+        _req_create($user, $base2, $base1);
+    }
+
+    wait_request(debug => 0);
+
+    @clone1 = grep { $_->{id_owner} == $user->id } $base1->clones();
+    @clone2 = grep { $_->{id_owner} == $user->id } $base2->clones();
+    is(scalar(@clone1),1);
+    is(scalar(@clone2),1);
+
+    is($clone1[0]->{is_volatile} , $volatile);
+    is($clone2[0]->{is_volatile} , $volatile);
+
+    for my $clone (@clone1, @clone2) {
+        Ravada::Request->start_domain( uid => $user->id
+            , id_domain => $clone->{id}
+        );
+    }
+    Ravada::Request->enforce_limits();
+    wait_request();
+
+    for my $clone0 ( @clone1, @clone2 ) {
+        my $clone = Ravada::Front::Domain->open($clone0->{id} );
+        is($clone->is_active,1);
+        Ravada::Request->force_shutdown(
+            uid => user_admin->id
+            ,id_domain => $clone->id
+        );
+    }
+    remove_domain($base1);
+    remove_domain($base2);
+}
+
+sub _check_net_private($domain, $net=undef) {
+    my $found;
+    for my $net_found ( _get_net($domain) ) {
+        isnt($net_found->{name}, 'default', "Expecting another net in ".$domain->{name}) or exit;
+        my $base = base_domain_name();
+        like($net_found->{name},qr/^$base/) or die $domain->{name};
+        is ( $net_found->{id_owner}, $domain->{id_owner})
+            or confess "Expecting net $net_found->{name} owned by $domain->{id_owner}";
+
+        if (defined $net) {
+            is($net_found->{name}, $net->{name});
+        }
+
+        $found = $net_found if $net_found->{name} ne 'default';
+    }
+    return $found;
+}
+
+sub _get_net($domain0) {
+    my $domain = $domain0;
+    if (ref($domain) !~ /^Ravada::/) {
+        $domain = Ravada::Domain->open($domain0->{id});
+    }
+
+    my @net_name;
+    if ($domain->type eq 'KVM') {
+        @net_name = _get_net_kvm($domain);
+    } elsif ($domain->type eq 'Void') {
+        @net_name = _get_net_void($domain);
+    }
+
+    die "Error: no net found in ".$domain->name if !@net_name;
+
+    my @net;
+    for my $name (@net_name) {
+        push @net, grep { $_->{name} eq $name }
+        $domain->_vm->list_virtual_networks;
+    }
+    return @net;
+}
+
+sub _get_net_kvm($domain) {
+    my $doc = XML::LibXML->load_xml(string => $domain->xml_description());
+
+    my @net_source = $doc->findnodes("/domain/devices/interface/source");
+    my @names;
+    for my $net (@net_source) {
+        push @names, $net->getAttribute('network');
+    }
+    return @names;
+
+}
+
+sub _get_net_void($domain) {
+    my $config = $domain->get_config();
+    my @names;
+    for my $net ( @{$config->{hardware}->{network}} ) {
+        push @names,($net->{name});
+    }
+    return @names;
+}
+#################################################################
+
+init();
+clean();
+for my $vm_name ( vm_names() ) {
+
+    SKIP: {
+    my $vm = rvd_back->search_vm($vm_name);
+
+    my $msg = "SKIPPED test: No $vm_name VM found ";
+    if ($vm_name ne 'Void' && $>) {
+            $msg = "SKIPPED: Test must run as root";
+            $vm = undef;
+    }
+
+    diag($msg)      if !$vm;
+    skip $msg,10    if !$vm;
+
+    diag("Testing $vm_name bundle");
+
+    test_bundle_2($vm,3,0);
+    test_bundle_2($vm,3,1);
+
+    test_bundle_2($vm,4,0);
+    test_bundle_2($vm,4,1);
+
+    test_bundle($vm,1); # with clone and volatile
+
+    test_bundle($vm,0); # create
+    test_bundle($vm,1); # with clone
+
+    }
+}
+
+end();
+done_testing();
diff --git a/t/vm/c10_copy.t b/t/vm/c10_copy.t
index 5970c195b..df6ce56ae 100644
--- a/t/vm/c10_copy.t
+++ b/t/vm/c10_copy.t
@@ -257,7 +257,6 @@ for my $vm_name ( vm_names() ) {
         test_copy_change_ram($vm_name);
 
         test_copy_req_nonbase($vm_name);
-        clean();
     }
 
 }
diff --git a/t/vm/networking.t b/t/vm/networking.t
index a4d4f231b..cf785bf18 100644
--- a/t/vm/networking.t
+++ b/t/vm/networking.t
@@ -234,6 +234,18 @@ sub test_add_network($vm) {
     is($new->{is_active},1);
     is($new->{autostart},1);
     is($new->{is_public},0);
+
+    my @old = $vm->list_virtual_networks();
+    for my $old (@old) {
+        next if $old->{name} eq $new->{name};
+        my $old_ip = $old->{ip_address};
+        my $new_ip = $new->{ip_address};
+
+        $old_ip =~ s/(.*)\.\d+/$1/;
+        $new_ip =~ s/(.*)\.\d+/$1/;
+
+        isnt($new_ip, $old_ip, "ip $new_ip found in ".$old->{name}) or exit;
+    }
     return $new;
 }
 
@@ -295,11 +307,14 @@ sub _check_network_changed($net, $field) {
 sub test_change_network($net) {
     my %net2 = %$net;
     $net2{dhcp_end} =~ s/(.*)\.\d+$/$1.100/;
+    my $ip = $net2{ip_address};
+    $ip =~ s/\.\d+$/.0/;
+    $net2{ip_address} = $ip;
     my $req = Ravada::Request->change_network(
         uid => user_admin->id
         ,data => \%net2
     );
-    wait_request();
+    wait_request(debug => 0);
     my $vm = Ravada::VM->open($net->{id_vm});
 
     my($new) = grep { $_->{name} eq $net->{name} } $vm->list_virtual_networks();
@@ -342,6 +357,7 @@ sub test_change_network($net) {
         is($new2->{is_active},$net2{is_active});
     }
 
+    $net2{is_active}=1;
     for ( 1 .. 2 ) {
         $net2{is_public} = (!$net2{is_public} or 0);
         $req = Ravada::Request->change_network(
@@ -388,7 +404,7 @@ sub test_assign_network($vm, $net) {
             network => $net->{name}
         }
     );
-    wait_request(debug => 1);
+    wait_request(debug => 0);
 
     my $domain = rvd_back->search_domain($name);
     ok($domain);
@@ -410,7 +426,20 @@ sub test_assign_network_clone($vm, $net, $volatile) {
 
     my $domain = rvd_back->search_domain($name);
     $domain->prepare_base(user_admin);
-    $domain->volatile_clones(1);
+    $domain->volatile_clones($volatile);
+
+    my $name_clone3 = new_domain_name();
+    my $req3 = Ravada::Request->clone(
+        id_domain => $domain->id
+        ,uid => user_admin->id
+        ,options => { network => $net->{name}}
+        ,name => $name_clone3
+    );
+    wait_request(debug => 0);
+    my $clone3 = rvd_back->search_domain($name_clone3);
+    ok($clone3);
+
+    _check_domain_network($clone3, $net->{name});
 
     my $name_clone = new_domain_name();
     my $req2 = Ravada::Request->create_domain(
@@ -419,11 +448,26 @@ sub test_assign_network_clone($vm, $net, $volatile) {
         ,options => { network => $net->{name}}
         ,name => $name_clone
     );
-    wait_request(debug => 1);
+    wait_request(debug => 0);
     my $clone = rvd_back->search_domain($name_clone);
     ok($clone);
 
     _check_domain_network($clone, $net->{name});
+
+    my $name_clone3 = new_domain_name();
+    my $req3 = Ravada::Request->clone(
+        id_domain => $domain->id
+        ,uid => user_admin->id
+        ,options => { network => $net->{name}}
+        ,name => $name_clone3
+    );
+    wait_request(debug => 0);
+    my $clone3 = rvd_back->search_domain($name_clone3);
+    ok($clone3);
+
+    _check_domain_network($clone, $net->{name});
+
+    remove_domain($domain);
 }
 
 sub _check_domain_network_kvm($domain, $net_name) {
@@ -776,6 +820,7 @@ for my $vm_name ( vm_names() ) {
         test_list_networks($vm);
 
         my $net = test_add_network($vm);
+
         test_assign_network($vm, $net);
         test_assign_network_clone($vm, $net, 0);
         test_assign_network_clone($vm, $net, 1); # volatile clone
@@ -792,7 +837,9 @@ for my $vm_name ( vm_names() ) {
         test_duplicate_bridge_add($vm, $net);
 
         test_change_network_internal($vm, $net);
+
         test_change_network($net);
+        test_add_network($vm);
 
         test_changed_uuid($vm);
 
@@ -803,6 +850,8 @@ for my $vm_name ( vm_names() ) {
     }
 }
 
+remove_networks_req();
+
 end();
 
 done_testing();
diff --git a/t/vm/s30_storage.t b/t/vm/s30_storage.t
index 27409f1ba..a7cd96086 100644
--- a/t/vm/s30_storage.t
+++ b/t/vm/s30_storage.t
@@ -60,7 +60,7 @@ sub test_storage_pools_fail($vm) {
 
     create_storage_pool($vm, $dir);
 
-    delete_request('cleanup');
+    delete_request('cleanup', 'check_storage');
     my $req = Ravada::Request->check_storage(
         uid => user_admin->id
         ,retry => 2
@@ -70,7 +70,9 @@ sub test_storage_pools_fail($vm) {
     );
     is($req_cleanup->after_request_ok,$req->id);
     wait_request( debug => 0, check_error => 0);
-    is($req->status,'done');
+    wait_request( debug => 0, check_error => 0);
+    wait_request( debug => 0, check_error => 0);
+    is($req->status,'done',"Expecting done ".$req->id);
     like($req->error, qr/not mounted/);
 
     is($req_cleanup->status,'done');
diff --git a/templates/main/admin_machines.html.ep b/templates/main/admin_machines.html.ep
index c7b937066..5f63da330 100644
--- a/templates/main/admin_machines.html.ep
+++ b/templates/main/admin_machines.html.ep
@@ -145,7 +145,7 @@
                               ,active_machine: machine.status == 'active'
                               }"
                         title ="<%=l 'Manage machine' %>">{{machine.name}}</a> {{machine.comment}}
-                   <span class="comment" ng-show="machine.is_volatile"><%=l 'Volatile' %></span>
+                   <span class="comme497461nt" ng-show="machine.is_volatile"><%=l 'Volatile' %></span>
                         <button ng-show="machine.has_clones && !filter"
                                          type="button"
                         class="badge badge-light text-blue"
@@ -228,6 +228,16 @@
                                </div>
                                <div class="modal-body">
                                  <p><%=l 'Are you sure you want to change the Public state of' %> {{machine.name}} <%=l 'to' %> {{!(machine.is_public==0)}}?</p>
+                                 <div ng-show="machine.is_public==0" class="ml-4">
+                                    <input type="checkbox" name="show_clones" ng-model="machine.show_clones"
+                                            ng-true-value="1" ng-false-value="0"
+                                    >
+                                    <label for="show_clones"><%=l 'Show already created clones' %></label>
+                                    <button type="button" class="badge" ng-click="help_show_clones=!help_show_clones">?</button>
+                                    <div ng-show="help_show_clones">
+                                        <span class="info"><%=l 'The user will be able to access the clone, even when the base is hidden.' %> <%=l 'But no new clones can be created.' %></span>
+                                    </div>
+                                 </div>
                                </div>
                                <div class="modal-footer">
                                  <button type="button" class="btn btn-secondary" data-dismiss="modal" ng-click="cancel_modal(machine,'is_public')"><%=l 'No' %></button>
diff --git a/templates/main/node_hostdev.html.ep b/templates/main/node_hostdev.html.ep
index 653dc8a62..675bc906c 100644
--- a/templates/main/node_hostdev.html.ep
+++ b/templates/main/node_hostdev.html.ep
@@ -46,8 +46,67 @@
         <div ng-show="!hdev.devices"><i class="fa fa-sync-alt fa-spin"></i></div>
         <ul>
             <li ng-repeat="device in hdev.devices">
-                {{device}}
+                {{device.name}}
+                <a class="badge badge-primary" href="/machine/manage/{{device.domain.id}}.html#!#v-pills-hostdev"
+                    ng-show="device.domain">{{device.domain.name}}</a>
             </li>
         </ul>
+        <div ng-show="hdev._bases.length" class="ml-0">
+            <b>Bases</b>
+            <i ng-click="show_bases[hdev.id]=true" ng-show="!show_bases[hdev.id]"
+                class="fa fa-caret-right"></i>
+            <i ng-click="show_bases[hdev.id]=false" ng-show="show_bases[hdev.id]"
+                class="fa fa-caret-down"></i>
+            <div ng-show="show_bases[hdev.id]">
+                <div class="row ml-0 pl-0" ng-repeat="domain in hdev._bases">
+                    <div class="col col-sm-1 ml-0 pl-0" align="right">
+                    </div>
+                    <div class="col col-sm-10 ml-0 pl-0">
+                    <a href="/machine/manage/{{domain.id}}.html"
+                            class="machine"
+                    >
+                    <span ng-class="disabled">{{domain.name}}</span>
+                    </a>
+                    </div>
+                </div>
+            </div>
+
+
+        </div>
+
+        <div ng-show="hdev._domains.length" class="ml-0">
+            <b>Machines</b>
+            <i ng-click="show_domains[hdev.id]=true" ng-show="!show_domains[hdev.id]"
+                class="fa fa-caret-right"></i>
+            <i ng-click="show_domains[hdev.id]=false" ng-show="show_domains[hdev.id]"
+                class="fa fa-caret-down"></i>
+            <div ng-show="show_domains[hdev.id]">
+                <div class="row ml-0 pl-0" ng-repeat="domain in hdev._domains">
+                    <div class="col col-md-1 ml-0 pl-0" align="right">
+                    <a ng-show="domain.is_locked"
+                        align="right"
+                        title="<%=l 'locked' %>"
+                    ><i class="fa fa-arrow-right"></i>
+                    </a>
+                    </div>
+                    <div class="col col-md-11 ml-0 pl-0">
+                    <a href="/machine/manage/{{domain.id}}.html"
+                            class="machine"
+                              ng-class="{
+                              machine: domain.is_locked==0
+                              ,active_machine: domain.is_locked>0
+                              }"
+
+                    ><b ng-show="domain.is_locked">{{domain.name}}</b>
+                    <span ng-class="disabled" ng-show="domain.is_locked==0">{{domain.name}}</span>
+                    </a>
+                    <span ng-show="domain.is_locked" class="ml-4"><small>{{domain.device}}</small></span>
+                    </div>
+                </div>
+            </div>
+
+        </div>
+
+
     </div>
 </div>
diff --git a/templates/main/vm_base.html.ep b/templates/main/vm_base.html.ep
index e267392df..2d905c6d8 100644
--- a/templates/main/vm_base.html.ep
+++ b/templates/main/vm_base.html.ep
@@ -16,16 +16,18 @@
 <div ng-show="!showmachine || (pending_request && pending_request.status != 'done')"><i class="fas fa-sync-alt fa-spin"></i>
 </div>
 
+%= include "/main/vm_base_public"
+
 <div ng-hide="!showmachine || (pending_request && pending_request.status != 'done')">
 
+    %= include "/main/vm_remove_base"
+
     %= include "/main/vm_rebase"
 
     %= include "/main/vm_spinoff"
 
     %= include "/main/vm_prepare_base"
 
-    %= include "/main/vm_remove_base"
-
     %= include "/main/vm_base_policy"
 
 </div>
diff --git a/templates/main/vm_base_policy.html.ep b/templates/main/vm_base_policy.html.ep
index 1a984e6f8..e937def7c 100644
--- a/templates/main/vm_base_policy.html.ep
+++ b/templates/main/vm_base_policy.html.ep
@@ -1,8 +1,8 @@
 <div class="row" ng-show="showmachine.is_base && nodes.length && balance_options.length">
-    <div class="col-md-1">
+    <div class="col-md-2" align="right">
             <label><b><%=l 'Balance' %></b></label>
     </div>
-    <div class="col-md-11">
+    <div class="col-md-10">
 
         <select ng-model="new_balance_policy"
             ng-change="set_value('balance_policy',new_balance_policy)"
diff --git a/templates/main/vm_base_public.html.ep b/templates/main/vm_base_public.html.ep
new file mode 100644
index 000000000..b5a4bd251
--- /dev/null
+++ b/templates/main/vm_base_public.html.ep
@@ -0,0 +1,24 @@
+<div class="row" ng-show="showmachine.is_base">
+    <div class="col-md-2" align="right">
+            <label><b><%=l 'Public' %></b></label>
+    </div>
+    <div class="col-md-10">
+        <input type="checkbox" ng-model="showmachine.is_public"
+            ng-true-value="1" ng-false-value="0"
+            ng-click="set_value('is_public' , !showmachine.is_public)"
+        />
+        <span class="info"><%=l 'Allow users to clone this base' %></span>
+    </div>
+</div>
+<div class="row" ng-show="showmachine.is_base && !showmachine.is_public">
+    <div class="col-md-2" align="right">
+            <label><b><%=l 'Show Clones' %></b></label>
+    </div>
+    <div class="col-md-10">
+        <input type="checkbox" ng-model="showmachine.show_clones"
+            ng-true-value="1" ng-false-value="0"
+            ng-click="set_value('show_clones' , !showmachine.show_clones)"
+        />
+        <span class="info"><%=l 'Show the base when the user already created a clone' %></span>
+    </div>
+</div>
diff --git a/templates/main/vm_hostdev.html.ep b/templates/main/vm_hostdev.html.ep
index 68c8fe6e4..de44793bd 100644
--- a/templates/main/vm_hostdev.html.ep
+++ b/templates/main/vm_hostdev.html.ep
@@ -13,7 +13,14 @@
     ng-click="toggle_host_device(hdev.id)"/> <b>{{hdev.name}}</b>
        <ul>
             <li ng-repeat="device in hdev.devices">
-                {{device}}
+                {{device.name}}
+                <span class="badge badge-primary" ng-show="showmachine.is_active && device.domain && device.domain.is_locked"><%=l 'locked' %></span>
+                <a href="/machine/manage/{{device.domain.id}}.html"
+                    class="badge badge-danger"
+                    ng-show="device.domain && device.domain.is_locked && device.domain.id != showmachine.id">
+                        <%=l 'locked by' %>
+                        {{device.domain.name}}
+                </a>
             </li>
         </ul>
 </div>
diff --git a/templates/main/vm_rebase.html.ep b/templates/main/vm_rebase.html.ep
index 7c2ca91e6..92ed3cc07 100644
--- a/templates/main/vm_rebase.html.ep
+++ b/templates/main/vm_rebase.html.ep
@@ -1,10 +1,10 @@
 <div ng-show="(showmachine.is_base && showmachine.has_clones>0 ) || showmachine.id_base">
 
     <div ng-show="bases" class="row">
-        <div class="col-md-1">
-            <label><%=l 'Base' %></label>
+        <div class="col-md-2" align="right">
+            <label><b><%=l 'Base' %></b></label>
         </div>
-        <div class="col-md-11">
+        <div class="col-md-10">
             <select ng-model="new_base"
                 ng-disabled="rebase_request && rebase_request.status != 'done'"
                 ng-options="item.name for item in bases | orderBy :'name'">
@@ -19,12 +19,16 @@
             ><%=l 'Cancel' %></button>
         </div>
     </div>
-    <div ng-show="bases" class="row">
-        <div class="col-md-1">
+    <div ng-show="bases" class="row mb-4">
+        <div class="col-md-2">
         </div>
-        <div class="col-md-11">
-            <p ng-show="showmachine.is_base"><%=l 'Rebase all the clones to a new base' %></p>
-            <p ng-show="showmachine.id_base && !showmachine.has_clones"><%=l 'Rebase this machine to another virtual machine' %></p>
+        <div class="col-md-10">
+            <div ng-show="showmachine.is_base">
+                <span class="info"><%=l 'Rebase all the clones to a new base' %></span>
+            </div>
+            <div ng-show="showmachine.id_base && !showmachine.has_clones">
+                <span class="info"><%=l 'Rebase this machine to another virtual machine' %></span>
+            </div>
         </div>
     </div>
     <div ng-show="bases" class="row">
diff --git a/templates/main/vm_remove_base.html.ep b/templates/main/vm_remove_base.html.ep
index 43b5a93d0..8d9343f57 100644
--- a/templates/main/vm_remove_base.html.ep
+++ b/templates/main/vm_remove_base.html.ep
@@ -1,13 +1,11 @@
 <div ng-show="showmachine.is_base && !showmachine.has_clones" class="row"
         >
-    <div class="col-sm-3">
+    <div class="col-md-12" align="left">
     <button type="button" ng-click="confirm_remove_base=true"
         ng-model="btn_remove_base"
         ng-hide="confirm_remove_base"
     ><%= l 'Remove Base' %></button>
-    </div>
-    <div class="col-sm-8" ng-hide="confirm_remove_base">
-        <p><%=l 'Remove the base prepared from this machine' %></p>
+        <span class="info"><%=l 'Remove the base prepared from this machine' %></span>
     </div>
 </div>
 
diff --git a/templates/main/vm_share.html.ep b/templates/main/vm_share.html.ep
index 3d53b27cf..da90a3d19 100644
--- a/templates/main/vm_share.html.ep
+++ b/templates/main/vm_share.html.ep
@@ -10,9 +10,10 @@
                 <i class="fa fa-search" aria-hidden="true"
                 ng-click="search_shared_user()"
                 ></i>
-                <span ng-show="shared_user_found && !searching_shared_user">
+                <span ng-show="!searching_shared_user && shared_user_count>=0 && !shared_user_found ">
                 {{shared_user_count}} <%=l 'found' %>
                 </span>
+                <span ng-show="shared_user_found"><%=l 'Exact match' %></span>
                 <i class="fas fa-sync-alt fa-spin"
                     ng-show="searching_shared_user"></i>
             </div>