Changeset 692 for trunk/cgi-bin

Timestamp:

02/11/15 18:43:22 (10 years ago)

Author:

Kris Deugau

Message:

/trunk

Start adding support for advisory "reserved block" assignments - when
creating a new assignment, flag an equal-sized block ahead or behind
to expand the assignment in the future. See #24.

• free block assignment
• guided assignment (still needs tweaking to dodge existing reserved blocks)
• note flagged blocks in free block list

Location:

trunk/cgi-bin

Files:

• IPDB.pm (modified) (6 diffs)
• main.cgi (modified) (6 diffs)

trunk/cgi-bin/IPDB.pm

@@ -674 +674 @@
   $args{vrf} = '' if !$args{vrf};
 
-  my $sth = $dbh->prepare("SELECT cidr,id FROM freeblocks WHERE parent_id = ? ORDER BY cidr");
+  my $sth = $dbh->prepare(q(
+        SELECT f.cidr,f.id,allocations.cidr
+        FROM freeblocks f
+        LEFT JOIN allocations ON f.reserve_for = allocations.id
+        WHERE f.parent_id = ?
+        ORDER BY f.cidr
+        ) );
 #  $sth->execute($args{parent}, $args{vrf});
   $sth->execute($args{parent});
   my @flist;
-  while (my ($cidr,$id) = $sth->fetchrow_array()) {
+  while (my ($cidr,$id,$resv) = $sth->fetchrow_array()) {
     $cidr = new NetAddr::IP $cidr;
     my %row = (
@@ -685 +691 @@
         fbid => $id,
         fbparent => $args{parent},
+        resv => $resv,
         );
     push @flist, \%row;
@@ -985 +992 @@
         undef, $args{fbid});
   $alloc_from = new NetAddr::IP $alloc_from;
+  return ('FAIL',"Failed to allocate $args{cidr};  intended free block was used by another allocation.")
+        if !$fbparent;
+##fixme:  fail here if !$alloc_from
+# also consider "lock for allocation" due to multistep allocation process
 
   # To contain the error message, if any.
@@ -1117 +1128 @@
         $dbh->do("DELETE FROM freeblocks WHERE id = ?", undef, ($args{fbid}) );
 
-        # Insert new list of smaller free blocks left over
-        $sth = $dbh->prepare("INSERT INTO freeblocks (cidr,city,routed,vrf,parent_id,master_id) VALUES (?,?,?,?,?,?)");
-        foreach my $block (@newfreeblocks) {
-          $sth->execute($block, $fcity, $alloc_from_type, $args{vrf}, $fbparent, $fbmaster);
-        }
-
         # Insert the allocations entry
         $dbh->do("INSERT INTO allocations ".
@@ -1130 +1135 @@
                 $args{desc}, $args{notes}, $args{circid}, $args{privdata}, $args{rdns}) );
         my ($bid) = $dbh->selectrow_array("SELECT currval('allocations_id_seq')");
+
+        # Insert new list of smaller free blocks left over. Flag the one that matches the
+        # masklength of the new allocation, if a reserve block was requested.
+        $sth = $dbh->prepare("INSERT INTO freeblocks (cidr,city,routed,vrf,parent_id,master_id,reserve_for) ".
+                "VALUES (?,?,?,?,?,?,?)");
+        foreach my $block (@newfreeblocks) {
+          $sth->execute($block, $fcity, $alloc_from_type, $args{vrf}, $fbparent, $fbmaster,
+                ($block->masklen == $wantmaskbits ? $bid : 0));
+        }
 
         # For routed/container types, add a freeblock within the allocated block so we can subdivide it further
@@ -1714 +1728 @@
   my ($btype) = $dbh->selectrow_array("SELECT type FROM allocations WHERE id=?", undef, ($id) );
 
+  # Note city, vrf, parent_id and master_id removed due to JOIN uncertainty for block allocations
+  my $commonfields = q(custid, type, circuitid, description, notes, modifystamp AS lastmod,
+        privdata, vlan, rdns);
+
   if ($type eq 'i') {
-    my $binfo = $dbh->selectrow_hashref("SELECT ip AS block, custid, type, city, circuitid, description,".
-        " notes, modifystamp AS lastmod, privdata, vrf, vlan, rdns, parent_id, master_id".
-        " FROM poolips WHERE id = ?", undef, ($id) );
+    my $binfo = $dbh->selectrow_hashref(qq(
+        SELECT ip AS block, city, vrf, parent_id, master_id, $commonfields
+        FROM poolips WHERE id = ?
+        ), undef, ($id) );
     return $binfo;
   } else {
-    my $binfo = $dbh->selectrow_hashref("SELECT cidr AS block, custid, type, city, circuitid, ".
-        "description, notes, modifystamp AS lastmod, privdata, vrf, vlan, swip, rdns, parent_id, master_id".
-        " FROM allocations WHERE id = ?", undef, ($id) );
+    my $binfo = $dbh->selectrow_hashref(qq(
+        SELECT a.cidr AS block, a.city, a.vrf, a.parent_id, a.master_id, swip, $commonfields,
+                f.cidr AS reserve, f.id as reserve_id
+        FROM allocations a LEFT JOIN freeblocks f ON a.id=f.reserve_for
+        WHERE a.id = ?
+        ), undef, ($id) );
     return $binfo;
   }

