Пример #1
0
    def __init__(self, **kwargs):
        super(ConsistencySimulation, self).__init__(**kwargs)

        # Primary simulation variables.
        self.users = kwargs.get('users', settings.simulation.users)
        self.trace = kwargs.get('trace', None)
        self.outages = kwargs.get('outages', None)
        self.n_objects = kwargs.get('objects',
                                    settings.simulation.max_objects_accessed)
        self.replicas = []
        self.network = Network()
Пример #2
0
    def __init__(self, **kwargs):
        super(ConsistencySimulation, self).__init__(**kwargs)

        # Primary simulation variables.
        self.users = kwargs.get("users", settings.simulation.users)
        self.trace = kwargs.get("trace", None)
        self.outages = kwargs.get("outages", None)
        self.n_objects = kwargs.get("objects", settings.simulation.max_objects_accessed)
        self.replicas = []
        self.network = Network()
Пример #3
0
class ConsistencySimulation(Simulation):
    @classmethod
    def load(klass, fobj, **kwargs):
        """
        Loads the simulation network from a JSON file containing the
        simulation description and network graph.
        """
        csim = klass(**kwargs)

        if fobj is not None:
            data = json.load(fobj)

            # Add simulation meta information
            csim.name = data['meta']['title']
            csim.description = data['meta']['description']
            csim.users = data['meta'].get('users', csim.users)
            csim.results.settings.update(data['meta'])

            # If the trace exists in the simulation meta, use it.
            # Do not use the trace if it has been specified in the kwargs.
            if csim.trace is None and 'trace' in data['meta']:
                csim.trace = data['meta']['trace']

            # If the outages exists in the simulation meta, use it.
            # Do not use the outages if it has been specified in the kwargs.
            if csim.outages is None and 'outages' in data['meta']:
                csim.outages = data['meta']['outages']

            # Add replicas to the simulation
            for node in data['nodes']:
                csim.replicas.append(replica_factory(csim, **node))

            # Add edges to the network graph
            for link in data['links']:
                source = csim.replicas[link.pop('source')]
                target = csim.replicas[link.pop('target')]
                csim.network.add_connection(source, target, True, **link)

        return csim

    def __init__(self, **kwargs):
        super(ConsistencySimulation, self).__init__(**kwargs)

        # Primary simulation variables.
        self.users = kwargs.get('users', settings.simulation.users)
        self.trace = kwargs.get('trace', None)
        self.outages = kwargs.get('outages', None)
        self.n_objects = kwargs.get('objects',
                                    settings.simulation.max_objects_accessed)
        self.replicas = []
        self.network = Network()

    def complete(self):
        """
        Ensure the topology is part of the results, as well as any configured
        variables on that don't match the settings.
        """
        # Log that the trace read is complete
        if self.trace:
            self.logger.info(
                "access trace complete for {} accesses on {} objects".format(
                    self.workload.count,
                    len(self.workload.objects),
                ))

        # Update the results with runtime settings and serialize the topo.
        self.results.settings['users'] = self.users
        self.results.topology = self.serialize()

        # Compute Anti-Entropy
        aedelays = map(float, [
            node.ae_delay for node in filter(
                lambda n: n.consistency == Consistency.EVENTUAL, self.replicas)
        ])

        if aedelays:
            self.results.settings['anti_entropy_delay'] = int(
                sum(aedelays) / len(aedelays))

        # Call consistency checker on all the replica logs
        if settings.simulation.validate_consistency:
            self.results.consistency.validate(self)

        # Finialize logging and wrap up the simulation
        super(ConsistencySimulation, self).complete()

    def script(self):
        # Create the workload that generates accesses as though they are users.
        self.workload = create_workload(self,
                                        trace=self.trace,
                                        n_objects=self.n_objects,
                                        users=self.users)

        # Create the outages that generate partitions for realistic networks.
        self.partitions = create_outages(self, outages=self.outages)

    def dump(self, fobj, **kwargs):
        """
        Write the simulation to disk as a D3 JSON Graph
        """
        return json.dump(self, fobj, cls=JSONEncoder, **kwargs)

    def serialize(self):
        latency = self.network.get_latency_ranges()
        network = self.network.serialize()

        return {
            'nodes': network['nodes'],
            'links': network['links'],
            'meta': {
                'seed':
                self.random_seed,
                'title':
                self.name,
                'description':
                getattr(self, 'description', None),

                # Latency Labels
                'constant':
                '{}ms'.format(latency.get('constant', ('N/A ', None))[0]),
                'variable':
                '{}-{}ms'.format(*latency.get('variable', ('N/A', 'N/A'))),
            },
        }
