signals

I need some help with sending email when an order is placed. To illustrate the problem, following is the abstract code: class Order(models.Model): user = models.ForeignKey(User) class OrderItem(modes.Model): order = models.ForeignKey(Order, related_name='items') item = models.CharField(max_length=255) unit_price = models.DecimalField() qty = models.IntegerField() item_amount = models.DecimalField() def email_order_on_save(sender, instance, **kwargs): # Need order.items.all() here pass post_save.connect(email_order_on_save, sender=Order) Most of the problems on SO and google seem to deal with

The POSIX specifies two types for thread cancellation type: PTHREAD_CANCEL_ASYNCHRONOUS , and PTHREAD_CANCEL_DEFERRED (set by pthread_setcanceltype(3) ) determining when pthread_cancel(3) should take effect. By my reading, the POSIX manual pages do not say much about these, but Linux manual page says the following about PTHREAD_CANCEL_ASYNCHRONOUS : The thread can be canceled at any time. (Typically, it will be canceled immediately upon receiving a cancellation request, but the system doesn't guarantee this.) I am curious about the meaning about the system doesn't guarantee this . I can easily

There is a timer which sends out signal SIGALARM every 1 sec. A signal handler which sleeps 2 sec is registered. What happens? Specifically, I have following code, in which the process runs multiple threads. It's quite interesting that with this long signal handler, it looks other threads are blocked from execution... Can anyone explain why this is the case? #include <unistd.h> #include <stdio.h> #include <stdlib.h> //rand #include <sys/wait.h> #include <time.h> #include <sys/time.h> #include <pthread.h> #define NUM_THREADS 2 int init_timer(int real_time, int msec) { struct itimerval timeslice

I'd like to create a complete instruction trace of the execution of a program, to collect some stats etc. I first tried using linux' ptrace functionality to step through a program (using the tutorial here ). This creates two processes, the traced one and the debugger, and they communicate via signals. I only got around 16K instructions per second (on 1.6GHz Atom), so this is too slow for anything non-trivial. I thought the interprocess communication via signals is too slow, so I tried setting up the debugging in the same process as the execution: Set the trap flag, and create a signal handler.

Here's the scenario. I have a Django app being served by Gunicorn on Linux. On certain requests it makes an https call to an external API via httplib2.request() . Sometimes that call fails in such a way that hoses OpenSSL (not sure how, but it's not my fault and doesn't really matter). OpenSSL sends a SIGABRT signal to gunicorn in this case. Gunicorn handles the SIGABRT and promptly system exits (as it should). The root issue as I see it is that OpenSSL asynchronously signals the parent process to abort, rather than returning an error code. Don't tell me to abort because of YOUR personal

As far as I understand signals sent to a parent process should not be sent to children. So why does SIGINT reach both the child and the parent in the example below? #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <unistd.h> void sigCatcher( int ); int main ( void ) { if (signal(SIGINT, sigCatcher) == SIG_ERR) { fprintf(stderr, "Couldn't register signal handler\n"); exit(1); } if(fork() == 0) { char *argv[] = {"find","/",".",NULL}; execvp("find",argv); } for (;;) { sleep(10); write(STDOUT_FILENO, "W\n",3); } return 0; } void sigCatcher( int theSignal ) { write(STDOUT_FILENO,