标签: fault-tolerance

据我所知,当我反序列化缺少这个新成员的我的类的旧版本时,我必须使用[OptionalField]属性在我的类的较新版本中装饰一个新成员.

但是,在序列化类之后添加InnerTranslator属性时,下面的代码不会抛出任何异常.我在onDeserialization方法中检查属性是否为null(它确认它没有被序列化),但我希望代码因此而抛出异常.[OptionalField]属性本身是可选的吗？

class Program
{
    static void Main(string[] args)
    {
        var listcol = new SortedList<string,string>
        {
            {"Estados Unidos", "United States"},
            {"Canadá", "Canada"},
            {"España", "Spain"}
        };
        var translator = new CountryTranslator(listcol);
        using (var file_stream=new FileStream("translator.bin",FileMode.Open))
        {
            var formatter = new BinaryFormatter();
            translator = formatter.Deserialize(file_stream) as CountryTranslator;
            file_stream.Close();
        }
        Console.ReadLine();
    }
}

[Serializable]
internal class CountryTranslator:IDeserializationCallback
{
    public int Count { get; set; }

    public CountryTranslator(SortedList<string,string> sorted_list)
    {
        this.country_list = sorted_list;
        inner_translator = new List<string> {"one", "two"};
    }
    //[OptionalField]
    private List<string> inner_translator; …

Erlang容错(据我所知)包括使用管理程序进程来监视工作进程,因此如果工作者死亡,主管可以启动一个新的.

Erlang如何进行此监控,尤其是在分布式方案中？怎么能确定这个过程真的死了？它会做心跳吗？内置于运行时环境中的是什么？如果拔下网络电缆怎么办？如果无法与其通信,是否会假设其他进程已经死亡？等等

我在考虑如何在JVM(例如Java或Scala)中实现Erlang声称的相同容错等.但我不确定是否需要内置于JVM中的支持以及Erlang.虽然作为一个比较点,我还没有看到Erlang如何做到的定义.

JobDetail.requestsRecovery属性文档说明如下

如果遇到"恢复"或"故障转移"情况,则指示调度程序是否应重新执行作业.

现在,什么是"复苏"情况或"故障转移"情况？

他们有什么不同？

仅当JVM在作业执行期间崩溃时才会发生恢复,或者如果由于异常而导致作业执行失败,是否会发生恢复？

我试图找出Hystrix如何请求缓存工作,但我没有关注他们在他们的文档中提供的wiki或端到端示例.

基本上我有以下HystrixCommand子类:

public class GetFizzCommand extends HystrixCommand<Fizz> {
    private Long id;
    private Map<Long,Fizz> fizzCache = new HashMap<Long,Fizz>();

    void doExecute(Long id) {
        this.id = id;
        execute();
    }

    @Override
    public Fizz run() {
        return getFizzSomehow();
    }

