Skip to content

History

Jump to bottom
jfuruness edited this page Oct 31, 2024 · 174 revisions

Home

Stable releases

  • 11.3.2 Added a check to the base BGP to drop announcements containing AS 0 in accordance with RFC7607
  • 11.3.1 Removed windows support from CI/CD
  • 11.3.0 Added PeerlockLite
  • 11.2.2 Fixed another bug in the ProviderConeID logic, another off by one error. Everything should be all set now though lol
  • 11.2.1 Fixed a bug in the ProviderConeID logic, an off by one error that did not check the last ASN (the receiving ASN) in the AS path. This would have affected ProviderConeID and BGP-iSec policies.
  • 11.2.0 Added a utils function to get the current ROV deployment
  • 11.1.1 Fixed a bug in ROV++ where all routed prefixes were being blackholed. If you were simulating with ROV++ this would affect results, and if you had tests using ROV++ you'd need to run pytest with --overwrite.
  • 11.1.0 Added hardcoded_base_asn_cls_dict to the scenario_config. This can be used so that by default, an AS will use a specific policy instead of the BasePolicyCls. For example, this can be useful if by default you want to have ASes adopting ROV.
  • 11.0.0
    • Apologies for the major release so quickly. This one does break a considerable amount of backwards compatability. Previously we stored ROA information within the announcements, storing the origin and valid_length attributes. This is a problem however if there are many ROAs per announcement. Initially this was not an issue, as having multiple ROAs per announcement was redundant, but for more realistic simulations, for the website, etc, this had to be changed. Unfortunately, storing more than one ROA per announcement is not possible, so I've made an RPKI-like structure in the Policy class called roa_checker (as a class attribute) with some helper functions attached such as self.ann_is_valid_by_roa etc, and have removed them from the announcement class. No discernible change in speed as far as I can tell. This also removed a good portion of code around the ROAs in the Scenario class, as well as from the announcement class. The announcement footprint is now smaller as well, and things are closer to how they are in the real world.
  • 10.2.0 Added ability to not plot legend by passing add_legend=False to the GraphFactory
  • 10.1.2 Fixed internal test failure
  • 10.1.1 Fixed bug where simulations weren't tracking properly when running multiple percent adoptions. Also fixed BGPSec -> BGPsec typo (may require running tests with --overwrite in rare cases)
  • 10.1.0 Added the ability to remove lines from graphing and fixed a bug that included the scripts folder upon install
  • 10.0.0
    • For probably everyone this won't result in any backwards compatibility breaking changes, we just changed the ASPAwN policy to be ASRA instead. Considering that both ASPAwN and ASRA are as of yet unpublished, I doubt anyone was using them in the few months prior to this new release. Chances are, none of these changes will affect anyone.
    • Modified ASPAwN to be ASRA instead
    • Improved equality and hashing in the ASGraph, ASGraphInfo, Link, PeerLink, and CustomerProviderLink.
    • Removed link_sets property of as_graph_info and replaced with links
    • Added unlinked_asns to ASGraphInfo so that you could have an ASGraph where some ASNs aren't linked anywhere
    • Made the Scenario class not be an abstract class, but instead return default no announcements
    • Added ROA information to override_announcements when passed into the Scenario
    • Added requires_provider_cones argument to the EngineRunConfig for policies that require the provider cones to be set
    • Set a default argument for the base_dir in the EngineRunner (and because of this changed this to a kwarg and changed the order of args)
    • Refactored EngineRunner, splitting methods into smaller ones and adding provider_cone functionality
  • 9.0.0
    • This is a backwards compatability breaking change.
      • WE WILL CONTINUE TO SUPPORT V8 and it's subsequent releases. If you've already started a paper with v8, it's probably easier to just stick with V8.
      • If you want to upgrade to V9, you're more than welcome to contact me and I can offer considerable help, because there were a lot of backwards compatibility breaking changes in this release (jfuruness@gmail.com)
      • Most of the simulation framework was rewritten, as well as some parts of the simulation engine and system test suite.
    • Unfortunately we discovered a bug in the roa_checker repo that required fixing. Doing so required a total rewrite of that repo and the roa_collector repo, and thus required a total rewrite of everything having to do with the ROA logic within BGPy. (NOTE: V8 does not have this bug, but to avoid the bug you can not use a max length in a ROA greater than a prefix length. You can still work around this though by simply using multiple ROAs for each length you want to cover, which is why staying on V8 is totally fine.
      • If you didn't write your own attacks, or don't modify the ROAs, then this change likely doesn't affect you
      • ROAChecker interface was dramatically changed
      • scenario._get_roa_infos -> scenario._get_roas
      • scenario.roa_infos -> scenario.roas
      • scenario._get_roa_checker modified
      • scenario._get_roa_origin modified
      • scenario._get_roa_valid_length modified
      • ROAInfo removed from simulation_framework.scenarios.roa_info, we now use the ROA from roa_checker
    • Changed conftest.py for easier copy pasting
    • ASGraphAnalyzer class was changed so that _get_most_specific_ann runs now off of an ordered prefix list, which you can pass in the init func. Assuming you didn’t change the private methods this change should be backwards compatible, and now allows users to traceback for any arbitrary prefix
    • Refactored the GraphFactory significantly, added a lot of features here.
      • You can now pass in label, color, marker, and line style info for each label
      • You can now average a line together if it's irrespective of the X axis (for example, ROV does nothing against a superprefix hijack on a non routed prefix, so you could average that line together)
      • It's now possible to add a hardcoded line to your graph. This can be useful if you want to insert results from another paper onto your graphs to compare against
      • Lines in the legend are now ordered based on the mean y value
      • There is a legend hook for easy customizability
      • There is a "strongest attack" parameter that allows you to take the highest of two lines and combine them for the strongest attack between the two
    • Removed DependentSimulation. This was for internal use only, the file noted as such, and was never included in any tutorials or documentation. The purpose was to use the same attacker and victim pairs across all trials, but it was done so in a very janky way. The reason was so that lines that are irrespective of the percent adoption can remain flat, but now we can simply use the GraphFactory functionality to average these lines in a clean manner.
    • Finally, finally added a dang progress bar and removed those annoying print statements. Removed Simulation._print_progress, Modified the _run_chunk, _get_mp_results for this, and added _get_completed_and_tasks, and _update_tqdm_progress for this
    • Total refactor of the MetricTracker class. It was incredibly obtuse, and now has been removed completely in place of GraphDataAggregator. I've received pretty much universal negative feedback around the prior implementation, at the time it was just something we had to add so that we could get this out there. I think this version is much better and way more intuitive.
      • This refactor also includes all classes within the metric_tracker folder, such as MetricKey, Metric, DataKey, etc. Everything is wayyy more modular and intuitive now.
    • It was a required feature for several works for being able to keep attacker victim pairs the same across percent adoptions. This has now been added, but unfortunately this has caused major rewrites of most parts of the Simulator, including the Scenario class, Simulator class, and ScenarioConfig classes. All of the custom scenario classes have also had refactors as well. We additionally now multiprocess only across trials, rather than both across trials and percent adoptions, so that this can occur
      • Removed parse_cpus as an argument to _get_mp_results since it was unused
    • All these changes required updates in pretty much all the utils classes that ran the system test suite, such as the EngineRunner and it's subclasses. These were considerably modified.
      • Almost all of the engine tests configs were modified as well
    • preprocess_anns_funcs was an undocumented feature that never worked properly. This has been entirely removed and all these classes have been moved out into their own attacks.
    • non_default_asn_cls_dict was completely removed. That feature was so messed up. We would try to pass it from scenario to scenario and try to heuristically extract the adopting_asns. Why not instead just pass the adopting_asns? Ridiculous, idk what I was thinking. Now we just pass the adopting ASNs. I also think that method is faster anyways, especially since it no longer uses frozendict, which was at least 2x as slow under pypy
    • The SimulationEngine class was also modified to work with a Scenario class and all the other changes
    • prev_scenario was also used in a lot of places, but this was also a terrible practice. The previous scenario from what? The last trial? The same trial but the last percent adoption? The same trial and percent adoption but the last scenario config? It was totally unclear. 've removed it for the much more clear parameters of attacker_asns, victim_asns, and adopting_asns, which are set in the Simulation class.
    • The deprecated Pathend was removed, please use Path-End now
    • All old policy classes that ended in "Policy" such as ASPAPolicy were removed. These were pointing towards the original policy (ASPA) anyways so no need to keep them, they've been deprecated for a while now.
    • The Announcement class was modified.
      • Previously there was a traceback_end parameter. This has been removed since it is redundant to next_hop_asn. It was listed as deprecated for a while now. This was also moved out of all other parts of BGPy
      • Previously the announcement.copy would also under the hood modify the seed ASN and the traceback_end. This is just bad behavior, a user would not expect a .copy function to be modifying variables unexpectedly. Instead, seed_asn is now set in the copy_and_process functions in BGP, and there's an assert to check that it's been correctly used. Copy function now does as you'd expect - copies the announcement.
    • Arguments to the ASGraph changed as well.
      • There new options include:
        • store_customer_cone_size (stores customer cone size and as rank in the AS object)
        • store_customer_asns (stores all customer ASNs in the AS object)
        • store_provider_cone_size (stores provider cone size in the AS object)
        • store_provider_asns (stores all provider ASNs in the AS object)
      • It's important to note that storing the provider_cone_asns doubles the RAM, and with multiprocessing, you may run out depending on your machine, so plan the number of cores accordingly.
      • Additionally, if you store the customer cone asns, the RAM balloons extremely fast. Plan accordingly.
        • To combat this we now print the expected RAM usage and available RAM, and raise a warning if the two are less than 10% apart
    • I've added an argument to be able to modify the DPI for the diagrams, which can be useful when reusing them for papers. To increase the DPI when running tests just use --dpi=300 or something
      • (NOTE: this will make tests run slower)
      • This is also now a parameter in the Diagram class and in the EngineRunner class and EngineTester class
    • This should be about 10% faster than the previous version
    • BGPSec now adopts from ROV because no one would deploy bgpsec without first ROV
    • Changed all the announcement containers to public variables in the BGP and BGPFull classes. _local_rib -> local_rib, _recv_q -> recv_q. I've kept the old attributes as deprecated properties
    • Changed the default locations of the CAIDACollector to not use tmp which is insecure, and to make them cross platform
    • significant refactoring around linters, especially with ruff
    • Significant refactoring around typing with mypy
    • Added logging (removed all print statements)
    • Added a lot of linters and obsoleted black in exchange for ruff format
    • from bgpy.enums -> from bgpy.shared.enums (although the latter will work for now as this is backwards compatible)
    • New policies:
      • EdgeFilter
      • ROVEdgeFilter
      • EnforceFirstAS
      • ROVEnforceFirstAS
      • BGP-iSec
        • Transitive
        • Transitive + OTC
        • ProviderConeID
        • Transitive + ProviderConeID
        • Transitive + OTC + ProviderConeID
      • ASPAwN
    • Added new hijack classes for
      • ShortestPathPrefixHijack
      • ForgedOriginPrefixHijack
      • FirstASNStrippingHijack
    • Added new attacker classes to work against ASPA in the ShortestPathPrefixASPAAttacker policy
      • This sends forged-origins to customers
    • Significantly extended the Grapher. Tutorial coming soon.
    • Like I said, there were a lot of changes, so many I lost track, if I've missed something notable or you'd like help with anything please just let me know at jfuruness@gmail.com!
  • 8.1.1 pyproject.toml email update in the Authors list. Thanks Joel Braun for his contributions!
  • 8.1.0
    • The ASPA RFC was updated to version 18. Joel Braun, a new BGPy author, has pointed this out and made a great PR for this, thanks :)
      • The next hop check for ASPA now exists in it's own function to make it easily subclassable for IXPs
      • I've confirmed this is functionally equivalent to the prior version, and is just as fast.
    • Discovered a bug in the ROAChecker where the max length for ROAs isn't working properly if it's not set to the same length as the ROA prefix. I've ensured this can't be set for now. You can simply issue multiple ROAs if you need more coverage. This will be permanently fixed in V9, but that won't be released for a while.
  • 8.0.1 Fixed typo that showed attacker as origin instead of blackholes for diagrams when using ROV++, and added internal ROV++V1 test
  • 8.0.0
    • NOTE: This is not a breaking change for most people. The only aspect of this that is not backwards compatible is that we have changed ASPA to by default inherit from ROV, since it pretty much doesn't ever make sense to deploy ASPA without first deploying ROV (making this change is really a bug fix in that sense). For most people, this won't change their results at all, but just in case it does I've bumped this version up. Additionally, the Announcement class now has some new attributes for ROV++, so you'll need to run your tests with --overwrite once
    • ASPA now by default adopts from ROV. This is because in real life it'd be pointless to deploy ASPA without ROV. Updated example configs 23 and 24 for this as well
    • Expanded the tutorial to include descriptions of the graphs: https://github.com/jfuruness/bgpy_pkg/wiki/Graphs-Directory-Structure
    • Previously the graph kwargs were modified internally, potentially causing issues if graphing kwargs were reused multiple times. Now the graph kwargs are deepcopied first and only afterwards modified internally.
    • Added the prefixes from the ROAs to the prefix_subprefix_dict within the Scenario class
    • Added ROV++ V1 LITE, V2 LITE, V2i LITE (note - I haven't gotten around to testing these thoroughly, but other groups needed them ASAP so I've gone ahead and merged these in. I plan on fixing this mid August)
    • Before there was a bug in identifying transit ASes. Transit ASes previously were considered to be only ASes that had more than 1 customer. Now instead it is ASes with at least 1 customer, and at least 2 connections. This is unlikely to have affected anyone's simulations unless you were explicitly using the transit AS group.
  • 7.3.0 Fixed scenario config labelling. Expanded tutorial. See: https://github.com/jfuruness/bgpy_pkg/wiki/ScenarioConfig-Examples-1
  • 7.2.1 Previously the set of adopting ASes would remain consistent across the same trial for each AdoptPolicyCls. This doesn't work when the hardcoded_asn_cls_dict is different, so now when the hardcoded_asn_cls_dict is set, the set of adopting ASes is randomized.
  • 7.2.0 Added DependentSimulation class, useful for very specific types of simulations
  • 7.1.3 internal test fix
  • 7.1.2 internal test fix
  • 7.1.1 Fixed bug where shortest path export all algorithm took Pathend into account but not PathEnd. This was introduced in the previous release and I fixed it within about an hour of that so I doubt this affected anyones simulation results.
  • 7.1.0
    • The author of the path-end paper informed me that Pathend was spelled Path-End. I fixed the name, but changing it in the Pathend policy would have broken tests so now instead Pathend is deprecated and should be replaced with PathEnd.
    • Removed next hop check in Pathend, this was added in error
    • Fixed bug where for the AccidentalRouteLeak, an attacker could receive the announcement to “leak” from their customers who could be the victim. Now victims are not allowed to be customers of the attacker for this scenario.
    • Origin_hijack deprecated for forged_origin_export_all. It appears that the second term is the one actually used in research, rather than origin hijack
    • Added an option for the AttackerBasePolicyCls in the scenario config, that will set the attacker’s base policy to be something unique, so that you can customize attacker behavior
  • 7.0.12 fixed a shortest path export all bug with Pathend where the shortest path for a victim AS that was a stub with no customers and 1 peer was simply (attacker, legitimate origin), rather than the (attacker, peer, legitimate origin ASN)
  • 7.0.11 Minor change to internal tests
  • 7.0.10 Minor change to internal tests
  • 7.0.9 Added two more system tests for ASPA
  • 7.0.8 Fixed some errors with the ASPA implementation for the downstream verification. Unfortunately, this bug likely affected results that used ASPA
  • 7.0.7 Made the error message for not setting the PYTHONHASHSEED slightly more clear
  • 7.0.6 Fixed a slight issue for the AccidentalRouteLeak class. If you leaked from a transit AS (which is not the default, so you would have needed to have been doing this intentionally), then the transit ASes customers would have been counted towards the attackers success. Normally this would make sense, but since we are specifically checking for leakage, and you can't leak to your own customers, this does not make sense, so the leakers customer cone is no longer checked for the metrics
  • 7.0.5 Updated ROA checker in requirements.txt and requirements_dev.txt, which I previously forgot to do
  • 7.0.4 Updated dependencies to get bug fix for roa_checker dependency. It would only have affected cases where multiple ROAs are used for the same prefix origin pair. Hopefully that's a relatively rare case.
  • 7.0.3 Adds an assert to the Scenario class to ensure that the scenario_config's ScenarioCls is the same as the Scenario. Thanks Arvind for this PR!
  • 7.0.2 internal unit test updates
  • 7.0.1
    • Thanks Arvind for this PR!
    • Arvind discovered a bug that affects our BGPy website, but shouldn't (hopefully) affect anyone's simulations
      • This was a bug where the Scenario class would check if the override_attacker_asns was truthy, and if so, it would set the attacker_asns to the override_attacker_asns. However - an empty set is a valid override_attacker_asns value, but this results in a boolean value of False, and therefore wasn't being used. Instead, we should check (as this release does) if the override_attacker_asns is not None.
        • The same behavior was fixed in the override_victim_asns
    • There was also a typo when overriding ROA information
    • contest.py was updated to work with macs
  • 7.0.0
    • This is again not really a backwards compatibility breaking change, but due to the changes in the YAML, users will need to run --overwrite with their tests, so this is technically a major release.
    • The nomenclature of BGPSimplePolicy and BGPPolicy was changed to BGP and BGPFull, respectively. When we initially built BGPy we assumed that BGPPolicy was going to be the default for most simulations, but we now know that this is not the default for any simulations that we are aware of. It makes much more sense to have BGP as the default, and BGPFull as the non default. We have also changed the names of these policies within the classes. We have also dropped the Policy name so that the old "BGPPolicy" does not conflict with the new "BGP". Additionally, the old policy names are all still available from bgpy.simulation_engine, but will be removed from some future release.
    • We have also added ROA functionality in the Scenario class. This is not a backwards compatability breaking change, because this will simply add the ROA information to the announcements as it used to, so if you do not include ROA information, you can still just include it in the default announcements that you are using.
    • Dependencies were also updated as well
    • Updated tutorial and docs
    • Fixed a bug that would cause announcements without a withdraw attribute to return True for withdrawals instead of False
  • 6.0.0
    • The main backwards breaking change for this release was simply moving the propagation rounds from the Simulation class into the ScenarioConfig class. If you are using a Scenario class that requires more than 1 propagation rounds (usually only the AccidentalRouteLeak), you can simply move this attribute into your ScenarioConfig (although I suspect almost all users are not).
    • Moved the propagation rounds from the simulation class to the ScenarioConfig class
      • This is because there are cases where you may want to compare scenario configs that require a different number of propagation rounds
      • Additionally, the EngineRunConfig already pretty much did this
      • On top of that, this will allow us to check if the Scenario is compatible with the number of propagation rounds being used
    • The Scenario now has an abstract property called min_propagation_rounds to define the minimum number of propagation rounds that can be used
    • This has the added benefit of being able to define the number of propagation rounds required per scenario. For example, the AccidentalRouteLeak requires a minimum of 2 propagation rounds, but this was never asserted anywhere before this change
    • This will be really useful for the website we are planning on having as well
    • The AccidentalRouteLeak class also now raises a warning if you use an ASGroup that contains stubs, since stubs can’t route leak
    • Added typing to the _get_announcements function
    • It would appear that the git merge added back the as_graph_infos by accident - this release removes them
    • Also removed the propagation_rounds from the EngineRunConfig (and therefore also it’s subclass, EngineTestConfig) since it only needs to exist within the ScenarioConfig (which defaults to min_propagation_rounds listed within the ScenarioCls)
  • 5.1.1
    • Fixed typing info for AS PATH in the Announcement class (from tuple[int] to tuple[int, ...])
  • 5.1.0
    • Added a hook for _untracked_asns in the scenario class. By default, this is not tracking the attackers and victims. It now does track the hardcoded ASNs, which is a deviation from prior behavior. However, not tracking these was really invalid, so this is somewhat of a bug fix.
  • 5.0.0
    • Unfortunately I implemented the OnlyToCustomers (OTC attribute) incorrectly within the announcement class. It should have been an optional integer, and instead I made it an optional bool. This is a minor change, just fixing the announcement class, as well as fixing the functions within the OnlyToCustomersSimplePolicy, but since the announcement class changed, all the tests are going to need to be overwritten.
    • Additionally, the OnlyToCustomers policies were not implemented properly. They did not catch OTC attributes sent to peers. This has been fixed.
  • 4.1.0
    • Added TRANSIT subgrouping to ASGraph ad to ASGroups enum
  • 4.0.5
    • Added more debug info to withdrawal errors
    • Fixed a bug that caused the non-simple policies to always fail when run on full scale topos
    • Added an assert to check that AdoptASCls and BaseASCls are both either simple or non simple classes
  • 4.0.4
    • Fixed shortest path export all hijack bug (see function notes if interested)
    • Fixed hardcoded metric keys. Now users can pass in their own sets of metric keys to be tracked/graphed.
  • 4.0.3
    • Updated tutorial script's conftest.py
    • Added more debug messages for shortest_path_export_all_hijack
    • Fixed GraphFactoryCls changes that didn't end up making it into the original
    • Added x_limit and y_limit to GraphFactory parameters
  • 4.0.2
    • Added back the Policy changes to make it more resiliant to adding a dunder init to the top level dir, which helps some users
  • 4.0.1
    • Fixed Pathend to inherit from ROV
    • Fixed Pathend to work for any neighbor - not just providers
    • Changed the neighbors and a few other properties in the AS class to functools.cached_properties for speed
    • Fixed the shortest path export all to do an origin hijack for any policy not deploying ASPA or Pathend
    • There's a bug in the shortest path export all attack that consumes a ton of RAM when the entire AS graph is adopting ASPA. For now, we raise an Exception when that occurs rather than let laptops run out of RAM. This hijack can be run with 90% or less adoption for ASPA until we have the time to get a PR for this, but if this is important for your sims just lmk at jfuruness@gmail.com and we can prioritize it
  • 4.0.0
    • Speedups:
      • There was a bug that didn't affect results that slowed down the ASGraphAnalyzer by an order of magnitude. This has been fixed.
      • The GaoRexford functions where not being optimized by PyPy. This has been fixed, and these are now 7x faster
      • peer_asns, customer_asns, provider_asns attributes have been added to the AS class for much faster lookups
    • New features:
      • Added support for:
        • ASPA
        • BGPSec
        • Pathend
        • OnlyToCustomers
      • Added attributes to the Announcement class:
        • BGPSec attributes
        • only_to_customers attributes (RFC 9234)
        • next_hop_asn (taking the place of next_hop)
      • Added several new attacks/scenarios:
        • AccidentalRouteLeak
        • OriginHijack
        • ShortestPathExportAllHijack
      • new hook function within the BGPSimplePolicy class for seed_ann
      • peer_asns, customer_asns, provider_asns attributes have been added to the AS class for much faster lookups
      • Made GraphFactoryCls optional for the run function of the Simulation so that users can easily opt out of writing the graphs
      • Added a weak reference to the as graph as an attribute of the AS class
      • Diagrams now display next_hop_asn under certain attack conditions
      • Changed the metric tracker testing to only overwrite the metrics when they are actually different, reducing the unnecessary git additions
      • Added a heck of a lot of docs
      • Much better typing
    • Breaking changes:
      • Test internals have been removed
        • It was a mistake to allow the as_graph_infos and engine_test_configs to be importable at a package level. These are internal to the BGPy tests, and when the BGPy tests change, these change as well. I've looked far and wide to determine how to deprecate an import statement in Python, but have been unable to figure it out. I have no easy way of making this a backwards compatible change, since I stupidly made the internal test infos importable, so I have to just remove it. Sorry. Simply copy your as_graph_info or engine_test_config into your own repo/fork for your own internal tests.
          • If you need a copy of the as_graph_infos from an old version, here's a link to the previous versions: link
      • The dynamic nature of gao_rexford_funcs was drastically slowing down the simulations (since PyPy can't optimize for this), so this has been changed back to the old way of computing the gao rexford best announcement (with nested if statements)
      • Removed the hash function of the Announcement class. It was hashing off of only three values, which is incorrect
      • ASGraphAnalyzer's class has been modified to use the next_hop_asn for traceback to be more in line with real BGP
      • next_hop_asn was added within BGPSimple's propagation function
    • Other notes:
      • This was a major release, and fairly close to the last one. Sorry about that. We've been trying to juggle getting features out to the people who need them while also maintaining some stability within this repo. I think it will be the common case that for most people, to update to the latest version will require just changing the as_graph_infos within their tests.
      • If you have any trouble at all transititioning your code, please just lmk at jfuruness@gmail.com and I'd be happy to help. If you'd rather not transition to the latest version, you're always welcome to stick with the old version. No bugs have been found that affect simulation results.
  • 3.0.2 Modified the dunder main to avoid SpecialPercentAdoptions.ALL_BUT_ONE due to very high variance
  • 3.0.1
    • Thanks to Joel Braun for pointing out these issues for this release :)
    • Somehow there is an edge case where a policy can be imported twice, even though Python should only ever import things once. This causes an error since the Policy class thinks two different classes have the same name. To correct this fragile behavior, we now use a dictionary to store the AS class names.
    • If a test fails for the first time, the DiagramAggregator will suppress the test failure due to pytest internals. Unfortunately I don't know a good workaround other than to instead suppress the DiagramAggregator error instead. The only issue this could cause is if the tests pass, but the PDF fails to generate, it will be suppressed, but that will be pretty obvious when the PDF is missing, there is an error printed, and additionally if the tests are passing then that's a success. And there's just no other workaround that I'm aware of for this strange pytest behavior
  • 3.0.0
    • This release involved a lot of well deserved updates for BGPy. There are more changes to come, but since a few projects depended on the features in this release, we wanted to get this out now so that we don’t hinder people’s paper deadlines. While the philosophies behind the simulation are still the same, much of the implementation has been modified to be in line with best python practices. I’ve done my best to describe the details here, but it’s definitely possible that I’ve accidentally left some changes out, this was a pretty major rewrite. If you have any trouble at all transitioning your code, please just lmk at jfuruness@gmail.com and I’d be happy to help you transition to the latest version. If you’d rather not transition to the latest version, you’re always welcome to set your version of BGPy to a previous release, a few grad students that are on the cusp of graduation have opted to do this instead of update.
    • The engine test configs and as graph infos within the system test suite have been overhauled so that they all use the same topology, don't include redundant tests, and are much better examples for the website, teaching, the policies themselves, and the attacks
    • Added a new hook function that the policy can override to control seeding
    • Significant documentation updates
      • Significant refactor in almost every class, along with significant changes to folder, file, test, and import structure
    • Added support for python3.12 and fixed deprecation warnings
    • Changed all of the AnnContainers to be inherited from UserDict for a proper implementation
    • Split the AS Class and it's routing policy
      • This was a necessary change to be able to more easily support Rust objects, since we were using the Python class to swap out objects for no good reason
      • Much more modular imo
      • This also required overhauling the eq functionality in a lot of places
    • Different init structure as well to better clarify imports
    • Upgraded all dependencies
    • Updated keywords
    • Updated Gao Rexford funcs to be more like bgpsecsim
      • Before I was having a bunch of nested if statements. MUCH better to just do this in a simple for loop
    • Added parameters for SimulationEngineCls and CaidaCollectorClass to simulation.py
      • This will make it much easier to swap out Rust modules with this
    • Significant refactor around the ASGraphs so that we could have any AS graph implementation. Before the CAIDACollector class was from another repo, when we merged it into BGPy we did not set up the proper abstractions. That's what this refactor is meant to address.
    • Significant refactor around the SimulationEngine, so that it does not inherit from the ASGraph, but rather takes in an ASGraph as a parameter and controls it. This way you can have any type of ASGraph in the SimulationEngine without crazy inheritance.
    • significant changes in the scenario class - moved the seed_announcements and set_as_classes out into the SimulationEngine. After all - scenario class should not need to know the internals of the engine! This should be abstracted away.
    • changed the ASGraph's as_dict to be immutable since other data structures relied on this not changing and there should be no reason to change
    • made customer_cone_size calculations optional in the as graph class since they take ~1.5s each time
    • removed get_real_world_rov_asn_cls_dict. This function is very outdated when it comes to mixed deployment to the point of being wrong. I've also removed this functionality from the CAIDACollector. See github.com/jfuruness/rov_collector for actual mixed deployment information
    • Moved EngineRunConfig and Diagram into the utils folder since these should be decoupled from testing as they are useful for both the tests and the API
    • Fixed circular reference issues around the ASGraph with proxys from weakref to fix memory management issues. Also discovered that just adding customer cone info adds .3gb of RAM to pypy that won't get reclaimed because it doesn't do reference counting (but it will copy this to other processes)
    • Abstracted away the Policy class so that it's separate from BGPSimplePolicy
      • Really we should have checked long ago for minimum working functionality of the policy class in mypy, not the full functionality of BGPSimplePolicy
    • Drastic changes to the way process_incoming_anns works
      • Before, we would take each incoming announcement, and determine if it was better than the announcement within the local RIB, before copying that announcement and processing it (prepending to the AS Path, etc). We figured that this would save on copy and processing time, which was one of the main bottlenecks of the program
      • It turns out that this approach was actually slower than just doing it the simple way (copy announcements and process them first, and afterwards compare).
        • Because of this, process_incoming_anns has been changed to copy/process first, then compare. Additionally, this will greatly simplify the gao_rexford functions
        • I ran this timing test multiple times and every single time it was the same. Copying first led to about a 20% speedup for propagation times. Sam said the result was the same in c++
    • Discovered that IXPs (of len ~15) were being added to the AS graph even though they had no relationships and were being counted as stubs.
      • Moved these into their own ASGroup of IXPS and removed them from all other ASGroups. Changed the ASGroup ASGroup.ALL to ASGroup.ALL_WOUT_IXPS
    • Fixed a typing issue with the metric.py (that also propagated to a few other classes), I was using Any when I should have been using type[Policy]
  • 2.0.0
    • Added IXPs to the BGPDAG class within the CAIDACollector. This is a breaking change because anyone using the system test engine will need to rerun their tests with --overwrite. Now the IXPs are being saved to the yaml, so the yaml for the engine will have changed, and if you don't overwrite, the tests will break.
    • Additionally changed a function called _get_engine in the EngineTester so that the scenario gets passed in the engine class when it get initialized for the tests, which is the way it's meant to be. Unless you've overwritten that function in the engine_tester.py, this change won't affect you.
  • 1.21.0 Changed CSVs to be outcome.name instead of outcome.value
  • 1.20.0
    • output metric_key.name instead of metric.value in the CSV
    • added back SpecialPercentAdoptions. I couldn't reproduce the error, I think it may have just been due to large variability at low numbers of ASes (just 1 AS)
    • Fixed bug in GraphFactory for Any (introduced in 1.19.0) and fixed type in MetricKey (introduced in (1.19.0)
  • 1.19.0
    • Added Any to Metric.py and graph_factory.py to track both non adopting and adopting ASes combined into a single group.
    • Fixed default graph directories to be more modular
    • Set DPI to be 300 since 150 was blurry
    • Changed default number of trials in main.py to 10 instead of 100 for speed
  • 1.18.07 Updated deprecated scenario funcs to remove warnings since it adds 17s per trial in ezbgp project (it's still deprecated though, although the way to get to that func is with the subgraph, and there is a warning in that)
  • 1.18.06 Fix in deprected subgraph simulator for an assert statement involving the labels
  • 1.18.05 Updated PyPi README description
  • 1.18.04 Updated keywords in setup.cfg
  • 1.18.03 Removed very old tests that are no longer supported
  • 1.18.02 Fixed bug where two scenarios running with different versions of mixed deployment would not set adopting ASes properly for the hardcoded_asn_cls_dict
  • 1.18.01 Better error messages for hardcoded_asn_cls_dict being a frozendict
  • 1.18.00 Update to CAIDA collector for more clear error messages
  • 1.17.02 Patch for MetricTracker.__add__ deepcopy slowdowns when running with large trials and cpu cores
  • 1.17.01 Patch for line markers
  • 1.17.00 Added markers and line styles to the graphs
  • 1.16.00 Added optional graphing kwargs for running simulations
  • 1.15.00 Added deprecated subgraph simulation param for scenarios
  • 1.14.01 Upgraded PyYaml to work with redhat
  • 1.14.00 Updated deprecated simulator
  • 1.13.00 Correctly changed the name to bgpy_pkg within setup.cfg
  • 1.12.00 Changed the name to bgpy_pkg. Amazingly, this is not a breaking change, as git will simply reroute you, and this was not published to pypi yet. With this version, we are now live on pypi under bgpy_pkg
  • 1.11.00 Fixed a typo in the previous commit, fixed minor linter errors
  • 1.10.03 Extended the EngineTester class to be more easily extended
  • 1.10.02 Added optional arg to get_real_world_asn_cls_dict for caida_run_kwargs
  • 1.10.01 Added ASGroups to top level import
  • 1.10.00 Fixed bugs in the deprecated simulation_framework aka subgraph_simulation_framework. Added another deprecated function to scenario.py. Added caida_run_kwargs to the simulation to allow the passing in of a specific datetime. Added metadata to deprecated subgraph simulator
  • 1.09.00 Added deprecated simulation framework so that a few PhD students could use it to graduate. Fixed .gitignore, moved the data collection out into it's own function within the Simulation class. Added deprecated function to the scenario class.
  • 1.08.02 Added an optional kwarg to the graph factory class for easy relabelling
  • 1.08.01 When multiple scenarios are being compared with various numbers of attackers, the scenarios with more attackers are now using a superset of attackers from the scenarios with less attackers.
  • 1.08.00 Fixed multi attacker issue where if you ran different levels of attackers on the same graph it would default to the first number of attackers used
  • 1.07.00
    • Fixed mypy issues
    • Fixed black linter issues
    • Added "ALL" subcategory of ASes both to the enums and to the CAIDA collector
  • 1.06.00
    • fixed .gitignore, which was tracking all the guesses for the tests
    • Added system test tutorial, both in code and in docs
    • Added necessary columns to CSVs (required a test overwrite for both bgp and ROV++)
    • Fixed an issue where graphs were no longer being saved in directories and were instead being saved in one giant folder
    • Raised an exception with special percent adoptions bug
    • Added links to the paper in the docs and finalized the docs, also adding ROV++ as a reference
  • 1.05.00 Fixed a typo on get_real_world_rov_asn_cls_dict that resulted in an error
  • 1.04.00 Remove self parameter from get_real_world_rov_asn_cls_dict
  • 1.04.00 Remove self parameter from get_real_world_rov_asn_cls_dict
  • 1.03.01 Moved get_real_world_rov_asn_cls_dict to a top level import
  • 1.03.00 Removed __init_subclass__ from Announcement class since Announcement was changed to a dataclass, which screwed up subclassing
  • 1.02.00 Fixed a bug that resulted in tox failing when run with python3.10. Pytest did not fail, and tox with pypy did not fail, but sometimes the test would fail when run with tox and python3.10. Just had to change a list comparison to a set comparison in the tests, it didn't affect the results.
  • 1.01.00 Fixed a bug resulting in incorrectly graphed data
  • 1.0.03 Documentation updates and code examples
  • 1.0.02 Updates to PDF aggregation. Mypy fixes. Added conference examples to test suite. Fixed bug when using SpecialPercentAdoption
  • 1.0.0 First Major Release. Many changes for the conference version. Since prior to this point all changes were internal, won't list them all here, but will keep better records from now on.
  • 0.2.1 Various bug fixes. PRs from Cameron (Thank you!). input clique rounding up now. Victims/attackers no longer being counted. No more windows support.
  • 0.2.0 Fixed subgraph issues. Changed the -1 and 101% cases to be SpecialPercentAdoptions
  • 0.1.03 Fixed subgraph bug that resulted in incorrect graphs
  • 0.1.02 Removed slots from ASes since it does not increase speed, and now ASes with different slots can be interchanged
  • 0.1.01 Added optional gao rexford kwargs to allow easier subclassing (I undid this)
  • 0.1.0 Major refactor and name change. I believe this version will be stable. Deps saved.
  • 0.0.4 Major refactor
  • 0.0.2 Fixed dependencies so that they weren't relying off ssh, since github doesn't support pip installs with ssh and github actions failed
  • 0.0.1 Refactored package. Semi working version

In Development (DO NOT USE)

NOTE: these are NOT stable branches, most of the time they won't run at all. Do NOT use them please :)

Clone this wiki locally