I am using typescript to build a microservice and handling signals as well. The code was working fine till a few days ago but recently it started throwing errors. Couldn&#39;t find a fix for the issue. 

code for handling signals. It is just part of the file.
`src/main.ts`
```
  enum signals {
    SIGHUP = 1,
    SIGINT = 2,
    SIGTERM = 15
  }
  const shutdown = (signal, value) =&gt; {
    logger.warn(&quot;shutdown!&quot;)
    Db.closeAll()
    process.exit(value)
  }
  Object.values(signals).forEach(signal =&gt; {
    process.on(signal, () =&gt; {
      logger.warn(`process received a ${signal} signal`)
      shutdown(signal, signals[signal])
    })
  })
```

When I do `ts-node src/main.ts` The following error throws and exits.

```

/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:245
    return new TSError(diagnosticText, diagnosticCodes)
           ^
TSError: ⨯ Unable to compile TypeScript:
src/main.ts:35:16 - error TS2769: No overload matches this call.
  The last overload gave the following error.
    Argument of type &#39;string | signals&#39; is not assignable to parameter of type &#39;Signals&#39;.
      Type &#39;string&#39; is not assignable to type &#39;Signals&#39;.

35     process.on(signal, () =&gt; {
                  ~~~~~~

  node_modules/@types/node/base.d.ts:653:9
    653         on(event: Signals, listener: SignalsListener): this;
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The last overload is declared here.

    at createTSError (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:245:12)
    at reportTSError (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:249:19)
    at getOutput (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:362:34)
    at Object.compile (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:395:32)
    at Module.m._compile (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:473:43)
    at Module._extensions..js (module.js:663:10)
    at Object.require.extensions.(anonymous function) [as .ts] (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:476:12)
    at Module.load (module.js:565:32)
    at tryModuleLoad (module.js:505:12)
    at Function.Module._load (module.js:497:3)
```

Any fix would be appreciated. Or If you can tell why it was working earlier just 2 days ago and not now. 

No overload matches this call. Type &#39;string&#39; is not assignable to type &#39;Signals&#39;

Is there a way to map a signal number (e.g. signal.SIGINT) to its respective name (i.e. &quot;SIGINT&quot;)?

I&#39;d like to be able to print the name of a signal in the log when I receive it, however I cannot find a map from signal numbers to names in Python, i.e.:
    
    import signal
    def signal_handler(signum, frame):
        logging.debug(&quot;Received signal (%s)&quot; % sig_names[signum])

    signal.signal(signal.SIGINT, signal_handler)

For some dictionary sig_names, so when the process receives SIGINT it prints:

    Received signal (SIGINT)

Get signal names from numbers in Python

