O recurso está a ser carregado... Carregamento...
  1. Digestão
  2. Discussões
  3. Exploração da recepção de sinais externos da plataforma FMZ: API de extensão vs estratégia de serviços HTTP embutidos

Exploração da recepção de sinais externos da plataforma FMZ: API de extensão vs estratégia de serviços HTTP embutidos

Autora:Inventor quantificado - sonho pequeno, Criado: 2024-12-12 18:33:26, Atualizado: 2024-12-16 09:15:23

img

Prefácio

Há vários artigos na biblioteca da plataforma sobre o linking do Trading View webhook, que permite que o sistema fora da estratégia faça transações impulsionadas por sinais, quando a plataforma ainda não suportava a funcionalidade de serviço HTTP embutida na linguagem JavaScript.CommandRobotO FMZ é uma plataforma de comunicação de mídia que transmite sinais de comunicação de mídia para os programas de comunicação de mídia.

Com o desenvolvimento da plataforma, a atualização e a atualização de muitas novas funcionalidades. Também há novos métodos para receber sinais externos. Todos os métodos têm suas próprias vantagens.

Interface de API expandida com a plataforma FMZ

A utilização desta forma de ligação de sistemas externos é mais simples, mais segura e mais estável do que a interface API de extensão dependente da plataforma.

O processo de recepção de sinais externos:

Sistema externo (Trading View webhook) Fone> FMZ Extended API Service Fone> Disco real de estratégia

Sistemas externos (Trading View webhook): por exemplo, um script PINE executado no Trading View pode definir um alarme que, quando desencadeado, envia um pedido http para o URL do webhook definido, como um sinal. 2, FMZ Extended API Service: Após o sucesso do acesso à interface, a plataforma transmite informações, que são enviadas como mensagens interativas para o disco rígido da política. Disco real de políticas: no disco real de políticas, pode ser projetado o função GetCommand para ouvir mensagens de interação e executar ações estabelecidas após a detecção da mensagem.

O serviço de recepção de sinais é um passo mais no meio do que usar o serviço de recepção de sinais de serviços criados diretamente usando o serviço de HTTP embutido.

Política de serviços HTTP embutidos

Após o suporte da plataforma ao recurso de serviço HTTP embutido na linguagem JavaScript, é possível criar diretamente um serviço paralelo de escuta de sinais externos. As vantagens são: o serviço HTTP criado é um fio separado e não afeta a lógica da função principal, pode escutar mensagens semelhantes à função GetCommand, escutando diretamente os sinais externos, em comparação com o uso de programas de API de extensão, eliminando o anel de desvio intermediário.

O processo de recepção de sinais externos:

Sistema externo (Trading View webhook)

Sistemas externos (Trading View webhook): por exemplo, o script PINE executado no Trading View pode definir um alarme que, quando desencadeado, envia um pedido http para o URL do webhook definido, como um sinal. 2, Disco real de políticas: políticas paralelas para executar um serviço HTTP, recebendo sinais externos diretamente.

Este programa poupa um passo, mas para aumentar a segurança, é melhor configurar o serviço https, que precisa ser dobrado; em comparação com o problema do programa de usar uma API de extensão.

Testes de código

Em um teste de dois programas, a seguinte política irá circular e enviar 10 solicitações HTTP/Https por rodada, para simular sinais externos. A política vai ouvir as "mensagens de interação" e "mensagens enviadas pelo fio do serviço HTTP". A política irá então combinar mensagens de sinais externos e sinais recebidos, detectando se há perda de sinal, e calcular o tempo de execução.

var httpUrl = "http://123.123.123.123:8088/CommandRobot"
var accessKey = ""
var secretKey = ""

function serverFunc(ctx) {
    var path = ctx.path()
    if (path == "/CommandRobot") {
        var body = ctx.body()
        threading.mainThread().postMessage(body)
        ctx.write("OK")
        // 200
    } else {
        ctx.setStatus(404)
    }
}

