All Classes and Interfaces

Class
Description
An abstract implementation of DependencyDescription taking care of the probabilities and alternative probabilities.
Accumulates numeric data points.
An intermediate DependencyDescription that picks one child dependency based on a probability for execution.
Class that contains the architectural information provided by the architecture file.
Adapter for parsing the architecture model from json into an object.
Represents an iterable arrival rate model that provides.
A AsyncReportWriter that writes a list of values to a single column.
Writes a list of values to multiple columns, seperated by MiSimReporters.csvSeperator.
A base class that provides functionalities to asynchronously write data to a file.
MultiDataPointReporter that averages all entries for a TimeInstance over a given time bucket.
An examplary implementation of a StrategicPeriodicServiceOwnedPattern with a potentially varying IAutoscalingPolicy.
Represents a CPU utilization tracker that periodically reports the CPU utilization in the recent time based on a bin size.
A datapoint reporter that can map collected data points into time buckets based on a BucketMultiDataPointReporter.bucketingFunction.
A ChaosMonkeyEvent is an ExternalEvent that gets scheduled at the beginning of the experiment.
Manager class of all CircuitBreakers of one Microservice Instance.
Contains the three possible states of a CircuitBreaker.
Static class that holds the command line options of the simulator and is able to parse these into a CommandLine object for retrieval.
Annotation to mark and configure a CLI option.
This is a copy of the non-public utility class java.util.stream.Collector.CollectorImpl.
Event that represents the completion of a process burst for a specific CPUProcess.
Marks the end of the last computation burst of a thread.
This is an Adapter for a configurable and named type.
This class represents an actual CircuitBreaker with the behavior defined by Hystrix.
Represents a CPU resource.
Data-class that contains information about a currently running (or potentially finished) process.
Superclass that provides the interface for all CPU scheduling strategies.
Provides methods for direct conversion to the csv format.
Event that triggers a latency injection.
Represents a dependency of an Operation to other Operations.
Adapter for parsing DependencyDescriptions from JSON.
The DependencyGraph class is used in order to create the graph that displays the dependencies between the systems' microservice instances.
TODO:!!!!!! Adapter for parsing distributions from JSON into a DiscreteDist.
TypeAdapter to write/read doubles in json.
Extention of Gsons' InstanceCreator to create Entity instances of Desmo-J objects.
Strategy that balances the amount of requests evenly between instances.
Static class that takes care of enabling subscribing and publishing events.
Subscribes to specific events on the event bus.
Represents an action during an experiment e.g.
Adapter so Gson can parse experiment action descriptions from json into object instances.
Class that contains code for creating a new Experiment based on a ExperimentStartupConfig.
Class that contains the architectural information provided by the architecture file.
Adapter for parsing the metadata within an experiment description into a ExperimentMetaData object.
Represents the experiment model.
Adapter for parsing a json input into the experiment model.
Configuration that controls how an experiment is started.
Represents an exponential retry backoff strategy.
Utility functions for creating the experiment report.
First in first out scheduler.
Gson TypeAdapter for the File type.
Utility class for checking file existence.
Utility class to create a Gson with a default set of TypeAdapters.
Event that represents the half-closing of a circuit breaker.
An event without any direct effect on the simulation.
Interface for auto scaling policies.
Interface for classes that represent the State of a Circuit Breaker.
Interface for a load balancing strategy.
For now this is an unused event that represents the killing of an instance.
Represents a resilience pattern that is owned by a MicroserviceInstance.
Adapter for parsing pattern configurations written in json into InstanceOwnedPatternConfigurations.
Can store the configuration of an InstanceOwnedPattern.
Represents the end of the shutdown process of an instance.
Triggers the instance to stats its shutdown process.
Triggers the startup procedure for a MicroserviceInstance.
Represents the possible states of a MicroserviceInstance.
These dependencies act (only) as intermediate dependencies inside a hierarchy of DependencyDescription.
Represents a Request between two MicroserviceInstances.
Adds properties to a LoadGeneratorDescription for describing an interval-based load generator.
Represents all pattern lifecycle hooks.
Marks a periodically appearing service owned pattern.
Interface for listening for request updates.
Interface that represnts a strategy of a Retry.
Events of an experiment that extend this interface are asked to self schedule on the start of the simulation.
Non-Functional interface to mark classes as Strategies for parsing.
Interface to mark classes as acceptors of an IStrategy.
Represents a jittering exponential retry backoff strategy.
Represents a jittering linear retry backoff strategy.
Annotation to give a type name to class that represents it in a MiSim architecture or experiment description.
Utility class for resloving JsonTypeNames into actual types using Reflection.
Last in first out scheduler.
Adds properties to a LoadGeneratorDescription for describing a limbo load model-based load generator.
Represents a linear retry backoff strategy.
A MiSimReporter that collects uses an AsyncListReportWriter to collect data points.
Wrapper Class for ILoadBalancingStrategy to encapsulate common behavior around it.
Wrapper class around a StrategyWrapperTypeAdapter for creating new LoadBalancer objects.
This class represents the description of a load generator.
Class that can execute a LoadGeneratorDescription.
Adapter for creating LoadGeneratorDescriptionExecutors from JSON.
RuntimeException that represents the stopping of a generator.
Allows LocalDateTimes to be parsed to and from JSON.
An intermediate DependencyDescription that repeats the execution of its child dependencies based on a number.
Main class of the simulator.
A Microservice is one of the core Entities of the simulation.
Adapter for parsing JSON-data into Microservice object.
A MicroserviceInstance (in the following just called instance) represents an actual, running instance of a Microservice.
For now this is an unused event to represent the scaling of a microservice.
Main model that contains architectural and experiment descriptions/data.
Collection class to mark Adapters that need a MiSimModel for parsing.
Base class for all MiSimReporters.
Class that manges all MiSimReporters.
Utility class for loading the MiSim architecture and experiment descriptions from JSON-files.
Listener that takes care of handling the activation of MTL events.
Dynamically-typed data point collector.
Implements a Multi-Level Feedback Queue scheduler.
Class that adds further options for the retrieving of names of Entitys.
Class that adds further options for the retrieving of names of ExternalEvents.
Class that adds further options for the retrieving of names of SimProcess's.
Factory for Adapters that turn JSON-strings into Microservice and Operation objects using the NameResolver.
Utility class to help resolve names into Operation and Microservice object.
Event that should be scheduled when a request gets canceled.
Superclass for network events that take care of exactly one traveling Request.
Event that represents the successful arrival of a request at its target instance.
Event that represents the sending of a request.
Event that represents the timeout of a Request.
RuntimeException that is thrown if there are currently no requests service instances available.
Adapter for parsing normal distributions from JSON into a ContDistNormal.
An Operation represents an endpoint of a service.
Adapter for parsing Operations from JSON.
Exception thrown when the parsers encounter a problem.
Adapter factory to react to different Path classes such as sun.nio.fs.WindowsPath.
Utility class for parsing TypeNameAssociatedConfigurationData into a pattern.
Class that takes care of periodically triggering IPeriodicPattern objects.
A service owned pattern that is automatically triggered periodically.
Contains Constants to make prioritized scheduling easier to read.
Implements a simple round-robin load balancing strategy.
A randomized load balancing strategy.
Represents a Request that can travel between two MicroserviceInstances.
Wrapper class to ease responding to Requests.
Contains a collection of reasons, why a request can fail.
Class that provides the ability to send requests and register listeners to this requests.
TODO: integration of this state definitions.
Retry implementation that employs a full jitter based exponential backoff.
This class should be used to keep track of all static Random Number Generators (RNG).
Implements a simple round-robin load balancing strategy.
Self adjusting Round-Robin (SARR) scheduler with dynamic median-based quantum calculation.
Describes time-dependent scaling of load.
A function that defines the shape of the time-dependent ScaleFactor.
Event that handles scaling of load.
Represents a scenario description input.
Apdater for parsing ATAM-Scenario descriptions.
Represents an event that can do an initial self schedule if asked to.
This is an instance of a SimpleDependencyDescription.
Resilience Pattern that is owned by a Microservice.
Adapter for parsing patterns owned by Microservices.
Scheduler, that schedules all entered processes by their left over work unit demand.
Represents the leaf dependencies in a hierarchy of DependencyDescriptions.
A SimulationEndEvent is an ExternalEvent that is called upon the end of the simulation.
Reports last value for the given time bucket.
Represents a ServiceOwnedPattern that wants to be injected with an IStrategy object.
Represents a pattern owned by a Microservice that employs a IStrategy.
Represents a pattern owned by a Microservice that employs a IStrategy.
Exception class to symbolize the absence of an IStrategy class.
Adapter that allows for custom initialization of entities using a function callback.
A SummonerMonkeyEvent is an ExternalEvent that gets scheduled at the begin of the experiment.
Gson TypeAdapter for TimeInstant objects.
Gson TypeAdapter for TimeSpan objects.
Provides useful (transformation) operations regarding time instants and spans.
This class represents an actual CircuitBreaker with the behavior defined by Hystrix.
Represents the configuration data that relates to a specific type.
A Request that represents a request that is created by a user from outside the simulated system.
Class that holds static utility methods.
Strategy that chooses the least utilized Microservice Instance by current relative Queue demand.