Development How To

pidfile_name = "/tmp/myprog.pid"
if os.access(os.path.expanduser(pidfile_name), os.F_OK): #if the lockfile is already there then check the PID number in the lock file
    pidfile = open(os.path.expanduser(pidfile_name), "r")
    pidfile.seek(0)
    pid = pidfile.readline()
    # Now we check the PID from lock file matches to the current process PID
    if os.path.exists("/proc/%s" % pid):
        print "Already running. Stopping."
        sys.exit(1)
    else:
        os.remove(os.path.expanduser(pidfile_name)) # File is there but the program is not running. Removing lock file.

file(pidfile_name, 'w').write(str(os.getpid()))

def flag_handler(sig, frame):
    global flag
    flag = (sig == signal.SIGUSR1)

signal.signal(signal.SIGUSR1,flag_handler) # register the signal
signal.signal(signal.SIGUSR2,flag_handler)

pidfile_name = "/tmp/myprog.pid"
def sendsignal(flag):
    if os.access(os.path.expanduser(pidfile_name), os.F_OK):
        #if the lockfile is already there then check the PID number the lock file
        pidfile = open(os.path.expanduser(pidfile_name), "r")
        pidfile.seek(0)
        pid = pidfile.readline()
        if os.path.exists("/proc/%s" % pid): # Now we check the PID from lock file matches to the current process PID
            os.kill(int(pid),signal.SIGUSR1 if flag else signal.SIGUSR2) # send the signal
        else:
            os.remove(os.path.expanduser(pidfile_name)) # File is there but the program is not running. Removing lock file.
    else:
        print "Target is not running"

import os, time, json, errno

def retry_write(*args, **kwargs):
    # Like os.write, but retries until EAGAIN stops appearing
    while True:
        try:
            return os.write(*args, **kwargs)
        except OSError as e:
            if e.errno == errno.EAGAIN:
                time.sleep(0.5)
            else:
                raise
class Pipe(object):
    # FIFO based IPC based on newline-separated JSON
    ENCODING = 'utf-8'

    def __init__(self,sPath):
        self.sPath = sPath
        if not os.path.exists(sPath):
            os.mkfifo(sPath)
        self.fd = os.open(sPath,os.O_RDWR | os.O_NONBLOCK)
        self.file_blocking = open(sPath, "r", encoding=self.ENCODING)

    def write(self, dmsg):
        serialised = json.dumps(dmsg) + "\n"
        dat = bytes(serialised.encode(self.ENCODING))
        # This blocks until data can be read by other process.
        # Can just use os.write and ignore EAGAIN if you want
        # to drop the data
        retry_write(self.fd, dat)

    def read(self):
        serialised = self.file_blocking.readline()
        return json.loads(serialised)

oP = Pipe(some_path)
while 1:
    oP.write({'a':'foo','b':'bar','c':'erm...','d':'plop!','e':'etc'})

oP = Pipe(same_path_as_before)
while 1:
    print(oP.read())

import mmap, os, struct, time

def main():
    fd = os.open('/tmp/mmaptest', os.O_RDONLY)
    buf = mmap.mmap(fd, mmap.PAGESIZE, mmap.MAP_SHARED, mmap.PROT_READ) # Memory map the file
    i = None
    s = None
    while 1:
        new_i, = struct.unpack('i', buf[:4])
        new_s, = struct.unpack('3s', buf[4:7])
        if i != new_i or s != new_s:
            print 'i: %s => %d' % (i, new_i)
            print 's: %s => %s' % (s, new_s)
            print 'Press Ctrl-C to exit'
            i = new_i
            s = new_s
        time.sleep(1)

if __name__ == '__main__':
    main()

import ctypes, mmap, os, struct