trunk/cgi-bin/main.cgi

@@ -410 +410 @@
 
   my $cidr;
+  my $resv;   # Reserved for expansion.
   my $alloc_from;
   my $fbid = $webvar{fbid};
@@ -443 +444 @@
       $alloc_from = new NetAddr::IP $webvar{allocfrom};
       $webvar{maskbits} = $cidr->masklen;
+      # Some additional checks are needed for reserving free space
+      if ($webvar{reserve}) {
+        if ($cidr == $alloc_from) {
+# We could still squirm and fiddle to try to find a way to reserve space, but the storage model for
+# IPDB means that all continguous free space is kept in the smallest number of strict CIDR netblocks
+# possible.  (In theory.)  If the request and the freeblock are the same, it is theoretically impossible
+# to reserve an equivalent-sized block either ahead or behind the requested one, because the pair
+# together would never be a strict CIDR block.
+          $page->param(warning => "Can't reserve space for expansion;  free block and requested allocation are the same.");
+          delete $webvar{reserve};
+        } else {
+          # Find which new free block will match the reqested block.
+          # Take the requested mask, shift by one
+          my $tmpmask = $webvar{maskbits};
+          $tmpmask--;
+          # find the subnets with that mask in the selected free block
+          my @pieces = $alloc_from->split($tmpmask);
+          foreach my $slice (@pieces) {
+            if ($slice->contains($cidr)) {
+              # For the subnet that contains the requested block, split that in two,
+              # and flag/cache the one that's not the requested block.
+              my @bits = $slice->split($webvar{maskbits});
+              if ($bits[0] == $cidr) {
+                $resv = $bits[1];
+              } else {
+                $resv = $bits[0];
+              }
+            }
+          }
+        }
+      } # reserve block check
+
     } else { # done with direct freeblocks assignment
 
@@ -465 +498 @@
           }
           $failmsg .= "You will have to route another superblock to $webvar{pop}<br>\n".
-                "from one of the master blocks or chose a smaller blocksize.";
+                "from one of the master blocks";
+          if ($webvar{reserve}) {
+            $failmsg .= ', choose a smaller blocksize, or uncheck "Reserve space for expansion".';
+          } else {
+            $failmsg .= " or chose a smaller blocksize.";
+          }
         }
       }
 
-## fixme:  add rdepth?
+      # if requesting extra space "reserved for expansion", we need to find a free
+      # block at least double the size of the request.
+      if ($webvar{reserve}) {
+        $webvar{maskbits}--;
+      }
+
       ($fbid,$cidr,$p_id) = findAllocateFrom($ip_dbh, $webvar{maskbits}, $webvar{alloctype},
         $webvar{city}, $webvar{pop}, (master => $webvar{allocfrom}, allowpriv => $webvar{allowpriv}) );
@@ -478 +521 @@
       $cidr = new NetAddr::IP $cidr;
 
-# this chunk now specific to "guided" allocation;  freeblock-select can now slice-n-dice on its own.      
       $alloc_from = "$cidr";
+
+      # when autofinding a block to allocate from, use the first piece of the found
+      # block for the allocation, and the next piece for the "reserved for expansion".
+      if ($webvar{reserve}) {
+        # reset the mask to the real requested one, now that we've got a
+        # block large enough for the request plus reserve
+        $webvar{maskbits}++;
+        ($cidr,$resv) = $cidr->split($webvar{maskbits});
+      }
+
       # If the block to be allocated is smaller than the one we found,
       # figure out the "real" block to be allocated.
@@ -524 +576 @@
 ## end node hack
 
+  # reserve for expansion
+  $page->param(reserve => $webvar{reserve});
+  # probably just preventing a little log noise doing this;  could just set the param
+  # all the time since it won't be shown if the reserve param above isn't set.
+#  if ($webvar{reserve}) {
+    $page->param(resvblock => $resv);
+#  }
+
   # Stick in the allocation data
   $page->param(alloc_type => $webvar{alloctype});
@@ -592 +652 @@
         cidr            => $webvar{fullcidr},
         fbid            => $webvar{fbid},
+        reserve         => $webvar{reserve},
         parent          => $webvar{parent},
         custid          => $webvar{custid},