function createMsgTester(accessKey, secretKey, httpUrl) {
    var tester = {}
    
    tester.currentRobotId = _G()
    tester.arrSendMsgByAPI = []
    tester.arrSendMsgByHttp = []
    tester.arrEchoMsgByAPI = []
    tester.arrEchoMsgByHttp = []
    tester.idByAPI = 0
    tester.idByHttp = 0

    var sendMsgByAPI = function(msgByAPI, robotId, accessKey, secretKey) {
        var headers = {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36",
            "Content-Type": "application/json"
        }
        HttpQuery(`https://www.fmz.com/api/v1?access_key=${accessKey}&secret_key=${secretKey}&method=CommandRobot&args=[${robotId},+""]`, {"method": "POST", "body": JSON.stringify(msgByAPI), "headers": headers})
    }

    var sendMsgByHttp = function(msgByHttp, httpUrl) {
        HttpQuery(httpUrl, {"method": "POST", "body": JSON.stringify(msgByHttp)})
    }

    tester.run = function() {
        var robotId = tester.currentRobotId

        for (var i = 0; i < 10; i++) {
            var msgByAPI = {"ts": new Date().getTime(), "id": tester.idByAPI, "way": "ByAPI"}            
            tester.arrSendMsgByAPI.push(msgByAPI)
            tester.idByAPI++
            threading.Thread(sendMsgByAPI, msgByAPI, robotId, accessKey, secretKey)

            var msgByHttp = {"ts": new Date().getTime(), "id": tester.idByHttp, "way": "ByHttp"}
            tester.arrSendMsgByHttp.push(msgByHttp)
            tester.idByHttp++
            threading.Thread(sendMsgByHttp, msgByHttp, httpUrl)
        }
    }

    tester.getEcho =function(msg) {
        if (msg["way"] == "ByAPI") {
            tester.arrEchoMsgByAPI.push(msg)
        } else {
            tester.arrEchoMsgByHttp.push(msg)
        }
    }

    tester.deal = function() {
        var tbls = []
        for (var pair of [[tester.arrEchoMsgByHttp, tester.arrSendMsgByHttp, "ByHttp"], [tester.arrEchoMsgByAPI, tester.arrSendMsgByAPI, "ByAPI"]]) {
            var receivedMessages = pair[0]
            var sentMessages = pair[1]
            var testType = pair[2]

            var receivedMap = new Map()
            receivedMessages.forEach(message => {
                receivedMap.set(message["id"], message)
            })
            
            var matchedPairs = []
            var timeDifferences = []
            for (var sentMessage of sentMessages) {
                var receivedMessage = receivedMap.get(sentMessage["id"])
                if (receivedMessage) {
                    matchedPairs.push([JSON.stringify(sentMessage), JSON.stringify(receivedMessage), receivedMessage["ts"] - sentMessage["ts"]])
                    timeDifferences.push(receivedMessage["ts"] - sentMessage["ts"])
                } else {
                    Log("no matched sentMessage:", sentMessage, "#FF0000")
                }
            }
            
            var averageTimeDifference = timeDifferences.reduce((sum, diff) => sum + diff, 0) / timeDifferences.length
            
            var tbl = {
                "type": "table",
                "title": testType + " / averageTimeDifference:" + averageTimeDifference,
                "cols": ["send", "received", "ts diff"],
                "rows": []
            }

            for (var pair of matchedPairs) {
                tbl["rows"].push(pair)
            }

            tbls.push(tbl)
            Log(testType, ", averageTimeDifference:", averageTimeDifference, "ms")
        }

        tester.arrSendMsgByAPI = []
        tester.arrSendMsgByHttp = []
        tester.arrEchoMsgByAPI = []
        tester.arrEchoMsgByHttp = []

        return tbls
    }

    return tester
}

function main() {
    __Serve("http://0.0.0.0:8088", serverFunc)

    var t = createMsgTester(accessKey, secretKey, httpUrl)
    while (true) {
        Log("测试开始...", "#FF0000")
        t.run()

        var beginTS = new Date().getTime()
        while (new Date().getTime() - beginTS < 60 * 1000) {
            var cmd = GetCommand()
            if (cmd) {
                try {
                    var obj = JSON.parse(cmd)
                    obj["ts"] = new Date().getTime()
                    t.getEcho(obj)
                } catch (e) {
                    Log(e)
                }
            }
            
            var msg = threading.mainThread().peekMessage(-1)
            if (msg) {
                try {
                    var obj = JSON.parse(msg)
                    obj["ts"] = new Date().getTime()
                    t.getEcho(obj)                
                } catch (e) {
                    Log(e)
                }
            }
        }
        Log("等待结束...", "#FF0000")
                
        var tbls = t.deal()
        LogStatus(_D(), "\n`" + JSON.stringify(tbls) + "`")
        Sleep(20000)
    }
}

Se for testado, é necessário preencher um endereço IP específico do servidor, o API KEY da extensão da plataforma FMZ.

var httpUrl = "http://123.123.123.123:8088/CommandRobot"
var accessKey = "xxx"
var secretKey = "xxx"