def main():
    fd = os.open('/tmp/mmaptest', os.O_CREAT | os.O_TRUNC | os.O_RDWR)     # Create new empty file to back memory map on disk
     assert os.write(fd, '\x00' * mmap.PAGESIZE) == mmap.PAGESIZE          # Zero out the file to insure it's the right size
    # Create the mmap instace with the following params:
    # fd: File descriptor which backs the mapping or -1 for anonymous mapping
    # length: Must in multiples of PAGESIZE (usually 4 KB)
    # flags: MAP_SHARED means other processes can share this mmap
    # prot: PROT_WRITE means this process can write to this mmap
    buf = mmap.mmap(fd, mmap.PAGESIZE, mmap.MAP_SHARED, mmap.PROT_WRITE)
    # Now create an int in the memory mapping
    i = ctypes.c_int.from_buffer(buf)
    i.value = 10
    i.value += 1     # And manipulate it for kicks
    assert i.value == 11
    # Before we create a new value, we need to find the offset of the next free
    # memory address within the mmap
    offset = struct.calcsize(i._type_)
    # The offset should be uninitialized ('\x00')
    assert buf[offset] == '\x00'
    # Now ceate a string containing 'foo' by first creating a c_char array
    s_type = ctypes.c_char * len('foo')
    # Now create the ctypes instance
    s = s_type.from_buffer(buf, offset)
    # And finally set it
    s.raw = 'foo'
    print 'First 10 bytes of memory mapping: %r' % buf[:10]
    raw_input('Now run b.py and press ENTER')
    print 'Changing i'
    i.value *= i.value
    print 'Changing s'
    s.raw = 'bar'
    new_i = raw_input('Enter a new value for i: ')
    i.value = int(new_i)

if __name__ == '__main__':
    main()

class mysocket:
    def __init__(self, sock=None):
        if sock is None:
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        else:
            self.sock = sock

    def connect(self, host, port):
        self.sock.connect((host, port))

    def mysend(self, msg):
        totalsent = 0
        while totalsent < MSGLEN:
            sent = self.sock.send(msg[totalsent:])
            if sent == 0:
                raise RuntimeError("socket connection broken")
            totalsent = totalsent + sent

    def myreceive(self):
        chunks = []
        bytes_recd = 0
        while bytes_recd < MSGLEN:
            chunk = self.sock.recv(min(MSGLEN - bytes_recd, 2048))
            if chunk == '':
                raise RuntimeError("socket connection broken")
            chunks.append(chunk)
            bytes_recd = bytes_recd + len(chunk)
        return ''.join(chunks)

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
<window id="xxx" title="Process launcher" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" xmlns:html="http://www.w3.org/1999/xhtml">
<script type="application/x-javascript">
<![CDATA[
    function getFile() {
        try {
            // 1. Turn off the security. For the local files it should work.
            netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
            // 2. Get the file to be executed via file picker. File picker is not the only way to get the local file object,
            const nsIFilePicker = Components.interfaces.nsIFilePicker;
            var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(Components.interfaces.nsIFilePicker);
            fp.init(window, "Open Executable file", nsIFilePicker.modeOpen);
            var rv = fp.show();
            if (rv == nsIFilePicker.returnOK) {
                // So far so good...
                var file = fp.file;
                // Now create the process, itit and launch it
                var process = Components.classes["@mozilla.org/process/util;1"].createInstance(Components.interfaces.nsIProcess);
                process.init(file);
                // The process will not block the browser (1st arg), no command line options (2nd and 3rd args)
                process.run(false, {array: {}, size_iz: function() {return 0;}}, 0);
            }
        } catch(e) {
            alert('!!! Bad news - "Exception, Sir!" ["+e+"]');
        }
        return;
    }
]]>
</script>
<groupbox>
<description>Make sure that the browser's preference <html:code><html:b>signed.applets.codebase_principal_support</html:b></html:code> is set to <html:b>true</html:b>.
(Complete set of FF preferences is accessable via <html:u>about:config</html:u> in the browser's URL bar).
This approach to bypass FF's security is pretty fine for the development, especially when you run the developed code in the dedicated isolated FF profile.
Just don't forget to set it back to <html:b>false</html:b> when you are done with this sample.
Otherwise the page must be signed to have access to the browser's internals and then to the local resources.<html:br/><html:br/></description>
<button id="btnFile" label="OpenFile" oncommand="getFile();" />
</groupbox>
</window>

import java.applet.*;
import java.io.*;

public class ReadFromJar extends Applet{

public void init(){
  readTextFromJar("datafile1.txt");
  readTextFromJar("test/datafile2.txt");
  }

  public void readTextFromJar(String s) {
    String thisLine;
    try {
      InputStream is = getClass().getResourceAsStream(s);
      BufferedReader br = new BufferedReader
         (new InputStreamReader(is));
      while ((thisLine = br.readLine()) != null) {
         System.out.println(thisLine);
         }
      }
    catch (Exception e) {
      e.printStackTrace();
      }
  }
}

<HTML><HEAD></HEAD>
  <BODY>
    <APPLET CODE=ReadFromJar.class width=1 height=1 archive=readjar.jar></APPLET>
    See java console for output
  </BODY>
</HTML>