Run as a daemon or service: Difference between revisions

==={{header|FreeBASIC}}===

{{trans|QB64}}

Open "c:\Users\Default\Documents\myDaemon.log" For Append As #1

'Open "myDaemon.log" For Append As #1 'Ruta de archivo relativa para la salida // Relative file path for the output

Close #1 'Cierra el archivo previamente abierto para escritura // Close the file previously open for writing

ScreenUnlock()

 

==={{header|QB64}}===

'' The following line is double commented ('') as some metacommands still execute even when singularly commented (')

''$Console 'Closes the console but does not close the main window, used for whole program run

Next i%

Close #1 'Closes the file previously opened for writing

{{out}}

<pre>09:02:23 - Running

The task also wants to redirect stdout. This program does so with [http://netbsd.gw.com/cgi-bin/man-cgi?dup2+2+NetBSD-current dup2(2)]. Had we wanted to directly write to a file, we could open the file with <code>file = fopen(argv[1], "a")</code>, and write to ''file'' instead of ''stdout''.

 

#include <errno.h>

#include <fcntl.h>

sleep(1); /* Can wake early or drift late. */

}

 

<pre>$ make dumper

{{libheader|go-daemon}}

{{works with|Ubuntu 16.04}}

 

import (

 

work()

 

{{out}}

{{trans|Python}}

This is a direct translation of the Python Posix version.

 

let pid = fork()

while now() < t + initDuration(seconds = 10):

echo "timer running, $# seconds".format((now() - t).inSeconds)

 

{{out}}

=={{header|PARI/GP}}==

GP scripts cannot run in this fashion directly, but can be compiled into PARI code with <code>gp2c</code>. PARI code, whether from <code>gp2c</code> or not, can be run as a daemon just as [[#C|C]] would be.

 

=={{header|Phix}}==

Assuming this task is simply "a program that can write to stdout(/stderr) or a file".<br>

In some cases free_console() may help, should an attached console have been incorrectly created in the first place.<br>

to stdout, whereas printf(fn,fmt,args) writes to some previously opened fn.<br>

Of course there is nothing at all to stop fn from being set to 1 for stdout, or 2 for stderr.<br>

It is also strongly against the core philosophy of Phix to have or permit anything that would somehow make printf(1,x) do something it does not look like it should be doing, especially given printf(fn,x) has no such ambiguity. Not having to change your code may sound dandy, not being able to tell what your code is doing by looking at it, isn't.

<span style="color: #008080;">without</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">timedate</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- [close(1) quietly does nothing]</span>

{{out}}

<small>(When fn is 1, or the content of log.txt when it is not.)</small>

 

=={{header|PicoLisp}}==

(out "file.log"

(println *Pid) # First write the daemon's PID to the file

(bye) ) # Child terminates after one hour

 

 

=={{header|Pike}}==

if the first argument is "daemon" the program will be restarted with stdout redirected to "foo".

 

{

if (sizeof(argv)>1 && argv[1] == "daemon")

sleep(0.1);

}

 

=={{header|Python}}==

#!/usr/bin/python3

import posix

print("timer running, %s seconds" % str(time.time() - t))

time.sleep(1)

 

=={{header|Racket}}==

#lang racket

(require ffi/unsafe)

(with-output-to-file "/tmp/foo"

(λ() (for ([i 10]) (displayln (random 1000)) (flush-output) (sleep 1))))

 

=={{header|Raku}}==

(formerly Perl 6)

# https://github.com/hipek8/p6-UNIX-Daemonize/

 

sleep(1);

spurt $output, DateTime.now.Str~"\n", :append;

{{out}}<pre>root@ubuntu:~# su - david

david@ubuntu:~$ ./dumper.p6

=={{header|Sidef}}==

When the "daemon" argument is specified, a fork of the program is created with its STDOUT redirected into the file "foo.txt", and the main process is exited.

for n in (1..100) {

STDOUT.say(n)

 

STDERR.say("Normal mode")

 

=={{header|Smalltalk}}==

{{works with |Smalltalk/X}}

(pid := OperatingSystem fork) == 0 ifTrue:[

Stdin close.

Stdout showCR: e'forked new process pid={pid}; now exiting'.

OperatingSystem exit:0

{{out}}

<pre>bash-3.2$ ./daemon.st

Tcl doesn't come with tools for converting the process into a daemon, but can build them easily enough. Here's the BSD daemon function mapped into a Tcl command in a package.

{{libheader|Critcl}}

package require critcl

 

}

return TCL_OK;

These tools can then be used to solve this task:

if {$argc < 1} {

puts "usage: $argv0 file ?message...?"

proc every {ms body} {eval $body; after $ms [info level 0]}

every 1000 {puts "[clock format [clock seconds]]: $message"}

On Windows, there is a commercial extension to Tcl which allows a script to be installed as a service. Such a script would be much like the one above, but without the daemonization section as that has become a property of the runtime.

 

{{omit from|Brlcad}}