Changeset 638 for trunk/cgi-bin

Timestamp:

10/09/14 18:13:22 (10 years ago)

Author:

Kris Deugau

Message:

/trunk

Commit 10/mumble for work done intermittently over the past ~year.
See #5, comment 25:

• Update block delete. Includes a little current work to fix outstanding edge case issues

Location:

trunk/cgi-bin

Files:

• IPDB.pm (modified) (13 diffs)
• main.cgi (modified) (4 diffs)

trunk/cgi-bin/IPDB.pm

@@ -1247 +1247 @@
 # as well as the reverse entry
 sub deleteBlock {
-  my ($dbh,undef,$rdepth,$vrf,$delfwd,$user) = @_;
-  my $cidr = new NetAddr::IP $_[1];
+  my ($dbh,$id,$basetype,$delfwd,$user) = @_;
+
+  # Collect info about the block we're going to delete
+  my $binfo = getBlockData($dbh, $id, $basetype);
+  my $cidr = new NetAddr::IP $binfo->{block};
 
 # For possible auto-VRF-ignoring (since public IPs shouldn't usually be present in more than one VRF)
@@ -1267 +1270 @@
   my $con_type;
 
-  # Collect info about the block we're going to delete
-  my $binfo = getBlockData($dbh, $cidr, $rdepth, $vrf);
 
   # temporarily forced null, until a sane UI for VRF tracking can be found.
-  $vrf = '';# if !$vrf; # as with SQL, the null value is not equal to ''.  *sigh*
+#  $vrf = '';# if !$vrf;        # as with SQL, the null value is not equal to ''.  *sigh*
 
   # To contain the error message, if any.
@@ -1281 +1282 @@
   local $dbh->{RaiseError} = 1;
 
-  # First case.  The "block" is a static IP
-  # Note that we still need some additional code in the odd case
-  # of a netblock-aligned contiguous group of static IPs
   if ($binfo->{type} =~ /^.i$/) {
+    # First case.  The "block" is a static IP
+    # Note that we still need some additional code in the odd case
+    # of a netblock-aligned contiguous group of static IPs
 
     eval {
       $msg = "Unable to deallocate $disp_alloctypes{$binfo->{type}} $cidr";
-      my ($pool,$pcust,$pvrf) = $dbh->selectrow_array("SELECT pool,custid,vrf FROM poolips WHERE ip=?", undef, ($cidr) );
+      my $pinfo = getBlockData($dbh, $binfo->{parent_id}, 'b');
 ##fixme: VRF and rdepth
-      $dbh->do("UPDATE poolips SET custid=?,available='y',".
-        "city=(SELECT city FROM allocations WHERE cidr=?),".
-        "description='',notes='',circuitid='',vrf=? WHERE ip=?", undef, ($pcust, $pool, $pvrf, $cidr) );
-      $goback = $pool;
+      $dbh->do("UPDATE poolips SET custid = ?, available = 'y',".
+        "city = (SELECT city FROM allocations WHERE id = ?),".
+        "description = '', notes = '', circuitid = '', vrf = ? WHERE id = ?", undef,
+        ($pinfo->{custid}, $binfo->{parent_id}, $pinfo->{vrf}, $id) );
       $dbh->commit;
     };
@@ -1302 +1303 @@
     } else {
 ##fixme:  RPC return code?
-      _rpc('delByCIDR', cidr => "$cidr", user => $user, delforward => $delfwd);
+      _rpc('delByCIDR', cidr => "$cidr", user => $user, delforward => $delfwd, rpcuser => $user);
       return ('OK',"OK");
     }
 
   } elsif ($binfo->{type} eq 'mm') { # end alloctype =~ /.i/
+    # Second case.  The block is a full master block
 
 ##fixme: VRF limit
     $msg = "Unable to delete master block $cidr";
     eval {
-      $dbh->do("DELETE FROM masterblocks WHERE cidr = ?", undef, ($cidr) );
-      $dbh->do("DELETE FROM allocations WHERE cidr <<= ?", undef, ($cidr) );
-      $dbh->do("DELETE FROM freeblocks WHERE cidr <<= ?", undef, ($cidr) );
+      $dbh->do("DELETE FROM allocations WHERE cidr <<= ? AND master_id = ?", undef, ($cidr, $binfo->{master_id}) );
+      $dbh->do("DELETE FROM freeblocks WHERE cidr <<= ? AND master_id = ?", undef, ($cidr, $binfo->{master_id}) );
       $dbh->commit;
     };
@@ -1335 +1336 @@
     my @fails;
     foreach my $subzone (@zonelist) {
-      if ($rpc_url && !_rpc('delZone', zone => "$subzone", revrec => 'y', user => $user, delforward => $delfwd) ) {
+      if ($rpc_url && !_rpc('delZone', zone => "$subzone", revrec => 'y', rpcuser => $user, delforward => $delfwd) ) {
         push @fails, ("$subzone" => $errstr);
       }
@@ -1352 +1353 @@
 
     my $retcode = 'OK';
-    my ($ptype,$pcity,$ppatt);
+    my ($ptype,$pcity,$ppatt,$p_id);
 
     eval {
@@ -1359 +1360 @@
 # explicitly deleting any suballocations of the block to be deleted.
 
-      # find the current parent of the block we're deleting
-      my ($parent) = $dbh->selectrow_array("SELECT parent FROM allocations WHERE cidr=? AND rdepth=?",
-        undef, ($cidr, $rdepth) );
+      # get parent info of the block we're deleting
+      my $pinfo = getBlockData($dbh, $binfo->{parent_id});
+      $ptype = $pinfo->{type};
+      $pcity = $pinfo->{city};
+      $ppatt = $pinfo->{rdns};
+      $p_id = $binfo->{parent_id};
 
       # Delete the block
-      $dbh->do("DELETE FROM allocations WHERE cidr=? AND rdepth=?", undef, ($cidr, $rdepth) );
-
-##fixme:  we could maybe eliminate a special case if we put masterblocks in the allocations table...?
-      if ($rdepth == 1) {
-        # parent is a master block.
-        $ptype = 'mm';
-        $pcity = '<NULL>';
-        $ppatt = $dbh->selectrow_array("SELECT rdns FROM masterblocks WHERE cidr=?", undef, ($parent) );
-      } else {
-        # get that parent's details
-        ($ptype,$pcity,$ppatt) = $dbh->selectrow_array("SELECT type,city,rdns FROM allocations ".
-                "WHERE cidr=? AND rdepth=?", undef, ($parent, $rdepth-1) );
-      }
+      $dbh->do("DELETE FROM allocations WHERE id = ?", undef, ($id) );
 
       # munge the parent type a little
-      $ptype = (split //, $ptype)[0];
+      $ptype = (split //, $ptype)[1];
 
 ##fixme:  you can't...  CAN NOT....  assign the same public IP to multiple things.
@@ -1385 +1377 @@
 # -> $isprivnet flag from start of sub
 
-      my $fbrdepth = $rdepth;
-
       # check to see if any container allocations could be the "true" parent
-      my ($tparent,$trdepth,$trtype,$tcity) = $dbh->selectrow_array("SELECT cidr,rdepth,type,city FROM allocations ".
-        "WHERE (type='rm' OR type LIKE '_c') AND cidr >> ? ".
-        "ORDER BY masklen(cidr) DESC", undef, ($cidr) );
-
-      my $fparent;
-      if ($tparent && $tparent ne $parent) {
-        # found an alternate parent;  reset some parent-info bits
-        $parent = $tparent;
-        $ptype = (split //, $trtype)[0];
-        $pcity = $tcity;
-        ##fixme: hmm.  collect $rdepth into $goback here before vanishing?
-        $retcode = 'WARNMERGE'; # may be redundant
-        $goback = $tparent;
-        # munge freeblock rdepth and parent to match true parent
-        $dbh->do("UPDATE freeblocks SET rdepth = ?, parent = ?, routed = ? WHERE cidr <<= ? AND rdepth = ?", undef,
-                ($trdepth+1, $parent, $ptype, $cidr, $rdepth) );
-        $rdepth = $trdepth;
-        $fbrdepth = $trdepth+1;
-      }
-
-      $parent = new NetAddr::IP $parent;
-      $goback = "$parent,$fbrdepth";    # breadcrumb in case of live-parent-is-not-true-parent
-
-      # Special case - delete pool IPs
-      if ($binfo->{type} =~ /^.[pd]$/) {
-        # We have to delete the IPs from the pool listing.
-##fixme:  rdepth?  vrf?
-        $dbh->do("DELETE FROM poolips WHERE pool = ?", undef, ($cidr) );
-      }
-
-      # Find out if the block we're deallocating is within a DSL pool (legacy goo)
-      my ($pool,$poolcity,$pooltype,$pooldepth) = $dbh->selectrow_array(
-        "SELECT cidr,city,type,rdepth FROM allocations WHERE type LIKE '_p' AND cidr >>= ?",
-        undef, ($cidr) );
-
-      # If so, return the block's IPs to the pool, instead of to freeblocks
-## NB: not possible to currently cause this even via admin tools, only legacy data.
-      if ($pool) {
-        ## Deallocate legacy blocks stashed in the middle of a static IP pool
-        ## This may be expandable to an even more general case of contained netblock, or other pool types.
-        $retcode = 'WARNPOOL';
-        $goback = "$pool,$pooldepth";
-        # We've already deleted the block, now we have to stuff its IPs into the pool.
-        $pooltype =~ s/p$/i/;   # change type to static IP
-        my $sth2 = $dbh->prepare("INSERT INTO poolips (pool,ip,city,type,custid) VALUES ".
-                "('$pool',?,'$poolcity','$pooltype','$defcustid')");
-        # don't insert .0
+      my ($tparent,$tpar_id,$trtype,$tcity);
+      $tpar_id = 0;
+
+##fixme:  this is far simpler in the strict VRF case;  we "know" that any allocation
+# contained by a container is a part of the same allocation tree when the VRF fields are equal.
+
+# logic:
+# For each possible container of $cidr
+#  note the parent id
+#  walk the chain up the parents
+#    if we intersect $cidr's current parent, break
+#  if we've intersected $cidr's current parent
+#    set some variables to track that block
+#    break
+
+# Set up part of "is it in the middle of a pool?" check
+      my $wuzpool = $dbh->selectrow_hashref("SELECT cidr,parent_id,type,city,custid,id FROM allocations ".
+        "WHERE (type LIKE '_d' OR type LIKE '_p') AND cidr >> ? AND master_id = ?", { Slice => {} },
+        ($cidr, $binfo->{master_id}) );
+
+##fixme?
+# edge cases not handled, or handled badly:
+# -> $cidr managed to get to be the entirety of an IP pool
+
+      if ($wuzpool && $wuzpool->{id} != $id) {
+        # we have legacy goo to be purified
+        # going to ignore nested pools;  not possible to create them via API and no current legacy data includes any.
+
+        # for convenience
+        my $poolid = $wuzpool->{id};
+        my $pool = $wuzpool->{cidr};
+        my $poolcity = $wuzpool->{city};
+        my $pooltype = $wuzpool->{type};
+        my $poolcustid = $wuzpool->{custid};
+
+        $retcode = 'WARNPOOL';
+        $goback = "$poolid,$pool";
+        # We've already deleted the block, now we have to stuff its IPs into the pool.
+        $pooltype =~ s/[dp]$/i/;        # change type to static IP
+        my $sth2 = $dbh->prepare("INSERT INTO poolips (ip,city,type,custid,parent_id) VALUES ".
+          "(?,'$poolcity','$pooltype','$poolcustid',$poolid)");
 ##fixme:  need to not insert net, gateway, and bcast on "real netblock" pools (DHCPish)
-        $sth2->execute($cidr->addr) unless $cidr->addr =~ m|\.0$|;
-        foreach my $ip ($cidr->hostenum) {
-          $sth2->execute($ip);
-        }
-        $cidr--;
-        # don't insert .255
-        $sth2->execute($cidr->addr) unless $cidr->addr =~ m|\.255$|;
-      } else {  # done returning IPs from a block to a static DSL pool
+        # don't insert .0
+        $sth2->execute($cidr->addr) unless $cidr->addr =~ m|\.0$|;
+        foreach my $ip ($cidr->hostenum) {
+          $sth2->execute($ip);
+        }
+        $cidr--;
+        # don't insert .255
+        $sth2->execute($cidr->addr) unless $cidr->addr =~ m|\.255$|;
+      }
+
+## important!
+# ... or IS IT?
+# we may have undef'ed $wuzpool above, if the allocation tree $cidr is in doesn't intersect the pool we found
+#if (!$wuzpool) {
+
+      else {
+
+        # Get all possible (and probably a number of impossible) containers for $cidr
+        $sth = $dbh->prepare("SELECT cidr,parent_id,type,city,id FROM allocations ".
+          "WHERE (type LIKE '_m' OR type LIKE '_c') AND cidr >>= ? AND master_id = ? ".
+          "ORDER BY masklen(cidr) DESC");
+        $sth->execute($cidr, $binfo->{master_id});
+
+        # Quickly get certain fields (simpler than getBlockData()
+        my $sth2 = $dbh->prepare("SELECT cidr,parent_id,type,city FROM allocations ".
+          "WHERE (type LIKE '_m' OR type LIKE '_c') AND id = ? AND master_id = ?");
+
+        # For each possible container of $cidr...
+        while (my @data = $sth->fetchrow_array) {
+          my $i = 0;
+          # Save some state and set a start point - parent ID of container we're checking
+          $tparent = $data[0];
+          my $ppid = $data[1];
+          $trtype = $data[2];
+          $tcity = $data[3];
+          $tpar_id = $data[4];
+          last if $data[4] == $binfo->{parent_id};  # Preemptively break if we're already in the right place
+          last if $ppid == $binfo->{parent_id};     # ... or if the parent of the container is the block's parent
+          while (1) {
+            # Retrieve bits on that parent ID
+            $sth2->execute($ppid, $binfo->{master_id});
+            my @container = $sth2->fetchrow_array;
+            $ppid = $container[1];
+            last if $container[1] == 0;   # Break if we've hit a master block
+            last if $ppid == $binfo->{parent_id};   # Break if we've reached the block $cidr is currently in
+          }
+          last if $ppid == $binfo->{parent_id};
+        }
+
+        # found an alternate parent;  reset some parent-info bits
+        if ($tpar_id != $binfo->{parent_id}) {
+          $ptype = (split //, $trtype)[1];
+          $pcity = $tcity;
+          $retcode = 'WARNMERGE';       # may be redundant
+          $p_id = $tpar_id;
+        }
+
+        $goback = "$p_id,$tparent";     # breadcrumb, currently only used in case of live-parent-is-not-true-parent
+
+        # Special case - delete pool IPs
+        if ($binfo->{type} =~ /^.[pd]$/) {
+          # We have to delete the IPs from the pool listing.
+          $dbh->do("DELETE FROM poolips WHERE parent_id = ?", undef, ($id) );
+        }
+
+        $pinfo = getBlockData($dbh, $p_id);
 
         # If the block wasn't legacy goo embedded in a static pool, we check the
@@ -1452 +1494 @@
           # move the freeblocks into the parent
           # we don't insert a new freeblock because there could be a live reparented sub.
-          $dbh->do("UPDATE freeblocks SET rdepth=rdepth-1,parent=?,routed=?,city=? ".
-                "WHERE parent=? AND rdepth=?", undef,
-                ($parent, $ptype, $pcity, $cidr, $rdepth+1) );
+          $dbh->do("UPDATE freeblocks SET parent_id = ?, routed = ?, city = ? WHERE parent_id = ?", undef,
+                ($p_id, $ptype, $pcity, $id) );
         } else {
           # ... otherwise, add the freeblock
-          $dbh->do("INSERT INTO freeblocks (cidr, city, routed, parent, rdepth) VALUES (?,?,?,?,?)", undef,
-                ($cidr, $pcity, $ptype, $parent, $rdepth) );
+          $dbh->do("INSERT INTO freeblocks (cidr, city, routed, parent_id, master_id) VALUES (?,?,?,?,?)", undef,
+                ($cidr, $pcity, $ptype, $p_id, $binfo->{master_id}) );
         }
 
 ##fixme: vrf
+##fixme:  simplify since all containers now represent different "layers"/"levels"?
         # set up the query to get the list of blocks to try to merge.
-        $sth = $dbh->prepare("SELECT cidr FROM freeblocks ".
-                "WHERE parent = ? AND routed = ? AND rdepth = ? ".
+        $sth = $dbh->prepare("SELECT cidr,id FROM freeblocks ".
+                "WHERE parent_id = ? ".
                 "ORDER BY masklen(cidr) DESC");
 
-        $sth->execute($parent, $ptype, $fbrdepth);
+        $sth->execute($p_id);
 
 # NetAddr::IP->compact() attempts to produce the smallest inclusive block
@@ -1477 +1519 @@
 #       $cidr=.32/27, $ip1=.96/27, $ip2=.0/27, and $ip3=.64/27.
 
-        my (@rawfb, @combinelist);
+        my (@rawfb, @combinelist, %rawid);
         my $i=0;
         # for each free block under $parent, push a NetAddr::IP object into one list, and
@@ -1484 +1526 @@
           my $testIP = new NetAddr::IP $data[0];
           push @rawfb, $testIP;
+          $rawid{$data[0]} = $data[1];
           @combinelist = $testIP->compact(@combinelist);
         }
@@ -1489 +1532 @@
         # now that we have the full list of "compacted" freeblocks, go back over
         # the list of raw freeblocks, and delete the ones that got merged.
-        $sth = $dbh->prepare("DELETE FROM freeblocks WHERE cidr=? AND parent=? AND rdepth=?");
+        $sth = $dbh->prepare("DELETE FROM freeblocks WHERE id = ?");
         foreach my $rawfree (@rawfb) {
           next if grep { $rawfree == $_ } @combinelist; # skip if the raw block is in the compacted list
-          $sth->execute($rawfree, $parent, $fbrdepth);
+          $sth->execute($rawid{$rawfree});
         }
 
         # now we walk the new list of compacted blocks, and see which ones we need to insert
-        $sth = $dbh->prepare("INSERT INTO freeblocks (cidr,city,routed,parent,rdepth) VALUES (?,?,?,?,?)");
+        $sth = $dbh->prepare("INSERT INTO freeblocks (cidr,city,routed,parent_id,master_id) VALUES (?,?,?,?,?)");
         foreach my $cme (@combinelist) {
           next if grep { $cme == $_ } @rawfb;   # skip if the combined block was in the raw list
-          $sth->execute($cme, $pcity, $ptype, $parent, $fbrdepth);
+          $sth->execute($cme, $pcity, $ptype, $p_id, $binfo->{master_id});
         }
 
@@ -1513 +1556 @@
     } else {
 ##fixme:  RPC return code?
-      _rpc('delByCIDR', cidr => "$cidr", user => $user, delforward => $delfwd, delsubs => 'y', parpatt => $ppatt);
+      _rpc('delByCIDR', cidr => "$cidr", rpcuser => $user, delforward => $delfwd, delsubs => 'y', parpatt => $ppatt);
       return ($retcode, $goback);
     }

trunk/cgi-bin/main.cgi

@@ -821 +821 @@
 
   my $blockdata;
-
-  if ($webvar{rdepth} == 0) {   # $webvar{alloctype} eq 'mm'
-
-    $blockdata->{block} = $webvar{block};
+  $blockdata = getBlockData($ip_dbh, $webvar{block}, $webvar{basetype});
+
+  if ($blockdata->{parent_id} == 0) {   # $webvar{alloctype} eq 'mm'
     $blockdata->{city} = "N/A";
     $blockdata->{custid} = "N/A";
-    $blockdata->{type} = 'mm';
     $blockdata->{circuitid} = "N/A";
     $blockdata->{description} = "N/A";
     $blockdata->{notes} = "N/A";
     $blockdata->{privdata} = "N/A";
-    $blockdata->{rdepth} = 0;
-
-  } else {
-
-    $blockdata = getBlockData($ip_dbh, $webvar{block}, $webvar{rdepth});
-
   } # end cases for different alloctypes
 
+  $page->param(blockid => $webvar{block});
+  $page->param(basetype => $webvar{basetype});
+
   $page->param(block => $blockdata->{block});
-
   $page->param(rdns => $blockdata->{rdns});
 
@@ -853 +847 @@
   }
 
-  $page->param(rdepth => $blockdata->{rdepth});
   $page->param(disptype => $disp_alloctypes{$blockdata->{type}});
-#  $page->param(type => $blockdata->{type});
   $page->param(city => $blockdata->{city});
   $page->param(custid => $blockdata->{custid});
@@ -883 +875 @@
 
   # need to retrieve block data before deleting so we can notify on that
-  my $blockinfo = getBlockData($ip_dbh, $webvar{block}, $webvar{rdepth});
-
-  my ($code,$msg) = deleteBlock($ip_dbh, $webvar{block}, $webvar{rdepth}, $webvar{vrf}, $webvar{delforward}, $authuser);
-
-  $page->param(block => $webvar{block});
-  $page->param(delparent => $blockinfo->{parent}) if $webvar{rdepth};
-  $page->param(prdepth => $webvar{rdepth});
+  my $blockinfo = getBlockData($ip_dbh, $webvar{block}, $webvar{basetype});
+  my $pinfo = getBlockData($ip_dbh, $blockinfo->{parent_id}, 'b');
+
+  my ($code,$msg) = deleteBlock($ip_dbh, $webvar{block}, $webvar{basetype}, $webvar{delforward}, $authuser);
+
+  $page->param(block => $blockinfo->{block});
+  $page->param(delparent_id => $blockinfo->{parent_id});# if $webvar{rdepth};
+  $page->param(delparent => $pinfo->{block});
+  $page->param(returnpool => ($webvar{basetype} eq 'i') );
   if ($code =~ /^WARN(POOL|MERGE)/) {
-    my ($bp,$bd) = split /,/, $msg;
-    $page->param(bparent => $bp);
-    $page->param(brdepth => $bd);
+    my ($pid,$pcidr) = split /,/, $msg;
+    $page->param(parent_id => $pid);
+    $page->param(parent => $pcidr);
     $page->param(mergeip => $code eq 'WARNPOOL');
   }
@@ -901 +895 @@
   }
   if ($code eq 'OK' || $code =~ /^WARN/) {
-    syslog "notice", "$authuser deallocated '$webvar{alloctype}'-type netblock $webvar{block} ".
+    syslog "notice", "$authuser deallocated '".$blockinfo->{type}."'-type netblock $webvar{block} ".
         $blockinfo->{custid}.", ".$blockinfo->{city}.", desc='".$blockinfo->{description}."'";
-    mailNotify($ip_dbh, 'da', "REMOVED: $disp_alloctypes{$webvar{alloctype}} $webvar{block}",
-        "$disp_alloctypes{$webvar{alloctype}} $webvar{block} deallocated by $authuser\n".
+    mailNotify($ip_dbh, 'da', "REMOVED: ".$disp_alloctypes{$blockinfo->{type}}." $webvar{block}",
+        $disp_alloctypes{$blockinfo->{type}}." $webvar{block} deallocated by $authuser\n".
         "CustID: ".$blockinfo->{custid}."\nCity: ".$blockinfo->{city}.
         "\nDescription: ".$blockinfo->{description}."\n");