In my application, I want to create entries in certain tables when a new user signs up. For instance, I want to create a userprofile which will then reference their company and some other records for them. I implemented this with a post_save signal:

    def callback_create_profile(sender, **kwargs):
        # check if we are creating a new User
        if kwargs.get(&#39;created&#39;, True):
            user = kwargs.get(&#39;instance&#39;)
            company = Company.objects.create(name=&quot;My Company&quot;)
            employee = Employee.objects.create(company=company, name_first=user.first_name, name_last=user.last_name)
            profile = UserProfile.objects.create(user=user, employee=employee, partner=partner)
    # Register the callback
    post_save.connect(callback_create_profile, sender=User, dispatch_uid=&quot;core.models&quot;)

This works well when run. I can use the admin to create a new user and the other three tables get entries with sensible as well. (Except that is, the employee since the user.first_name and user.last_name aren&#39;t filled out in the admin&#39;s form when it saves. I still don&#39;t understand why it is done like that)

The problem came when I ran my test suite. Before this, I had created a bunch of fixtures to create these entries in the tables. Now I get an error that states:

    IntegrityError: duplicate key value violates unique constraint &quot;core_userprofile_user_id_key&quot;

I think this is because I have already created a company,employee and profile records in the fixture with id &quot;1&quot; and now the post_save signal is trying to recreate it.

My questios are: can I disable this post_save signal when running fixtures? Can I detect that I am running as part of the test suite and not create these records? Should I delete these records from the fixtures now (although the signal only sets defaults not the values I want to be testing against)? Why doesn&#39;t the fixture loading code just overwrite the created records?

How do people do this?

How do I prevent fixtures from conflicting with django post_save signal code?

I have a VirtualBox process hanging around which I tried to kill (`KILL`/`ABORT`) but without success. The parent pid is 1 (init).

`top` shows the process as `D` which is documented as &quot;uninterruptible sleep&quot;.

`strace` shows up nothing.

How can I get rid of this? It prevents me from unloading the VirtualBox kernel driver to load a newer one.

How to stop &#39;uninterruptible&#39; process on Linux?

There&#39;re many exit points in my bash code. I need to do some clean up work on exit, so I used trap to add a callback for exit like this:

    trap &quot;mycleanup&quot; EXIT

The problem is there&#39;re different exit codes, I need to do corresponding cleanup works. Can I get exit code in mycleanup?

How to trap exit code in Bash script

I have done the below post_save signal in my project. 

    from django.db.models.signals import post_save
    from django.contrib.auth.models import User
    
    # CORE - SIGNALS
    # Core Signals will operate based on post
    
    def after_save_handler_attr_audit_obj(sender, **kwargs):
        print User.get_profile()
        
        if hasattr(kwargs[&#39;instance&#39;], &#39;audit_obj&#39;):
            if kwargs[&#39;created&#39;]:
                kwargs[&#39;instance&#39;].audit_obj.create(operation=&quot;INSERT&quot;, operation_by=**USER.ID**).save()
            else:
                kwargs[&#39;instance&#39;].audit_obj.create(operation=&quot;UPDATE&quot;).save()
    
    
    # Connect the handler with the post save signal - Django 1.2
    post_save.connect(after_save_handler_attr_audit_obj, dispatch_uid=&quot;core.models.audit.new&quot;)


The operation_by column, I want to get the user_id and store it. Any idea how can do that?

Accessing the user&#39;s request in a post_save signal

I have a ```like``` function which is just like social networks like or thumbs up function; the user clicks the star / heart / whatever to mark the content as liked.It is done with ajax and must be fast. 

The only problem here is that for some reasons I have to do some tasks for each ```like``` and I found out they were coded straight in the ```like``` view and it makes it slow. 

I am thinking of using signals to make the execution of these tasks asynchronous so the view can send back the ```json``` right away to the ```javascript``` without waiting for the tasks to finish. 

I started creating a signal for the ```like``` but then realized that Django&#39;s ```signals``` were not asynchronous and it would end up the same, the view would have to wait for the signal to finish to send back its response. 

So I could try to make that ```signal``` asynchronous as it is explained here and there but I would as well use the ```post_save``` signal for the ```like``` model but now I wonder if the view can finish before the signal gets executed?

Is Django post_save signal asynchronous?

I have a signal_handler connected through a decorator, something like this very simple one:

    @receiver(post_save, sender=User, 
              dispatch_uid=&#39;myfile.signal_handler_post_save_user&#39;)
    def signal_handler_post_save_user(sender, *args, **kwargs):
       # do stuff

What I want to do is to mock it **with the mock library http://www.voidspace.org.uk/python/mock/** in a test, to check how many times django calls it. My code at the moment is something like:

    def test_cache():
        with mock.patch(&#39;myapp.myfile.signal_handler_post_save_user&#39;) as mocked_handler:
            # do stuff that will call the post_save of User
        self.assert_equal(mocked_handler.call_count, 1)

The problem here is that the original signal handler is called even if mocked, most likely because the ```@receiver``` decorator is storing a copy of the signal handler somewhere, so I&#39;m mocking the wrong code.

So the question: how do I mock my signal handler to make my test work?

Note that if I change my signal handler to:

    def _support_function(*args, **kwargs):
        # do stuff

    @receiver(post_save, sender=User, 
              dispatch_uid=&#39;myfile.signal_handler_post_save_user&#39;)
    def signal_handler_post_save_user(sender, *args, **kwargs):
       _support_function(*args, **kwargs)

and I mock ```_support_function``` instead, everything works as expected.

How do I mock a django signal handler?

I have a small server program that accepts connections on a TCP or local UNIX socket, reads a simple command and (depending on the command) sends a reply. 

The problem is that the client may have no interest in the answer and sometimes exits early.  So writing to that socket will cause a `SIGPIPE` and make my server crash. 

What&#39;s the best practice to prevent the crash here? Is there a way to check if the other side of the line is still reading? (`select()` doesn&#39;t seem to work here as it always says the socket is writable). Or should I just catch the `SIGPIPE` with a handler and ignore it?

How to prevent SIGPIPEs (or handle them properly)

I want to capture the &lt;kbd&gt;Ctrl+C&lt;/kbd&gt; (`SIGINT`) signal sent from the console and print out some partial run totals.


Is it possible to capture a Ctrl+C signal (SIGINT) and run a cleanup function, in a &quot;defer&quot; fashion?

How does one catch &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;C&lt;/kbd&gt; in C?

Catch Ctrl-C in C

My application runs as a background process on Linux. It is currently started at the command line in a Terminal window.

Recently a user was executing the application for a while and it died mysteriously. The text:

&gt; Killed

was on the terminal. This happened two times. I asked if someone at a different Terminal used the kill command to kill the process? No.

Under what conditions would Linux decide to kill my process?  I believe the shell displayed &quot;killed&quot; because the process died after receiving the kill(9) signal.  If Linux sent the kill signal should there be a message in a system log somewhere that explains why it was killed?


What killed my process and why?

I was about to add an extra signal handler to an app we have here and I noticed that the author had used `sigaction()` to set up the other signal handlers. I was going to use `signal()`. To follow convention I should use `sigaction()` but if I was writing from scratch, which should I choose?

What is the difference between sigaction and signal?

How do I catch a &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;C&lt;/kbd&gt; event in C++?

How can I catch a ctrl-c event?

Basically, what signal does &#39;0&#39; represent, because [here][1] I see SIGNAL numbers starting from 1. 


  [1]: http://lxr.linux.no/linux+v2.6.16.60/include/asm-i386/signal.h#L34

What does `kill -0 $pid` in a shell script do?

I&#39;m working on a python script that starts several processes and database connections. Every now and then I want to kill the script with a &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;C&lt;/kbd&gt; signal, and I&#39;d like to do some cleanup.

In Perl I&#39;d do this:

&lt;!-- language: perl --&gt;

    $SIG{&#39;INT&#39;} = &#39;exit_gracefully&#39;;
    
    sub exit_gracefully {
        print &quot;Caught ^C \n&quot;;
        exit (0);
    }

How do I do the analogue of this in Python?

How do I capture SIGINT in Python?

In Linux, what happens when a program (that possibly has multiple threads) receives a signal, like SIGTERM or SIGHUP?

Which thread intercepts the signal? Can multiple threads get the same signal? Is there a special thread dedicated entirely to handling signals? If not, what happens inside the thread that is to handle the signal? How does the execution resume after the signal handler routine finishes?

Signal handling with multiple threads in Linux

Just wondering about the difference between SIGSTOP and SIGTSTP signals.  

What is the difference between SIGSTOP and SIGTSTP?

In a [*comment*](https://stackoverflow.com/questions/526782/how-do-i-limit-the-running-time-of-a-bash-script#comment340090_526815) on [this answer][1] of another [question][2], the commenter says:

&gt; don’t use kill&amp;nbsp;-9 unless absolutely
&gt; necessary! SIGKILL can’t be trapped so
&gt; the killed program can’t run any
&gt; shutdown routines to e.g.&amp;nbsp;erase
&gt; temporary files. First try HUP&amp;nbsp;(1),
&gt; then INT&amp;nbsp;(2), then QUIT&amp;nbsp;(3)

I agree in principle about `SIGKILL`, but the rest is news to me. Given that the default signal sent by `kill` is `SIGTERM`, I would expect it is the most-commonly expected signal for graceful shutdown of an arbitrary process. Also, I have seen `SIGHUP` used for non-terminating reasons, such as telling a daemon &quot;re-read your config file.&quot; And it seems to me that `SIGINT` (the same interrupt you&#39;d typically get with Ctrl-C, right?) isn&#39;t as widely supported as it ought to be, or terminates rather ungracefully.

Given that `SIGKILL` is a last resort &amp;mdash; **Which signals, and in what order**, should you send to an arbitrary process, in order to shut it down as gracefully as possible?

Please substantiate your answers with supporting facts (beyond personal preference or opinion) or references, if you can.

Note: I am particularly interested in best practices that include consideration of bash/Cygwin.

**Edit:** So far, nobody seems to mention INT or QUIT, and there&#39;s limited mention of HUP. Is there any reason to include these in an orderly process-killing?

  [1]: https://stackoverflow.com/questions/526782#526815
  [2]: https://stackoverflow.com/questions/526782

In what order should I send signals to gracefully shutdown processes?

I have (in the past) written cross-platform (Windows/Unix) applications which, when started from the command line, handled a user-typed &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;C&lt;/kbd&gt; combination in the same way (i.e. to terminate the application cleanly).

Is it possible on Windows to send a &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;C&lt;/kbd&gt;/SIGINT/equivalent to a process from another (unrelated) process to request that it terminate cleanly (giving it an opportunity to tidy up resources etc.)?

Can I send a ctrl-C (SIGINT) to an application on Windows?

I&#39;m moving [a project][1] to the new Android Native Development Kit (i.e. JNI) and I&#39;d like to catch SIGSEGV, should it occur (possibly also SIGILL, SIGABRT, SIGFPE) in order to present a nice crash reporting dialog, instead of (or before) what currently happens: the immediate unceremonious death of the process and possibly some attempt by the OS to restart it. (&lt;b&gt;Edit:&lt;/b&gt; The JVM/Dalvik VM catches the signal and logs a stack trace and other useful information; I just want to offer the user the option to email that info to me really.) 

The situation is: a large body of C code which I didn&#39;t write does most of the work in this application (all the game logic) and although it&#39;s well-tested on numerous other platforms, it&#39;s entirely possible that I, in my Android port, will feed it garbage and cause a crash in native code, so I want the crash dumps (both native and Java) that currently show up in the Android log (I guess it would be stderr in a non-Android situation). I&#39;m free to modify both C and Java code arbitrarily, although the callbacks (both going in and coming out of JNI) number about 40 and obviously, bonus points for small diffs.

I&#39;ve heard of the signal chaining library in J2SE, libjsig.so, and if I could safely install a signal handler like that on Android, that would solve the catching part of my question, but I see no such library for Android/Dalvik.


  [1]: http://chris.boyle.name/projects/android-puzzles

How can I catch SIGSEGV (segmentation fault) and get a stack trace under JNI on Android?

Since `printf` is not reentrant, it&#39;s not supposed to be safe to use it in a signal handler. But I&#39;ve seen lots of example codes that uses `printf` this way.

So my question is: when do we need to avoid using `printf` in a signal handler, and is there a recommended replacement?

How to avoid using printf in a signal handler?

How do I catch a &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;C&lt;/kbd&gt; in multiprocess python program and exit all processes gracefully, I need the solution to work both on unix and windows. I&#39;ve tried the following:

    import multiprocessing
    import time
    import signal
    import sys
    
    jobs = []
    
    def worker():
        signal.signal(signal.SIGINT, signal_handler)
        while(True):
            time.sleep(1.1234)
            print &quot;Working...&quot;
    
    def signal_handler(signal, frame):
        print &#39;You pressed Ctrl+C!&#39;
        # for p in jobs:
        #     p.terminate()
        sys.exit(0)
    
    if __name__ == &quot;__main__&quot;:
        for i in range(50):
            p = multiprocessing.Process(target=worker)
            jobs.append(p)
            p.start()

And it&#39;s kind of working, but I don&#39;t think it&#39;s the right solution.

  [1]: https://stackoverflow.com/questions/1408356/keyboard-interrupts-with-pythons-multiprocessing-pool

Catch Ctrl+C / SIGINT and exit multiprocesses gracefully in python

I read somewhere that we should lock the **mutex** before calling **pthread_cond_signal** and unlock the mutex after calling it:

&gt; The pthread_cond_signal() routine is
&gt; used to signal (or wake up) another
&gt; thread which is waiting on the
&gt; condition variable. It should be
&gt; called after mutex is locked, and must
&gt; unlock mutex in order for
&gt; pthread_cond_wait() routine to
&gt; complete.

My question is: isn&#39;t it OK to call **pthread_cond_signal** or **pthread_cond_broadcast** methods without locking the mutex?

Calling pthread_cond_signal without locking mutex

I want to kill a whole process tree.  What is the best way to do this using any common scripting languages? I am looking for a simple solution.

What&#39;s the best way to send a signal to all members of a process group?

In Unix we can suspend a process execution temporarily and resume it with signals `SIGSTOP` and `SIGCONT`. How can I suspend a single-threaded process in Windows without programming ? 

How to suspend/resume a process in Windows?

In my Django app, I need to start running a few periodic background jobs when a user logs in and stop running them when the user logs out, so I am looking for an elegant way to

 1. get notified of a user login/logout
 2. query user login status

From my perspective, the ideal solution would be

 1. a signal sent by each `django.contrib.auth.views.login` and `... views.logout`
 2. a method `django.contrib.auth.models.User.is_logged_in()`, analogous to `... User.is_active()` or `... User.is_authenticated()`

Django 1.1.1 does not have that and I am reluctant to patch the source and add it (not sure how to do that, anyway).

As a temporary solution, I have added an `is_logged_in` boolean field to the UserProfile model which is cleared by default, is set the first time the user hits the landing page (defined by `LOGIN_REDIRECT_URL = &#39;/&#39;`) and is queried in subsequent requests. I added it to UserProfile, so I don&#39;t have to derive from and customize the builtin User model for that purpose only.

I don&#39;t like this solution. If the user explicitely clicks the logout button, I can clear the flag, but most of the time, users just leave the page or close the browser; clearing the flag in these cases does not seem straight forward to me. Besides (that&#39;s rather data model clarity nitpicking, though), `is_logged_in` does not belong in the UserProfile, but in the User model.

Can anyone think of alternate approaches ?

Django: signal when user logs in?

I&#39;ve been trying to understand the intricacies of how POSIX threads and POSIX signals interact. In particular, I&#39;m interested in:

* What&#39;s the best way to control which thread a signal is delivered to (assuming it isn&#39;t fatal in the first place)?
* What is the best way to tell another thread (that might actually be busy) that the signal has arrived? (I already know that it&#39;s a bad idea to be using pthread condition variables from a signal handler.)
* How can I safely handle passing the information that a signal has occurred to other threads? Does this need to happen in the signal handler? (I do not in general want to kill the other threads; I need a far subtler approach.)

For reference about why I want this, I&#39;m researching how to convert the [TclX](http://sourceforge.net/projects/tclx/) package to support threads, or to split it up and at least make some useful parts support threads. Signals are one of those parts that is of particular interest.

POSIX threads and signals

Many Unix programs accept signals like `USR1` and `USR2`. For example, to upgrade the executable for Nginx on the fly, you send `kill -USR2`.

I understand that `USR1` is a &quot;user defined&quot; signal, meaning that whoever created the program can use it to mean &quot;shut down&quot; or &quot;dump your logs&quot; or &quot;print foo a thousand times&quot; or whatever. But I don&#39;t understand why they must use this arbitrary name. Why not `kill -UPGRADE`, or `kill -GRACEFUL_SHUTDOWN`? Does Unix only allow specific signals?

While we&#39;re at it, Nginx also uses the following signals (see [documentation][1]):

- **TERM, INT**: Quick shutdown
- **QUIT**: Graceful shutdown
- **HUP**: 
  - Configuration reload
  - Start the new worker processes with a new configuration
  - Gracefully shutdown the old worker processes
- **USR1**: Reopen the log files
- **USR2**: Upgrade Executable on the fly
- **WINCH**: Gracefully shutdown the worker processes

HUP? WINCH? What&#39;s the reason for these names? Where can I learn more about this?

  [1]: http://wiki.nginx.org/CommandLine

Why can&#39;t Unix programs have signals with meaningful program defined names (rather than USR1, etc)?

On Mac OS X, if I send SIGQUIT to my C program, it terminates, but there is no core dump file.

Do you have to manually enable core dumps on Mac OS X (how?), or are they written to somewhere else instead of the working directory?

Where are core dumps written on Mac?

What is the correct way to make my PyQt application quit when killed from the console (Ctrl-C)?

Currently (I have done nothing special to handle unix signals), my PyQt application ignores SIGINT (Ctrl+C). I want it to behave nicely and quit when it is killed. How should I do that?

What is the correct way to make my PyQt application quit when killed from the console (Ctrl-C)?

Can I provide/pass any arguments to signal handler?

    /* Signal handling */
    struct sigaction act;
    act.sa_handler = signal_handler;
    /* some more settings */

Now, handler looks like this:

    void signal_handler(int signo) {
        /* some code */
    }

If I want to do something special i.e. delete temp files, can I provide those files as an argument to this handler?

Edit 0: Thanks for the answers. We generally avoid/discourage use of global variables. And in this case, If you have a huge program, things can go wrong at different places and you might need to do a lot of cleanup. Why was the API designed this way?

Providing/passing argument to signal handler

I&#39;m evaluating Pusher and PubNub at the moment to enable bi-directional realtime communications between my primarily web clients and my servers.  Both look impressive, with Pusher&#39;s docs seeming to be better, and PubNub&#39;s scalability and reliability clearly a strong point for them.

However, as I am managing a budget, I am concerned that Pusher &amp; PubNub costs may become an issue for us, and am therefore considering using one of the open source alternatives out there - I&#39;ve looked primarily at Socket.io, Faye and jWebSocket.  

I have my concerns though running the service myself though:

 - Has anyone actually scaled a Socket.io or other open source solution to multiple servers before?  PubNub claim to deal with **1M messages a second!**, I somewhat doubt Socket.io could do that without an unfathomable number of servers, if it would work at all.
 - Are there features in the paid services that I am likely going to miss down the line should I go with the open source solutions?
 - Is latency really going to be a concern if I have my server on AWS anyway?  PubNub are in multiple locations so I expect this should reduce latency although if a message needs to be sent from the US to Japan, having a server in Japan wouldn&#39;t help with latency as it still needs to travel there one way or another.

Thanks for the advice.

Pusher vs Pubnub vs open source Socket.io / SignalR.net / Faye / jWebSocket

In the app I&#39;m developing on Android, I keep getting a Fatal Signal 11 error.

I think it&#39;s something to do with the way that I&#39;m accessing the memory but I can&#39;t figure out what is causing it. 

Any help will be much appreciated!

Here&#39;s the LogCat:

    05-02 23:47:17.618: D/dalvikvm(590): GC_FOR_ALLOC freed 68K, 4% free 6531K/6787K, paused 101ms
    05-02 23:47:17.638: I/dalvikvm-heap(590): Grow heap (frag case) to 7.619MB for 1228816-byte allocation
    05-02 23:47:17.738: D/dalvikvm(590): GC_CONCURRENT freed 1K, 4% free 7730K/8007K, paused 5ms+14ms
    05-02 23:47:17.878: D/dalvikvm(590): GC_FOR_ALLOC freed &lt;1K, 4% free 7730K/8007K, paused 37ms
    05-02 23:47:17.888: I/dalvikvm-heap(590): Grow heap (frag case) to 8.790MB for 1228816-byte allocation
    05-02 23:47:17.998: D/dalvikvm(590): GC_CONCURRENT freed &lt;1K, 4% free 8930K/9223K, paused 4ms+4ms
    05-02 23:47:17.998: A/libc(590): Fatal signal 11 (SIGSEGV) at 0x00000000 (code=1)



Android Fatal Signal 11

I recently ran into an issue with Command Prompt on Windows where QuickEdit mode was enabled and clicking the window was selecting text and hanging a running program. This is, apparently, known behaviour—I found a few questions related to it:

- [Command Line Windows Hanging in RDP Windows][1]
- [Windows Console Application Getting Stuck][2]
- [How to disable QuickEdit Mode for individual scripts][3]

How is the application &quot;paused&quot;/&quot;suspended&quot;? Is the process similar to the `SIGSTOP` signal on *nix? (I am also interested in understanding *why* this functionality exists in the first place? It seems unintuitive and dangerous.)

  [1]:https://stackoverflow.com/q/591047/1267663
  [2]:https://stackoverflow.com/q/4453692/1267663
  [3]:https://stackoverflow.com/q/21805712/1267663


How and why does QuickEdit mode in Command Prompt freeze applications?

I know in bash I can run one command after another by separating them by semicolons, like

    $ command1; command2

Or if I only want `command2` to run only if `command1` succeeds, using `&amp;&amp;`:

    $ command1 &amp;&amp; command2

This works, but if I suspend `command1` using `Ctrl-z`, in the first case, it runs `command2` immediately, and in the second case, it doesn&#39;t run it at all.  How can I run commands in sequence, but still be able to suspend the first command, but not have the second run until I have restarted it (with `fg`) and it finishes?  I&#39;d prefer something as simple to type as possible, as I would like to do this interactively.  Or maybe I just need to set an option somewhere.

By the way, what is the proper term for what `Ctrl-z` does?

Run one command after another, even if I suspend the first one (Ctrl-z)

I want to capture the &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;D&lt;/kbd&gt; signal in my program and write a signal handler for it.
How can I do that?
I am working on *C* and using a *Linux* system.

How to capture Control+D signal?

I&#39;m having issues with a custom signal in a class I made.

Relevant code:

    self.parse_triggered = QtCore.pyqtSignal()

    def parseFile(self):
		self.emit(self.parse_triggered)

Both of those belong to the class: RefreshWidget.
In its parent class I have:

    self.refreshWidget.parse_triggered.connect(self.tabWidget.giveTabsData())

When I try to run the program, I get the error:

    AttributeError: &#39;PyQt4.QtCore.pyqtSignal&#39; object has no attribute &#39;connect&#39;

Help?
Thanks in advance.

PyQt4.QtCore.pyqtSignal object has no attribute &#39;connect&#39;

I&#39;m getting acquainted with signals in C. I can&#39;t figure out what kind of signals `SIGUSR1` and `SIGUSR2` are and how can I trigger them. Can anyone please explain it to me?

How to trigger SIGUSR1 and SIGUSR2?

I would like to know exactly how the execution of asynchronous signal handlers works on Linux. First, I am unclear as to *which* thread executes the signal handler. Second, I would like to know the steps that are followed to make the thread execute the signal handler.

On the first matter, I have read two different, seemingly conflicting, explanations:

1.  The Linux Kernel, by Andries Brouwer, [&#167;5.2 &quot;Receiving signals&quot; states][1]:

    &gt; When a signal arrives, the process is interrupted, the current registers are saved, and the signal handler is invoked. When the signal handler returns, the interrupted activity is continued.

2.  The [StackOverflow question &quot;Dealing With Asynchronous Signals In Multi Threaded Program&quot;][2] leads me to think that Linux&#39;s behavior is [like SCO Unix&#39;s][3]:

    &gt; When a signal is delivered to a process, if it is being caught, it will be handled by one, and only one, of the threads meeting either of the following conditions:
    &gt; 1. A thread blocked in a [**sigwait**(2)][4] system call whose argument *does* include the type of the caught signal.

    &gt; 2. A thread whose signal mask *does not* include the type of the caught signal.

    &gt; Additional considerations:
    &gt;  * A thread blocked in [**sigwait**(2)][5] is given preference over a thread not blocking the signal type.
    &gt;  * If more than one thread meets these requirements (perhaps two threads are calling [**sigwait**(2)][6]), then one of them will be chosen. This choice is not predictable by application programs.
    &gt;  * If no thread is eligible, the signal will remain \`\`pending&#39;&#39; at the process level until some thread becomes eligible.

    Also, [&quot;The Linux Signals Handling Model&quot; by Moshe Bar states][7] &quot;Asynchronous signals are delivered to the first thread found not blocking the signal.&quot;, which I interpret to mean that the signal is delivered to some thread having its sigmask *not* including the signal.

Which one is correct?

On the second matter, what happens to the stack and register contents for the selected thread?  Suppose the thread-to-run-the-signal-handler *T* is in the middle of executing a `do_stuff()` function. Is thread *T*&#39;s stack used directly to execute the signal handler (i.e. the address of the signal trampoline is pushed onto *T*&#39;s stack and control flow goes to the signal handler)? Alternatively, is a separate stack used? How does it work?


  [1]: http://www.win.tue.nl/~aeb/linux/lk/lk-5.html#ss5.2
  [2]: https://stackoverflow.com/q/6223191/196844
  [3]: http://uw714doc.sco.com/en/SDK_sysprog/PTL_ThdsSigs.html#_Asynch-Generated_Signal
  [4]: http://uw714doc.sco.com/en/man/html.2/sigwait.2.html
  [5]: http://uw714doc.sco.com/en/man/html.2/sigwait.2.html
  [6]: http://uw714doc.sco.com/en/man/html.2/sigwait.2.html
  [7]: http://www.linuxjournal.com/article/3985?page=0,1

All Signals Solutions on Gang of Coders

Total of 40 Signals Solutions