The @os module contains functions and classes for manipulating operating system primitives
such as paths, folders, processes, threads, and mutexes.
Normalize a path.
The function does the following:
Get items in a directory (folder).
Each item is like:
{
name : string,
is_folder : boolean,
modified : number (timestamp; seconds since Unix epoch),
size : number (bytes)
}
If recursive is true, each item.name is a path relative to root. If recursive is false, each item.name is just the leaf.
Get status of file at path.
Same item format as :dir.
Change modification time of an existing file.
This is similar to the "touch" command-line tool except that it does nothing if path does not exist (the "touch" command-line tool creates an empty file).
Change the current directory.
If path is null, the current directory is not changed (just returned).
Remove (delete) directory (folder) at path. Directory must be empty.
Use @io:remove to remove individual files.
Create folder(s) at path.
Get absolute path from partial/relative path.
Get folder from a file path.
Get the leaf (filename) from a file path.
Returns the same path for filename-only paths.
Get the extension (everything after the dot) from a file path.
Get the name (filename without extension) from a file path.
Get the absolute path of the directory in which the Axiom binary resides
Get the absolute path of the Axiom binary
Get the platform that the Axiom binary was compiled for.
Get environment variable under name.
Environment variables are inherited from the shell and parent processes.
Get environment variable under name.
Environment variables are inherited by subprocesses created by system, run, and exec
Get time in milliseconds from arbitrary point.
This is used to do fine-grained timing, not absolute timing.
Sleep for a specified duration in seconds (fractional seconds allowed).
This pauses the current thread for the specified time without consuming any CPU cycles.
In a multithreading/mutliprocessing context, it allows other threads/processes to preempt the current thread (allows them to jump ahead on the schedule and execute), even if zero is specified.
Run a command in the underlying shell of the operating system.
The underlying implementation uses system().
if os.platform()=='windows'
os.system('dir /b/od')
else
os.system('ls -ltr')
Run a command and capture the output as a string.
Unlike :system, this function suppresses the output and returns it as a string.
Execute a command in the background.
Unlike :system and :run, this function does not wait for the command to complete.
On Posix, this spawns a child process. A child process will be killed when the parent process is killed. However, if the child process finishes before the parent process finishes, the PID is not cleaned up until the parent calls :wait() or :done(). This is known as a zombie process. The reason for this behavior is so that a child process PID is not reused until the parent process is notified that it has finished.
On Windows, there is no special relationship with the spawned process.
Find PID for a process by matching name against pattern.
The process name is the name of the executable without leading path or trailing command-line arguments.
Kill a process.
Check if process is finished.
Wait for process to finish.
On Posix, this only works for child processes. (This only works for PIDs returned by :exec() not :find_pid().)
Get a bunch of machine metrics.
The object of metrics is like:
{
cpu_usage : number, #0-100%, CPU usage across all cores
mem_usage" : number, #0-100%
disk_usage : number, #0-100%
io_wait : number, #0-100%, CPU time spent waiting for IO
clock_freq : number, #in GHz
mem_size : number, #in GB
disk_size : number, #in GB
num_cores : number,
num_connections : number #number of TCP connections
}
This function does not fully work on all platforms besides Linux. On Raspberry Pi, clock_freq and num_cores are missing. On MacOS, only disk_usage and disk_size are present. On Windows, all metrics are missing.
The name comes from /proc, which is where most of the metrics are found on Linux.
Get the timezone for the machine.
Note that not all time zones are a whole number difference from UTC. For example, India is +5.5 hours.
print os.timezone() #should be -8 for California
@thread MethodsConstruct a new thread.
Reading/writing to the same variable from different thread can cause Axiom to crash. It is the responsibility of the programmer to properly use @mutex around shared data.
:hello(name) print 'hello',name+'!' t = os.thread(hello,null,['from another thread']) t.start() t.wait()
Start the thread.
Wait for thread to finish.
Blocks current thread until thread has finished.
Check if thread is finished.
Checks asynchronously (does not block current thread).
Kill the thread (stop execution of thread).
Get the return value of the function that was called by the thread
The return value of this method will be null until the thread is finished. However, do not use this method to check if the thread is finished; use :done() or :wait() instead.
@mutex MethodsConstruct a new mutex.
A mutex allows code from different threads to synchronize.
Lock the mutex.
If the mutex is already locked, this will block until the mutex is unlocked.
Attempt to lock the mutex, but do not wait for it.
Unlike :lock, this does not block the current thread.
Release lock on current mutex.
@pty MethodsCreate a new pseudo-terminal, which can be used to programmatically interact with a subprocess.
The cmd should include the full path of the binary, plus any arguments, separated by spaces.
This class currently doesn't work on Windows. It only works on Posix systems.
Read a chunk of data from the pseudo-terminal.
This function blocks until data is read.
Write data to the pseudo-terminal.
This function block until all data is written.
Close pseudo-terminal and kill subprocess.