Run as a daemon or service: Difference between revisions

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

{{trans|QB64}}

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

 

Print #1, Time + " - Running" 'Imprime en el archivo previamente abierto la hora actual del sistema (hh:mm:ss) y una nota

Next i

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|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}}