Changeset 692 for trunk/cgi-bin/main.cgi

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

File:

• trunk/cgi-bin/main.cgi (modified) (6 diffs)

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},