A função serverFunc cria um serviço HTTP paralelo para escutar sinais externos. Para mensagens externas recebidas pela API de extensão, a função GetCommand é usada para escutar.

  • A mensagem enviada pelo thread do serviço https: Porvar msg = threading.mainThread().peekMessage(-1)Ouça.

  • A mensagem de interação é transmitida através da API: Porvar cmd = GetCommand()Ouça.

2o, o processo de envio e recebimento de sinais é sem bloqueio, e a plataforma otimiza o mecanismo de recuperação de recursos de múltiplos fios no fundo, para que os sinais possam ser transmitidos sem bloqueio.ThreadOuexchange.GoFunções de concomitância, sem a necessidade de esperar explicitamente a conclusão de tarefas de concomitância (por exemplo, funções de junção, funções de espera, etc.), o sistema subterrâneo processa automaticamente a recuperação de recursos (requer apenas o suporte de um administrador com a versão mais recente).

    // 摘录代码片段，发送信号
    tester.run = function() {
        var robotId = tester.currentRobotId

        for (var i = 0; i < 10; i++) {
            var msgByAPI = {"ts": new Date().getTime(), "id": tester.idByAPI, "way": "ByAPI"}            
            tester.arrSendMsgByAPI.push(msgByAPI)
            tester.idByAPI++
            threading.Thread(sendMsgByAPI, msgByAPI, robotId, accessKey, secretKey)   // 并发调用，非阻塞

            var msgByHttp = {"ts": new Date().getTime(), "id": tester.idByHttp, "way": "ByHttp"}
            tester.arrSendMsgByHttp.push(msgByHttp)
            tester.idByHttp++
            threading.Thread(sendMsgByHttp, msgByHttp, httpUrl)                       // 并发调用，非阻塞
        }
    }

    // 摘录代码片段，接收信号
    var cmd = GetCommand()                              // 监听来自扩展API的消息，非阻塞
    var msg = threading.mainThread().peekMessage(-1)    // 监听来自自建Http服务的消息，使用了参数-1，非阻塞

A seguir, vamos ver este processo de teste, que mostra que a informação é anotada diretamente no código:

function main() {
    __Serve("http://0.0.0.0:8088", serverFunc)      // 在当前策略实例中，创建一个并发的http服务

    var t = createMsgTester(accessKey, secretKey, httpUrl)   // 创建一个用于测试管理的对象
    while (true) {                                           // 策略主循环开始
        Log("测试开始...", "#FF0000")
        t.run()                                              // 每次循环开始，调用测试管理对象的run函数，使用两种方式（1、通过扩展API发送信号，2、直接向当前策略创建的Http服务发送信号），每种方式并发发送10个请求

        var beginTS = new Date().getTime()
        while (new Date().getTime() - beginTS < 60 * 1000) {   // 循环检测来自扩展API的交互消息，循环检测来自自建Http服务的消息
            var cmd = GetCommand()
            if (cmd) {
                try {
                    var obj = JSON.parse(cmd)
                    obj["ts"] = new Date().getTime()        // 检测到交互消息，记录消息，更新时间为收到时间
                    t.getEcho(obj)                          // 记录到对应数组
                } catch (e) {
                    Log(e)
                }
            }
            
            var msg = threading.mainThread().peekMessage(-1)
            if (msg) {
                try {
                    var obj = JSON.parse(msg)
                    obj["ts"] = new Date().getTime()        // 检测到自建的Http服务收到的消息，更新时间为收到时间
                    t.getEcho(obj)                          // ...
                } catch (e) {
                    Log(e)
                }
            }
        }
        Log("等待结束...", "#FF0000")
                
        var tbls = t.deal()                                  // 根据记录的消息，配对，检查是否有未配对的消息，如果有说明有信号丢失
        LogStatus(_D(), "\n`" + JSON.stringify(tbls) + "`")
        Sleep(20000)
    }
}

Resultados dos testes

img

img

Com um tempo de testes, pode-se observar que o método HTTP é um pouco menos demorado do que o método API, em média.

A estratégia de recepção de sinais do serviço HTTP incorporado, este método de teste não é muito rigoroso, as solicitações devem vir de fora. Para uma simples compreensão, pode-se ignorar esse fator. Para a captação de sinais de ambos os modos, a estratégia de recepção de sinais do serviço HTTP incorporado deve ser um pouco mais rápida. Para a estabilidade do sinal, o mais importante é que o sinal não seja perdido ou perdido.

Neste artigo, o serviço HTTP embutido no código do texto não é verificado e é apenas um simples recebimento de dados de mensagens. No próximo artigo, implementamos um modelo completo de serviço HTTP embutido para receber sinais externos do Trading View.

Mais.

2019 FMZ - Todos os direitos reservados