कार्यों के "अंतहीन" पुनरावृत्ति के लिए मुझे किस ओटीपी व्यवहार का उपयोग करना चाहिए?

Question

मैं फीनिक्स एप्लिकेशन के बगल में बार-बार संचालन के समान अनुक्रम को चलाने के लिए चाहता हूं (यदि पूरे कार्यकर्ता में कुछ ब्रेक लगाना है तो पूरे वेब-ऐप को क्रैश किए बिना) और वास्तव में गीलेर को नहीं जानते हैं, मुझे जेनसेवर का उपयोग करना चाहिए , इलीक्सिर के कार्य, एक एजेंट या कुछ पूरी तरह से अलग मैंने अभी तक सोचा नहीं है।

जब मैं अपना फीनिक्स ऐप शुरू करता हूं तो एक कार्यकर्ता भी शुरू होना चाहिए, जो समय-समय पर एक सीरियल कनेक्शन के कुछ मूल्य खींचता है, उन्हें फीनिक्स चैनल के माध्यम से प्रसारित करता है, उन्हें @save_interval तक पहुंचता है और फिर औसत, गणना करता है कि मध्य एक अलग चैनल के माध्यम से और इसे एक InfluxDB लिखता है। अभी मैं कुछ (काम करने की तरह) इस तरह है:

def do_your_thing(serial_pid) do 
    Stream.interval(@interval_live) 
    |> get_new_values_from_serial(serial_pid) 
    |> broadcast!("live-channel:#{@name}") 
    |> Enum.take(div(@interval_save, @interval_live)) 
    |> calculate_medians() 
    |> broadcast!("update-channel:#{@name}") 
    |> write_to_database() 

    do_your_thing(serial_pid) # repeat 
end 

मैं केवल सब OTP सामान यह पता लगाने की शुरू कर और आशा है कि आप की कोई मदद कर सकता है मुझे यहाँ सही दिशा में ठोकर।

Answer 1

आप एक GenServer (नीचे उदाहरण में 60 सेकंड) ही एक्स सेकंड के बाद संदेश भेजता है कि उपयोग करना चाहिए:

defmodule MyApp.Worker do 
    use GenServer 

    def start_link() do 
    GenServer.start_link(__MODULE__, []) 
    end 

    def init([]) do 
    schedule_work() 
    {:ok, []} 
    end 

    def handle_info(:work, state) do 
    state = do_work(state) 
    schedule_work() 
    {:noreply, state} 
    end 

    defp do_work(state) do 
    # Do your work here and return state 
    end 

    defp schedule_work do 
    Process.send_after(self(), :work, 60_000) 
    end 
end