DEV Community: Wilberto Morales

Use Signals to Safely Stop processes

Wilberto Morales — Fri, 31 Dec 2021 04:05:29 +0000

Here are some times you probably don't want your process to stop:

When saving data to disk or some other resource.
When in the middle of some long running job.
When doing something business critical.

We can add signal handlers that place your process into a state of stopping the
next time it is ready.


import signal  # (1)
import time
import os

should_quit = False  # (2)

def main():
    stop_signal = signal.SIGUSR1  # (3)
    signal.signal(stop_signal, on_signal)  # (4)

    print(f"Starting - process id is: {os.getpid()}")  # (5)
    print(f"Send {stop_signal} to safely stop")  # (6)

    while not should_quit:
        print("Doing work, please do not interrupt this.")
        time.sleep(3)  # (7)
        print("Done with this unit of work")

    print("Stopping")


def on_signal(signum, frame):  # (8)
    global should_quit

    print("Received request to stop...doing so when it is safe.")
    should_quit = True  # (9)


if __name__ == "__main__":
    main()

The builtin signal module in Python. Most programming languages will provide a similar module for using signals.
We use a global variable(should_quit) to keep track of when the program should stop.
We are choosing SIGUSR1 for this example. There are many different signals, some are reserved for special purposes by your OS or programming language. SIGUSR1 is set aside for programmers to define their own custom handler.
Here we are saying: when my program receives a SIGUSR1, I want you to call the on_signal handler.
We print the process ID to make it easier to send the signal to the correct process.
We print the signal to make it easier to send the correct signal. On my OS, behind the scenes SIGUSR1 maps to 10.
This line represents some task your program is doing that you do not wish to interrupt.
A signal handler is a regular function that takes two parameters signum and frame.
on_signal simply sets should_quit to True, the next time we check against it, the programs stops.

Here is an example run:

$ python program.py
Starting - process id is: 25716
Send 10 to safely stop
Doing work, please do not interrupt this.
Done with this unit of work
Doing work, please do not interrupt this.
Done with this unit of work
Doing work, please do not interrupt this.
Done with this unit of work
Doing work, please do not interrupt this.

We see that our process ID is 25716 and the signal is 10. So to send our signal
we execute:

$ kill -10 25716

Received request to stop...doing so when it is safe.
Done with this unit of work
Stopping

Our processs receives the signal and calls our handler but the program resumes
its work without interruption. The next time around, it sees that we requested
to stop and does so.

Making Decisions

Wilberto Morales — Tue, 31 Aug 2021 04:03:40 +0000

Making decisions can be difficult; here are my models for making them.

Scorecards

Imagine you need to choose between different vendors for an Anti-Virus.
Looking at alternative vendor websites makes it hard to compare solutions. It's easy to make a choice that doesn't satisfy all the requirements. Having
a scorecard that compares all the solutions makes it easier and reduces mistakes.

Criteria	AV X	AV Y
Windows 8	✓	✓
Windows 10	✓	✓
Patch Management	✓	✗
Monthly Cost	10	2

Scorecards are a tool I first learned about from a recruiting book and have repurposed for engineering.

Radar charts

Radar Charts are a great way to compare the
attributes of different solutions. As software engineers, we need to remind ourselves that there are no
silver bullets. Radar charts make this obvious.

For example, imagine you need to choose between different software architectures. Their "ilities" should be considered—scalability, observability, changeability, reversibility, and so on.

List the "ilities" that are important to you and graph them
for each alternative.

Costs for being wrong

Keep in mind the cost (usually money and time), risk, long-term consequences, and reversibility of the decision.

If these aren't severe and you are OK with the consequences, don't waste time making the decision.
Just make it and move on.

I've seen too many people anguish over choices that they could have made in a few minutes.

React Testing Library - Testing a Node Attribute

Wilberto Morales — Mon, 29 Mar 2021 23:22:45 +0000

You can test HTML node attributes with the toHaveAttribute matcher. When you need more than an equality check, though, you can use getAttribute.

For example, here is a component that has a mailto link. Let's test the subject and recipient.

import React from "react";

export function Component() {
  return <a href="mailto:example@example.com?subject=Hello">Send</a>;
}

You could write one test:

import React from "react";
import { Component } from "./component.jsx";
import { render } from "@testing-library/react";
import "@testing-library/jest-dom/extend-expect";

it("has a subject and correct recipient", () => {
  const component = <Component />;
  const { getByText } = render(component);

  expect(getByText("Send")).toHaveAttribute(
    "href",
    "mailto:example@example.com?subject=Hello"
  );
});

This test case is testing two things at once though, the "and" in the test name gives it
away.

Lets test each idea seperately:

import React from "react";
import { Component } from "./component.jsx";
import { render } from "@testing-library/react";

it("has a subject", () => {
  const component = <Component />;
  const { getByText } = render(component);

  expect(getByText("Send").getAttribute("href")).toMatch(
    /subject=Hello/
  );
});