    @Override
    public Fizz getFallback() {
        // Consult a cache somehow.
        // Perhaps something like a Map<Long,Fizz> where the 'id' is the key (?)
        // If the 'id' exists in the cache, return it. Otherwise, give up and return
        // NULL. …

我想为比萨饼送货店建立一个容错的软实时网络应用程序.它应该有助于披萨店接受来自客户的电话,将它们作为订单放入系统(通过CRM网络客户端),并帮助调度员将订单分配给送货司机.

这些目标并不罕见,但我希望每周7天每天24小时提供服务,即使其具有容错能力.此外,我希望它能够非常快速地工作并且非常敏感.

下面是这种应用程序的一个非常简单的架构视图.

问题是我不知道如何使用所有Erlang/OTP优点来使应用程序具有响应性和容错性.

这是我的问题:

1. 应该复制哪些系统元素以提供容错,我应该如何做？我知道我可以在复制的Mnesia数据库中存储每辆车的状态(坐标,分配的订单等).这是一个正确的方法吗？
2. 哪些数据存储服务应该是传统的基于SQL的(例如基于boss_db),哪些应该在Mnesia上完成以提供非常快速的响应？是否可以使用传统的SQL数据库将客户记录和历史记录存储在这样的容错和响应速度快的应用程序中？
3. 我是否应该尝试将所有服务(客户,车辆状态等)的所有数据存储在RAM中,以使应用程序具有高响应性？
4. 我应该将持久性车辆数据(id,容量等)存储在传统的SQL数据库中,并将实时数据(坐标,分配的订单,主干中的订单等)存储在Mnesia数据库中,以使应用程序更多实时响应？

Backgound:

在第3节,名为实施状态机,Lamport的论文Paxos Made Simple,Multi-Paxos被描述.Multi Paxos用于Google Paxos Made Live.(Multi-Paxos用于Apache ZooKeeper).在Multi-Paxos中,可能会出现差距:

通常,假设领导者可以?提前获得命令 - 也就是说,它可以在选择命令1到之后i + 1通过i + ?命令提出命令i.? - 1然后可能出现高达命令的差距.

现在考虑以下场景:

整个系统使用主从架构.只有主服务器提供客户端命令.Master和Slaves通过Multi-Paxos就命令序列达成共识.Master是Multi-Paxos实例的领导者.现在假设主服务器及其两个从服务器具有下图所示的状态(已选择命令):

.

请注意,主状态中存在多个间隙.由于不同步,这两个奴隶落后了.这时,主人失败了.

问题:

1. 在检测到主设备故障后,从设备应该做什么(例如,通过心跳机制)？

2. 特别是,如何处理与旧主人的差距和缺失的命令？

关于Zab的更新:

正如@sbridges指出的那样,ZooKeeper使用Zab而不是Paxos.报价,

Zab主要用于主备份(即主从)系统,如ZooKeeper,而不是用于状态机复制.

似乎Zab与我上面列出的问题密切相关.根据Zab的简短概述文件,Zab协议包括两种模式:恢复和广播.在恢复模式下,会做出两个特定的保证:永远不会忘记已提交的消息并放弃跳过的消息.我对Zab的困惑是:

3. 在恢复模式下Zab是否也存在缺口问题？如果是这样,扎布做什么？

我想要一种在整个Storm拓扑中唯一标识元组的方法，以便可以将每个元组从Spout跟踪到最终的Bolt。

我的理解方式是，例如，传递带有喷口发出的唯一消息ID时：

String msgID = UUID.randomUUID();
// emits a line from user tasks with msg id
outputCollector.emit(new Values(task), msgID);

确认到喷口后，此ID会以某种方式返回（可以在任何时候更早模拟出来以获取通过的ID吗？）。但是，例如在元组上使用get message id：

inputTuple.getMessageId()

这将返回一个新的messageId，而不是元组在Spout处传入的那个。参考https://groups.google.com/forum/#!topic/storm-user/xBEqMDa-RZs

问题

1）有一种方法可以在收集器发出Tuple时获取tuple.getMessageId（）。

2）或者可以从拓扑中的任何喷嘴或螺栓的元组中以某种方式获得在喷嘴处传递的messageId吗？

最终解决方案 我希望能够在发出元组时在其上设置ID，然后能够在Storm拓扑中的任何时候再次标识该元组。

还是将必须将我的系统跟踪的唯一messageId作为字段/值传递到每个喷嘴和螺栓的每个输出上。

谢谢

所以,这就是事情.我非常喜欢微服务的想法,并且想要在决定是否要在生产中使用它之前进行设置和测试.然后,如果我想要使用它,我想慢慢地将我的旧rails应用程序的碎片切掉并将逻辑移动到微服务.我想我可以使用HAProxy并根据URL设置不同的路由.所以应该涵盖这一点.

然后我的下一个最大的担忧是我不需要太多的开销来确保一切都在基础设施方面顺利运行.我希望低配置,易于开发,测试和部署.

现在,我想知道每种款式的优点和缺点.Akka(集群)与Kubernetes之类的东西(甚至可能是它上面的fabric8).

我还担心的是容错.我不知道你是如何与Kubernetes一起做的.那么您是否必须包含一些消息队列以确保您的消息不会丢失？如果其中一个队列出现故障,那么还有多个队列？或者只是重试直到队列再次出现？阿卡演员已经有了这个权利吗？重试和邮箱？微服务的容错策略是什么？每种方法都有所不同吗？

有人请赐教!;)

我最近读了很多关于拜占庭容错的论文。有一个常见的证明，需要 3m+1 台计算机来处理 m 个拜占庭故障。一般证明是这样的：

存在三个“将军”：A、B、C。假设将军们是这样沟通的，其中C是“叛徒”：

A --> B "Attack", A --> C "Attack"
B --> A "Attack", B --> C "Attack"
C --> A "Attack", C --> B "Retreat"

A receives "Attack" from both sources, and will attack.
B receives "Attack" from A but "Retreat" from C and doesn't know what to do.
C is a traitor, so his action could be anything.

因此，我们不能保证大多数参与者会达成共识。

我有点理解这个证明，但似乎忽略了一个要点。A、B、C不也各自内部计算着要做什么吗？由于A和B是这里的“忠诚”将军，因此似乎“正确”的行动是进攻。难道B在决定做什么时不允许考虑他自己的计算吗？在这种情况下，他可以轻松打破相互冲突的 A&C 输入之间的联系并决定进攻。然后，A和B都进攻，问题就解决了。这是一个与经典的拜占庭将军问题不同的问题吗？

我有以下步骤：

    return stepBuilderFactory.get("billStep")
            .allowStartIfComplete(true)
            .chunk(20000)
            .reader(billReader)
            .processor(billProcessor)
            .faultTolerant()
            .skipLimit(Integer.MAX_VALUE)
            .skip(BillSkipException.class)
            .listener(billReaderListener)
            .listener(billSkipListener)
            .writer(billRepoItemWriter)
            .build();

我的理解是否正确，容错意味着当在 billProcessor 中引发异常时，它将在跳过侦听器中进行处理，然后下一行/项目将在 billProcessor 中进行处理？

我注意到在添加调试日志时 - 当处理器中抛出异常时，项目/行被“重新处理”。（可能是因为容错配置。但是，如果我正在处理 200 万条记录，其中 300,000 条记录被跳过 - 或者引发跳过异常 - 如果其中一些记录被“重新处理”，这不是性能问题吗）

最大的问题是 -下一行/项目被跳过。它们根本没有在处理器中进行处理。

如果我删除了faultTolerant和SkipListener - 并直接将跳过的记录保存在数据库中（skiplistener正在做什么） - 它正在工作，但是这个解决方案是否正确？