The docs say that calling sys.exit() raises a SystemExit exception which can be caught in outer levels.  I have a situation in which I want to definitively and unquestionably exit from inside a test case, however the unittest module catches SystemExit and prevents the exit.  This is normally great, but the specific situation I am trying to handle is one where our test framework has detected that it is configured to point to a non-test database.  In this case I want to exit and prevent any further tests from being run.  Of course since unittest traps the SystemExit and continues happily on it&#39;s way, it is thwarting me.

The only option I have thought of so far is using ctypes or something similar to call   exit(3) directly but this seems like a pretty fugly hack for something that should be really simple.

Is there a way to prevent a SystemExit exception raised from sys.exit() from being caught?

I inherited a database built with the idea that composite keys are much more ideal than using a unique object ID field and that when building a database, a single unique ID should &lt;b&gt;&lt;em&gt;never&lt;/em&gt;&lt;/b&gt; be used as a primary key.  Because I was building a Rails front-end for this database, I ran into difficulties getting it to conform to the Rails conventions (though it was possible using custom views and a few additional gems to handle composite keys).

The reasoning behind this specific schema design from the person who wrote it had to do with how the database handles ID fields in a non-efficient manner and when it&#39;s building indexes, tree sorts are flawed.  This explanation lacked any depth and I&#39;m still trying to wrap my head around the concept (I&#39;m familiar with using composite keys, but not 100% of the time).

Can anyone offer opinions or add any greater depth to this topic?  

Composite primary keys versus unique object ID field

I want to prevent my script running more than once at a time. 

My current approach is

  - create a semaphore file containing the pid of the running process
  - read the file, if my process-id is not in it exit (you never know...)
  - at the end of the processing, delete the file

In order to prevent the process from hanging, I set up a cron job to periodically check the file if its older then the maximum allowed running time and kills the process if it’s still running.

Is there a risk that I&#39;m killing a wrong process?

Is there a better way to perform this as a whole?

How to prevent a script from running simultaneously?

I want to prevent my script running more than once at a time.
My current approach is
<ul>
<li>create a semaphore file containing the pid of the running process</li>
<li>read the file, if my process-id is not in it exit (you never know...)</li>
<li>at the end of the processing, delete the file</li>
</ul>
In order to prevent the process from hanging, I set up a cron job to periodically check the file if its older then the maximum allowed running time and kills the process if it’s still running.
Is there a risk that I'm killing a wrong process?
Is there a better way to perform this as a whole?

Is it possible to check a bash script syntax without executing it?

Using Perl, I can run `perl -c &#39;script name&#39;`. Is there any equivalent command for bash scripts?

How do I syntax check a Bash script without running it?

What&#39;s a quick-and-dirty way to make sure that only one instance of a shell script is running at a given time?



Quick-and-dirty way to ensure only one instance of a shell script is running at a time

Trying to debug an issue with a server and my only log file is a 20GB log file (with no timestamps even! Why do people use `System.out.println()` as logging? In production?!)

Using grep, I&#39;ve found an area of the file that I&#39;d like to take a look at, line 347340107.

Other than doing something like

    head -&lt;$LINENUM + 10&gt; filename | tail -20 

... which would require `head` to read through the first 347 million lines of the log file, is there a quick and easy command that would dump lines 347340100 - 347340200 (for example) to the console?

**update** I totally forgot that grep can print the context around a match ... this works well. Thanks!



Quick unix command to display specific lines in the middle of a file?

Say, I have a script that gets called with this line:

    ./myscript -vfd ./foo/bar/someFile -o /fizz/someOtherFile

or this one:

    ./myscript -v -f -d -o /fizz/someOtherFile ./foo/bar/someFile 

What&#39;s the accepted way of parsing this such that in each case (or some combination of the two) `$v`, `$f`, and  `$d` will all be set to `true` and `$outFile` will be equal to `/fizz/someOtherFile`?

How do I parse command line arguments in Bash?

The way you would normally include a script is with &quot;source&quot;

eg:

main.sh:

    #!/bin/bash

    source incl.sh

    echo &quot;The main script&quot;