it("emails the example email address", () => {
  const component = <Component />;
  const { getByText } = render(component);

  expect(getByText("Send").getAttribute("href")).toMatch(
    /mailto:example@example.com/
  );
});

Library Testing Functionality

Wilberto Morales — Wed, 09 Sep 2020 01:47:54 +0000

We would save a lot of developer time if libraries included testing functionality. One example of this is the Python requests library. It's a beautiful piece of software that makes dealing with HTTP requests easy. Testing that you're making the correct HTTP requests is not straightforward, though.

You can use the built-in python mock library. I won't reiterate points that have been made elsewhere but mocking usually leads to code smells.
You can use the responses library. It helps, but it becomes unmanageable quickly. It's challenging to set up expected responses, especially since there could be multiple per test. Additionally, it seems that it is unmaintained. I have run into bugs around passthrus and random test ordering.
You can use another third party testing library. I don't have experience with them and settled on building a personal one.

At work(PrintWithMe) we have multiple internal libraries. For any new one added, we make it a habit to provide testing functionality, including fakes/doubles, fixtures, setup/teardown, and other helper functions.

Tips for Code Assignments

Wilberto Morales — Thu, 20 Aug 2020 18:05:09 +0000

Over the last six months, I have been reviewing coding assignments while searching for our next Software Engineer at PrintWithMe. Here are some tips I would give developers on the other side of this.

Use the programming language you're best at

You might feel this is a good time to test a new programming language you have been learning. The problem is that using a language you don't have real experience with will lead to mistakes. If the reviewer knows the programming language in your submission, they will quickly spot places where you don't measure against experienced developers using that programming language.

Another reason developers do this is that they feel the need to use the programming language listed in the job posting. Ask about this ahead of time, but in my experience, great companies don't care what programming language you use. They understand that a good developer is a good developer, and picking up a new language will not be a problem.

Run your code through tools

Take the time to run your code through formatting, static analysis, and other tools. It shows that you care about code quality, and it will catch common errors. If the person reviewing your code runs it through these tools, they will be put off immediately by warnings.

Test your code

I'm surprised by the number of developers who still don't know about TDD or testing in general. If you're one of them, take the time to learn it and use it on your code submission. If you are applying for any company where high-quality systems are important, tests will be a requirement. Even if they are not specified in the instructions, add them, they will make you stand out.

Make sure your submission is correct

Sometimes I get submissions that are straight-up wrong. This is because the developer forgot to test against corner cases like when the input is 0, an empty string, or something along those lines.

After making changes to your code, test everything again. A few times, candidates would make last-minute changes and forget to test running the program. There's nothing worse than your submission crashing on the first run.

Write clear documentation

Document how to test and run the code. Add a description of your design decisions. This might be controversial, but I'm going to come right out and say it: reading three paragraphs on why you chose "dynamic algorithms" is boring. Add documentation for humans.

Even though this is something I will forgive if the code is good, it's a place to stand out. A developer needs to communicate clearly with everyone in the company, not just other developers. Its something a lot of engineers struggle with, myself included. If you show me you are better at it than me, I want you on my team.

Testing Logger

Wilberto Morales — Wed, 19 Aug 2020 23:14:19 +0000

Logging is sometimes a part of your requirements. For example, you might want to issue a warning anytime some security event occurs. I like to test these events using a TestingLogger class that can stand in place of a real logger.

First, make your loggers parameters to your functions and classes. Globals make testing difficult.

class Example:

    def __init__(self, logger):
        self._logger = logger

    def do_something(self):
        self._logger.info("Logged something!")


def example(logger):
    logger.info("Logged something!")

Now you can use the TestingLogger during tests. If it quacks like a duck, its a duck. Let's make a TestingLogger that quacks like a logger.


class TestingLogger:
    def __init__(self):
        self.messages = []

    def debug(self, message):
        self._log(message)

    def info(self, message):
        self._log(message)

    def warning(self, message):
        self._log(message)

    def error(self, message):
        self._log(message)

    def critical(self, message):
        self._log(message)

    def exception(self, message):
        self._log(message)

    def _log(self, message):
        self.messages.append(message)

This class implements the methods you will call 99% of the time against a logger. Instead of logging though, it will capture the messages in a messages list. You can make assertions against this list in your tests.


def test_example_function():
    logger = TestingLogger()

    example(logger)

    assert "Logged something!" == logger.messages[0]


def test_example_class():
    logger = TestingLogger()

    Example(logger).do_something()

    assert "Logged something!" == logger.messages[0]

You can expand on this idea in many ways:

Capture the log level if you need to assert against them.
Inherit from list and use self.append to capture logs. Then you can make assertions against the testing logger directly instead of logger.messages.
Capture the str value of exceptions instead of the instances in TestingLogger.exception.
If passing loggers as parameters is cumbersome, you can create a default when one isn't specified, giving you flexibility in tests and convenience in the rest of the places.

If you would like to learn more about this testing style, check out the Python architecture book. It is one of the best programming books I have read in a long time.

As an Amazon Associate, I earn from qualifying purchases