grasp-impls.html

---
layout: default
title: GRASP Implementations
---
      <div class='jumbotron'>
        <h2>GRASP Implementations</h2>
        <p class='lead'>
          GRASP is typically implemented as a library that is part of a
          larger Autonomic Service Agent (ASA).
          <br>
        </p>
        <h2>GRASP talks and tutorials</h2>

        <h3>GRASP Prefix Management Demonstration</h3>

        <p>
        GRASP, the GeneRic Autonomic Signaling Protocol, is specified in
        <a href="https://www.rfc-editor.org/rfc/rfc8990.html">RFC8990</a>,
        and an API is specified in
        <a href="https://www.rfc-editor.org/rfc/rfc8991.html">RFC8991</a>. Here's a
        <a href="https://github.com/becarpenter/graspy/blob/master/GRASP-intro.pdf">general
        introduction to GRASP</a>
          We
        have every intention of writing a longer tutorial, but it hasn't
        happened yet.
        </p>

        <p>
          A fully designed use case for GRASP is documented in
          <a href="https://www.rfc-editor.org/rfc/rfc8992.html">RFC8992</a>
          It covers a network management application that could apply to a local
          Internet Service Provider (ISP) or to a large, multi-site enterprise
          network.
          Such operators need to manage IP address space and distribute
          blocks of addresses (i.e., address prefixes) to routers near the
          edges of their network. In turn, those routers delegate such
          prefixes to customers or first-hop routers that require them. The
          RFC defines a GRASP "objective" that allows address space
          management to occur autonomically, without operator involvement
          beyond creating an original pool of addresses. In full deployment,
          this would replace or automate a conventional APAM (address
          planning and management tool). In early deployment, it would need
          to interwork with an existing APAM and in some scenarios with a
          RADIUS server.
        </p>

        <p>
          The following video demonstration shows a proof of concept. The
          terminology adopted is as follows:
          <ul>
            <li> Origin Server: An autonomic service agent configured
              initially with two address pools (IPv4 and IPv6).

            <li> Delegator: An autonomic service agent that initially has no
            address pools, but needs IP prefixes that it can delegate to
              (imaginary) client routers or local routers.
          </ul>

        </p>
        <p>
          In the demo, you will see an origin server and two delegators,
          running in the same computer for simplicity in making the video. In
          practice, there would be one origin server (associated with a
          Network Operations Center) and any number of delegators placed
          elsewhere in the ISP or enterprise network. The same Python code
          runs as the origin server or as a delegator, controlled by a
          start-up option. After the demo has been running for a while,
          although the origin server remains active, individual delegators
          may use GRASP to discover each other and negotiate a transfer of a
          prefix when needed. In a large and dynamic network, this will
          automatically optimize the distribution of available prefixes
          around the network: a region that is running short of prefixes can
          get them from region that has too many, without operator
          intervention.
        </p>

        <p>
          There's also <a href="https://github.com/becarpenter/graspy/blob/master/pfxm3.pdf">a technical write-up of the demo code</a>

          <a href="https://youtu.be/yJsuLICMvdk">Enjoy the video here!</a>
          You may want to pause the video from time to time as there is quite a lot of text to read.
        </p>

      </div>
      <hr>
      <div class='row-fluid'>
        <div class='span4'>
          <h2 id="javascript">JavaScript</h2>
          <h2 id="php">PHP</h2>
          <h2 id="perl">Perl</h2>
          <h2 id="go">Go</h2>
          <h2 id="rust">Rust</h2>

          <p>The <a href="https://minerva.sandelman.ca/">ANIMAgus Minerva</a>
            <a href="https://minerva.sandelman.ca/hermes">Hermes</a>
            contains a minimal implementation of the GRASP DULL as required
            to bootstrap the Autonomic Control Plane.
          </p>
          <p> It is written in Rust.</p>

          <p><a class="btn" href="https://github.com/ANIMAgus-minerva/hermes">View details »</a></p>

          <h2 id="swift">Swift</h2>

        </div>
        <div class='span4'>
          <h2 id="lua">Lua</h2>

          <h2 id="python">Python</h2>

          <p>GRASPY is written in Python3.</p>
          <p><a class="btn" href="https://github.com/becarpenter/graspy">View details »</a></p>

          <h2 id="ruby">Ruby</h2>

          <h2 id="erlang-elixir">Erlang, Elixir</h2>

          <h2 id="haskell">Haskell</h2>

          <h2 id="ocaml">OCaml</h2>

          <h2 id="scala">Scala</h2>

          <h2 id="clojure">Clojure</h2>

          <h2 id="d">D</h2>

          <h2 id="crystal">Crystal</h2>

          <h2 id="julia">Julia</h2>

        </div>
        <div class='span4'>
          <h2 id="java">Java</h2>
          <h2 id="c-java">C#, Java</h2>

          <h2 id="c">C#</h2>

          <h2 id="c-c">C, C++</h2>

        </div>
      </div>