incl.sh:

    echo &quot;The included script&quot;

The output of executing &quot;./main.sh&quot; is:

    The included script
    The main script

... Now, if you attempt to execute that shell script from another location, it can&#39;t find the include unless it&#39;s in your path.

What&#39;s a good way to ensure that your script can find the include script, especially if for instance, the script needs to be portable?



How best to include other scripts?

Is there any advantage of using

 [**java.util.concurrent.CountdownLatch**][1] 

instead of

 [**java.util.concurrent.Semaphore**][2]? 

 As far as I can tell the following fragments are almost equivalent:

 **1. Semaphore**

    final Semaphore sem = new Semaphore(0);
    for (int i = 0; i &lt; num_threads; ++ i)
    {
      Thread t = new Thread() {
        public void run()
        {
          try
          {
            doStuff();
          }
          finally
          {
            sem.release();
          }
        }
      };
      t.start();
    }
    
    sem.acquire(num_threads);

 **2: CountDownLatch**

    final CountDownLatch latch = new CountDownLatch(num_threads);
    for (int i = 0; i &lt; num_threads; ++ i)
    {
      Thread t = new Thread() {
        public void run()
        {
          try
          {
            doStuff();
          }
          finally
          {
            latch.countDown();
          }
        }
      };
      t.start();
    }
    
    latch.await();

Except that in case #2 the latch cannot be reused and more importantly you need to know in advance how many threads will be created (or wait until they are all started before creating the latch.)

So in what situation might the latch be preferable?


  [1]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CountDownLatch.html
  [2]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Semaphore.html

CountDownLatch vs. Semaphore

Is there such a thing as an atomic test-and-set, semaphore, or lock in Javascript?

I have javascript invoking async background processes via a custom protocol (the background process literally runs in a separate process, unrelated to the browser). I believe I&#39;m running into a race condition; the background process returns between my test and my set, screwing things up on the javascript side. I need a test-and-set operation to make it a real semaphore. 

Here&#39;s the javascript code that attempts to detect background processes and queue them up:

    Call = function () {

    var isRunning = true,
		queue = [];

    return  {
        // myPublicProperty: &quot;something&quot;,

        call: function (method) {
    			if (isRunning) {
    				console.log(&quot;Busy, pushing &quot; + method);
    				queue.push(method);
    			} else {
    				isRunning = true;
    				objccall(method);
    			}
    		},
    		
    		done: function() {
		    	isRunning = false;
		    	if (queue.length &gt; 0) {
		    		Call.call(queue.shift());
		    	}
		    }
        };
    }();

Call is a singleton that implements the queuing; anybody that wants to invoke an external process does Call.call(&quot;something&quot;) .

Any ideas?

Javascript semaphore / test-and-set / lock?

What is mutex and semaphore in Java ? What is the main difference ?

What is mutex and semaphore in Java ? What is the main difference?

I am working on some code which uses the pthread and semaphore libraries. The `sem_init` function works fine on my Ubuntu machine, but on OS X the `sem_init` function has absolutely no effect. Is there something wrong with the library or is there a different way of doing it? This is the code I am using to test.

    sem_t sem1;
    sem_t sem2;
    sem_t sem3;
    sem_t sem4;
    sem_t sem5;
    sem_t sem6;

    sem_init(&amp;sem1, 1, 1);
    sem_init(&amp;sem2, 1, 2);
    sem_init(&amp;sem3, 1, 3);
    sem_init(&amp;sem4, 1, 4);
    sem_init(&amp;sem5, 1, 5);
    sem_init(&amp;sem6, 1, 6);

The values appear to be random numbers, and they do not change after the `sem_init` call.

sem_init on OS X

I&#39;ve heard these words related to concurrent programming, but what&#39;s the difference between lock, mutex and semaphore?

How to prevent a script from running simultaneously?

Bash Problem Overview

Bash Solutions

Composite primary keys versus unique object ID field

Is there a way to prevent a SystemExit exception raised from sys.exit() from being caught?

Attributions