Пример #4
0
class ConsistencySimulation(Simulation):
    @classmethod
    def load(klass, fobj, **kwargs):
        """
        Loads the simulation network from a JSON file containing the
        simulation description and network graph.
        """
        csim = klass(**kwargs)

        if fobj is not None:
            data = json.load(fobj)

            # Add simulation meta information
            csim.name = data["meta"]["title"]
            csim.description = data["meta"]["description"]
            csim.users = data["meta"].get("users", csim.users)
            csim.results.settings.update(data["meta"])

            # If the trace exists in the simulation meta, use it.
            # Do not use the trace if it has been specified in the kwargs.
            if csim.trace is None and "trace" in data["meta"]:
                csim.trace = data["meta"]["trace"]

            # If the outages exists in the simulation meta, use it.
            # Do not use the outages if it has been specified in the kwargs.
            if csim.outages is None and "outages" in data["meta"]:
                csim.outages = data["meta"]["outages"]

            # Add replicas to the simulation
            for node in data["nodes"]:
                csim.replicas.append(replica_factory(csim, **node))

            # Add edges to the network graph
            for link in data["links"]:
                source = csim.replicas[link.pop("source")]
                target = csim.replicas[link.pop("target")]
                csim.network.add_connection(source, target, True, **link)

        return csim

    def __init__(self, **kwargs):
        super(ConsistencySimulation, self).__init__(**kwargs)

        # Primary simulation variables.
        self.users = kwargs.get("users", settings.simulation.users)
        self.trace = kwargs.get("trace", None)
        self.outages = kwargs.get("outages", None)
        self.n_objects = kwargs.get("objects", settings.simulation.max_objects_accessed)
        self.replicas = []
        self.network = Network()

    def complete(self):
        """
        Ensure the topology is part of the results, as well as any configured
        variables on that don't match the settings.
        """
        # Log that the trace read is complete
        if self.trace:
            self.logger.info(
                "access trace complete for {} accesses on {} objects".format(
                    self.workload.count, len(self.workload.objects)
                )
            )

        # Update the results with runtime settings and serialize the topo.
        self.results.settings["users"] = self.users
        self.results.topology = self.serialize()

        # Compute Anti-Entropy
        aedelays = map(
            float, [node.ae_delay for node in filter(lambda n: n.consistency == Consistency.EVENTUAL, self.replicas)]
        )

        if aedelays:
            self.results.settings["anti_entropy_delay"] = int(sum(aedelays) / len(aedelays))

        # Call consistency checker on all the replica logs
        if settings.simulation.validate_consistency:
            self.results.consistency.validate(self)

        # Finialize logging and wrap up the simulation
        super(ConsistencySimulation, self).complete()

    def script(self):
        # Create the workload that generates accesses as though they are users.
        self.workload = create_workload(self, trace=self.trace, n_objects=self.n_objects, users=self.users)

        # Create the outages that generate partitions for realistic networks.
        self.partitions = create_outages(self, outages=self.outages)

    def dump(self, fobj, **kwargs):
        """
        Write the simulation to disk as a D3 JSON Graph
        """
        return json.dump(self, fobj, cls=JSONEncoder, **kwargs)

    def serialize(self):
        latency = self.network.get_latency_ranges()
        network = self.network.serialize()

        return {
            "nodes": network["nodes"],
            "links": network["links"],
            "meta": {
                "seed": self.random_seed,
                "title": self.name,
                "description": getattr(self, "description", None),
                # Latency Labels
                "constant": "{}ms".format(latency.get("constant", ("N/A ", None))[0]),
                "variable": "{}-{}ms".format(*latency.get("variable", ("N/A", "N/A"))),
            },
        }