Today is the North American 22nd anniversary of @HIDEO_KOJIMA_EN’s PS1 masterpiece METAL GEAR SOLID.
It changed me.
To celebrate, I commissioned artist @bud_sanfilippo (SG Customs) to riff on Yoji Shinkawa’s iconic brush strokes & colors.
Off-White Jordan x Shinkawa-San 1❗️ pic.twitter.com/dOIJ0632rv

— Jordan Vogt-Roberts (@VogtRoberts) October 21, 2020

Summary: To kill a thread use one of the following methods:

• Create an Exit_Request flag.
• Using the multiprocessing Module.
• Using the trace Module.
• Using ctypes to raise Exceptions in a thread

Problem: How to kill a thread in Python?

This is one of the most commonly asked questions in Python. Thus, in this article, we are going to address this issue and make sure you have a clear understanding of this topic. Before divining into the topic directly, we will have a look at threading in brief and then move on to our mission-critical question. So without further delay, let the games begin!  

Introduction

What is a Thread?

According to Wikipedia, in computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. Multiple threads can run concurrently within a single program. For example in a word processor, a background thread may be used for spell-checking while a foreground thread may be used to processes user input (keystrokes ), while yet a third thread may be used to load images from the hard drive, and a fourth thread might be busy doing periodic automatic backups of the file being edited.

• Therefore, treading in Python is used to run multiple threads that can be tasks or function calls, at the same time. Please note that this doesn’t mean that multiple threads are executed on different CPUs.
• Python threads do not make the program faster in case it already uses 100 % CPU time. That is probably a part of parallel programming which is not within the scope of this discussion.

Note: Threading in Python is itself an entire topic of discussion. The purpose of this introduction is to just get you acquainted with the idea of threads. It is highly recommended that you have some understanding of threading in Python before diving into the topic of killing the thread.

➥ When do we use Threading in Python?

Threads in Python are used in situations where the execution of a task or function call involves some waiting. An example could be interaction with a service hosted on a webserver. Thus, treading allows Python to execute other code while waiting. 

➥ Example:

import threading

import time print("Printing values from 90 to 100: ")

def loop_thread(): for t in range(90, 101): time.sleep(1) print(t) threading.Thread(target=loop_thread).start()

Output:

Printing values from 90 to 100: 90

91

92

93

94

95

96

97

98

99

100

Now that have an overview of threads, let us dive into our mission-critical question.

Ways To Kill A Thread In Python

Simply put, killing a thread abruptly is a very bad practice unless absolutely required. Having said that, you might want to kill a thread after a certain duration or after some interrupt. So, instead of closing it forcibly, you can kindly ask the thread to go away after ensuring a proper clean up which means:

• The thread you are trying to kill might be holding a critical resource that must be closed properly.
• The thread might have created several other threads that must be killed as well before the parent thread can be killed.

Let us understand the numerous ways that help us to do that.

Method 1: Creating An Exit Request Flag

If you are the manager of your own threads, a nice way of handling thread termination is to create an exit flag that each thread checks at regular intervals to know if it is time for it to exit.

Example:

import threading import time def thread_foo(stop): while True: print("THREAD STILL RUNNING!") if exit_flag: break exit_flag = False

t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) t.start() time.sleep(0.1) print('Done sleeping! Time to stop the threads.')

exit_flag = True

t.join() print('THREAD TERMINATED!')

Output:

In the above example, we created a function that keeps executing the thread until the program encounters the variable exit_flag = True. As soon as that happens, the thread can be killed using the t.join() method.

➥ Note: join() causes the main thread to wait for your thread to finish. In other words, join() acts as a “hold” on the main thread. It ensures that your thread has completed its execution before the main thread can move forward. In a way, it assures a clean and proper termination of your thread.

Method 2: Using The Multiprocessing Module

As stated in the Python documentation, multiprocessing is a package that supports spawning processes using an API similar to the threading module. Also, killing a process is much safer than killing a thread because threads share global variables and have a dependency, whereas processes are completely independent and exist separate from each other. The multiprocessing module has the terminate() function which is used to kill a process.

Let us have a look at the following example given below to understand how we can use the multiprocessing module to kill the process.

import multiprocessing

import time

def Child_process(): while True: for i in range (20): print ('Process: ', i) time.sleep(0.05)

t = multiprocessing.Process(target = Child_process)

t.start()

time.sleep(0.5)

t.terminate()

print("Child Process successfully terminated")

Output:

Process: 0

Process: 1

Process: 2

Process: 3

Process: 4

Process: 5

Process: 6

Process: 7

Process: 8

Process: 9

Child Process successfully terminated

In the above example after 0.5 seconds the execution of the Child_process was terminated using the terminate() function.

Method 3: Using The trace Module

Another approach to kill a thread is to install trace into the thread that will exit the thread. 

The module given below allows you to kill threads. The class KThread is a drop-in replacement for threading.Thread. It adds the kill() method, which should stop most threads in their tracks.

Disclaimer: The procedure given below has been taken from the following resource: Kill a thread in Python

KThread.py: A killable Thread implementation

import time

import sys

import trace

import threading class KThread(threading.Thread): """A subclass of threading.Thread, with a kill()

method.""" def __init__(self, *args, **keywords): threading.Thread.__init__(self, *args, **keywords) self.killed = False def start(self): """Start the thread.""" self.__run_backup = self.run self.run = self.__run threading.Thread.start(self) def __run(self): """Hacked run function, which installs the

trace.""" sys.settrace(self.globaltrace) self.__run_backup() self.run = self.__run_backup def globaltrace(self, frame, why, arg): if why == 'call': return self.localtrace else: return None def localtrace(self, frame, why, arg): if self.killed: if why == 'line': raise SystemExit() return self.localtrace def kill(self): self.killed = True # Example Usage

#This illustrates running a function in a separate thread. The thread is killed before the function finishes.

def func(): print('Function started') for i in range(1,100): print(i) time.sleep(0.2) print('Function finished') A = KThread(target=func)

A.start()

time.sleep(1)

A.kill()

Output:

Function started

1

2

3

4

5

Method 4: Using ctypes To Raise Exceptions In A Thread

In cases when you need to kill a thread forcibly, for example while wrapping an external library that is busy for long calls and you want to interrupt it, you can use raise_exc() to raise an arbitrary exception, or call terminate() to raise SystemExit automatically. It uses the unexposed PyThreadState_SetAsyncExc function (via ctypes) to raise an exception in the context of the given thread. 

The following code allows (with some restrictions) to raise an Exception in a Python thread:

Example:

import threading

import inspect

import ctypes

import time def _async_raise(tid, exctype): """raises the exception, performs cleanup if needed""" if not inspect.isclass(exctype): raise TypeError("Only types can be raised (not instances)") res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), ctypes.py_object(exctype)) if res == 0: raise ValueError("invalid thread id") elif res != 1: # """if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect""" ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0) raise SystemError("PyThreadState_SetAsyncExc failed") class Thread(threading.Thread): def _get_my_tid(self): """determines this (self's) thread id""" if not self.is_alive(): raise threading.ThreadError("the thread is not active") # do we have it cached? if hasattr(self, "_thread_id"): return self._thread_id # no, look for it in the _active dict for tid, tobj in threading._active.items(): if tobj is self: self._thread_id = tid return tid raise AssertionError("could not determine the thread's id") def raise_exc(self, exctype): """raises the given exception type in the context of this thread""" _async_raise(self._get_my_tid(), exctype) def terminate(self): """raises SystemExit in the context of the given thread, which should cause the thread to exit silently (unless caught)""" self.raise_exc(SystemExit) def f(): try: while True: for i in range(10000): print(i) time.sleep(0.1) finally: print ("TERMINATING!!!") t = Thread(target = f)

t.start()

time.sleep(0.6)

t.terminate()

t.join()

Output:

0

1

2

3

4

5

TERMINATING!!!

Conclusion

The key takeaways from this article were:

• What is Thread?
• Ways to kill a thread in Python:
  
  • Creating an Exit_Request flag.
  • Using the Multiprocessing Module.
  • Using the trace Module.
  • Using ctypes to raise Exceptions in a thread

Please subscribe and stay tuned for more interesting articles!

References

1. https://stackoverflow.com/questions/3239...l-a-thread
2. http://net-informations.com/python/iq/kill.htm
3. https://pybay.com/site_media/slides/raym...ading.html
4. http://tomerfiliba.com/recipes/Thread2/

Where to Go From Here?

Enough theory, let’s get some practice!

To become successful in coding, you need to get out there and solve real problems for real people. That’s how you can become a six-figure earner easily. And that’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

Practice projects is how you sharpen your saw in coding!

Do you want to become a code master by focusing on practical code projects that actually earn you money and solve problems for people?

Then become a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

Join my free webinar “How to Build Your High-Income Skill Python” and watch how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!

The post How To Kill A Thread In Python? first appeared on Finxter.

© Nintendo Life

Update: Nintendo has now confirmed that the Joy-Con price drop will also come to North America. Just like Japan, the discount only applies to single Joy-Con purchases.

The single Joy-Con products below will be reduced from $49.99 to $39.99 starting from 9th November. While this is a welcome change, it’s worth noting that $39.99 is exactly half the price of a full set, so buying two individually is sadly still no cheaper than buying a pair.

At least upgrading one is a little bit cheaper now!

Original Article (Mon 12th Oct, 2020 13:30 BST): Nintendo has revealed that it will be permanently reducing the price of its Switch Joy-Con controllers in Japan, starting from next month.

From 6th November, the price of a single Joy-Con controller will be revised from 4,480 yen + tax to 3,740 yen + tax, which is a drop of about 16.5%. The price reduction will apply to single Joy-Con products only, meaning Switch owners will still pay the same, regular price for a complete pack of two (thanks, Japanese Nintendo).

Users in Japan can buy Grey, Neon Red, Neon Blue, Neon Yellow, Neon Green, Red, and Neon Pink Joy-Con from the country’s official store.

Naturally, then, we can’t help but wonder whether or not a similar pricing restructure will arrive here in the west. Could we be about to see a permanent reduction in price across Europe and the US, or will this remain a Japan-only deal? [Update: North America now confirmed – see above].

We’re sure a drop in price would be well received, especially with all of the Joy-Con drift issues we’ve been seeing, but feel free to have your say in the comments below. Do you think we’ll see a price drop soon?

There is a new Humble Bundle of interest to game developers, this one is the Ultimate Fantasy Game Development bundle. It’s a collection of fantasy themed models, full rigged, textured and animated with tons of modularity and different texture packs. Even more impressive, the package is available as keys for both Unity and Unreal Engine asset stores and the models and textures are in a format that can be used in any 3D game engine with ease. As with all Humble Bundles, this one is organized into tiers:

1$ Tier

• Plant Monster
• Rock Monster
• Mushroom Monster

15$ Tier

• Giant Worm
• Minotaur
• Mimics & Chests
• Medusa
• Locks and Lockpicks

25$ Tier

• Spiders
• Dragons
• Humans
• Armor Pack 1
• Weapons & Armor 1
• Character Accessories
• Trolls
• Demons
• Magic & Melee Sounds Library
• Devils

As with all Humble Bundles, you get to decide how your money is allocated between Humble, Charity, the publisher and if you so choose (and thanks if you do!) to support GFS purchasing through this link. You can get additional asset packs in the same art style created by Infinity PBR on the Unity Asset Store. You can learn more about the asset pack in the video below.

Honeywell to leverage Microsoft Azure cloud platform and connect Microsoft Dynamics 365 to Honeywell Forge, enabling predictive maintenance applications with closed-loop maintenance workflows in the buildings industry

CHARLOTTE, N.C., and REDMOND, Wash., October 22, 2020 — Honeywell (NYSE: HON) and Microsoft (NASDAQ: MSFT) announced today that Honeywell will bring to market its domain-specific applications built on the Microsoft cloud platform to drive new levels of productivity for industrial clients.

With the integration of the AI-driven autonomous controls of the Honeywell Forge enterprise performance management software with Microsoft Dynamics 365 Field Service, customers will be able to access operating data that includes workflow management support to improve performance and energy efficiency within the enterprise environment. Workers in the field will benefit from real-time access to critical data that will help them prioritize, analyze and solve problems more quickly.

The first area of focus will be in automating maintenance for building owners and operators. To optimize their buildings’ energy, performance and comfort, they often need to pull data from a variety of sources that are not normalized and inform remote and dispersed workforces. Facility managers must determine what problem to fix, when to fix it and who to assign to the job, which can be very difficult without having the necessary asset know-how and work order management capability.

“Honeywell’s partnership with Microsoft will deliver new value to our customers as we help them solve business challenges by digitizing their operations,” said Que Dallara, president and CEO, Honeywell Connected Enterprise. “Working with Microsoft, Honeywell will bring solutions at scale – powered by AI-driven insights and immediate access to data – that will help our customers work more efficiently than ever before.”

Honeywell Forge delivers cost savings, improved energy efficiency and a better occupant experience to customers. For example, at Crown Towers Perth in Australia, the Honeywell Forge Digitized Maintenance solution provided faster inputs on potential maintenance issues versus traditional annual maintenance schedules and helped reduce reactive work orders by 90%.

In the heating, ventilation and air conditioning (HVAC) operation alone – which is known to account for up to 60% of total energy consumption in commercial buildings* – an AI-automated account system such as Honeywell Forge Energy Optimization can save between 10% and 20% in energy costs.**

Dynamics 365 Field Service allows companies to remotely detect and address potential issues early to avoid unnecessary downtime or operational inefficiencies by analyzing IoT data and to improve proactive service offerings through AI-infused IoT alerts and work orders. Leveraging the global scale of Microsoft’s cloud will enable Honeywell to quickly bring new offerings to market while helping customers meet regional security, privacy and compliance requirements.

“To achieve resilient operations and sustainable growth, businesses need to partner to fully unlock the opportunities of cloud, AI and IoT technologies. By integrating Honeywell and Microsoft services, companies turn IoT data into critical business insights and actions to optimize operations and deliver new customer value faster,” said Judson Althoff, executive vice president, Microsoft’s Worldwide Commercial Business.

Working with Microsoft, Honeywell is already delivering the following Honeywell Forge SaaS solutions that will address what customers need now to return to work and, in the future, to operate safely and efficiently, including:

• Digitized Maintenance – Offers a panoramic view of the performance of facilities and assets using near real-time analytics. This provides important information about critical equipment issues before they become big repair or even replacement problems.
• Energy Optimization – A cloud-based, closed-loop, machine-learning solution that continuously studies a building’s HVAC energy consumption patterns and automatically adjusts to optimal energy saving settings without compromising occupant comfort levels.
• OT Cybersecurity – Honeywell Forge Cybersecurity provides continuous threat detection with minimal disruption of services. The robust software solution simplifies, strengthens and scales industrial cybersecurity operations across the enterprise.

The companies are also exploring more ways to bring innovation to customers by integrating Honeywell Forge solutions with Azure services such as Azure Digital Twins and Azure edge capabilities. Digital twins allow businesses to easily model and create digital representations of connected physical environments to deliver products that meet fast-changing market needs while saving operational costs. Using edge computing, customers can run AI, machine learning and business processes directly across plants, warehouses, machines and appliances for quicker actions without the need for a constant internet connection.

Learn more about the partnership on Honeywell.com.

About Microsoft:

Microsoft (Nasdaq “MSFT” @microsoft) enables digital transformation for the era of an intelligent cloud and an intelligent edge. Its mission is to empower every person and every organization on the planet to achieve more.

About Honeywell:

Honeywell (www.honeywell.com) is a Fortune 100 technology company that delivers industry specific solutions that include aerospace products and services; control technologies for buildings and industry; and performance materials globally. Our technologies help aircraft, buildings, manufacturing plants, supply chains, and workers become more connected to make our world smarter, safer, and more sustainable.  For more news and information on Honeywell, please visit www.honeywell.com/newsroom.

###

Contacts:

Media                                                                                      

Nati Katz                                                                                   Microsoft Media Relations

Honeywell, External Communications                                      WE Communications for Microsoft

(704) 627-6109                                                                         (425) 638-7777

Netanel.Katz@honeywell.com                                                 rrt@we-worldwide.com

Many computers use the Network Time Protocol (NTP) to synchronize their system clocks over the internet. NTP is one of the few unsecured internet protocols still in common use. An attacker that can observe network traffic between a client and server can feed the client with bogus data and, depending on the client’s implementation and configuration, force it to set its system clock to any time and date. Some programs and services might not work if the client’s system clock is not accurate. For example, a web browser will not work correctly if the web servers’ certificates appear to be expired according to the client’s system clock. Use Network Time Security (NTS) to secure NTP.

Fedora 33¹ is the first Fedora release to support NTS. NTS is a new authentication mechanism for NTP. It enables clients to verify that the packets they receive from the server have not been modified while in transit. The only thing an attacker can do when NTS is enabled is drop or delay packets. See RFC8915 for further details about NTS.

NTP can be secured well with symmetric keys. Unfortunately, the server has to have a different key for each client and the keys have to be securely distributed. That might be practical with a private server on a local network, but it does not scale to a public server with millions of clients.

NTS includes a Key Establishment (NTS-KE) protocol that automatically creates the encryption keys used between the server and its clients. It uses Transport Layer Security (TLS) on TCP port 4460. It is designed to scale to very large numbers of clients with a minimal impact on accuracy. The server does not need to keep any client-specific state. It provides clients with cookies, which are encrypted and contain the keys needed to authenticate the NTP packets. Privacy is one of the goals of NTS. The client gets a new cookie with each server response, so it doesn’t have to reuse cookies. This prevents passive observers from tracking clients migrating between networks.

The default NTP client in Fedora is chrony. Chrony added NTS support in version 4.0. The default configuration hasn’t changed. Chrony still uses public servers from the pool.ntp.org project and NTS is not enabled by default.

Currently, there are very few public NTP servers that support NTS. The two major providers are Cloudflare and Netnod. The Cloudflare servers are in various places around the world. They use anycast addresses that should allow most clients to reach a close server. The Netnod servers are located in Sweden. In the future we will probably see more public NTP servers with NTS support.

A general recommendation for configuring NTP clients for best reliability is to have at least three working servers. For best accuracy, it is recommended to select close servers to minimize network latency and asymmetry caused by asymmetric network routing. If you are not concerned about fine-grained accuracy, you can ignore this recommendation and use any NTS servers you trust, no matter where they are located.

If you do want high accuracy, but you don’t have a close NTS server, you can mix distant NTS servers with closer non-NTS servers. However, such a configuration is less secure than a configuration using NTS servers only. The attackers still cannot force the client to accept arbitrary time, but they do have a greater control over the client’s clock and its estimate of accuracy, which may be unacceptable in some environments.

Enable client NTS in the installer

When installing Fedora 33, you can enable NTS in the Time & Date dialog in the Network Time configuration. Enter the name of the server and check the NTS support before clicking the + (Add) button. You can add one or more servers or pools with NTS. To remove the default pool of servers (2.fedora.pool.ntp.org), uncheck the corresponding mark in the Use column.

Enable client NTS in the configuration file

If you upgraded from a previous Fedora release, or you didn’t enable NTS in the installer, you can enable NTS directly in /etc/chrony.conf. Specify the server with the nts option in addition to the recommended iburst option. For example:

server time.cloudflare.com iburst nts

server nts.sth1.ntp.se iburst nts

server nts.sth2.ntp.se iburst nts

You should also allow the client to save the NTS keys and cookies to disk,
so it doesn’t have to repeat the NTS-KE session on each start. Add the
following line to chrony.conf, if it is not already present:

ntsdumpdir /var/lib/chrony

If you don’t want NTP servers provided by DHCP to be mixed with the servers you
have specified, remove or comment out the following line in
chrony.conf:

sourcedir /run/chrony-dhcp

After you have finished editing chrony.conf, save your changes and restart the chronyd service:

systemctl restart chronyd

Check client status

Run the following command under the root user to check whether the NTS key
establishment was successful:

# chronyc -N authdata

Name/IP address Mode KeyID Type KLen Last Atmp NAK Cook CLen

=========================================================================

time.cloudflare.com NTS 1 15 256 33m 0 0 8 100

nts.sth1.ntp.se NTS 1 15 256 33m 0 0 8 100

nts.sth2.ntp.se NTS 1 15 256 33m 0 0 8 100

The KeyID, Type, and KLen columns should have non-zero values. If they are zero, check the system log for error messages from chronyd. One possible cause of failure is a firewall is blocking the client’s connection to the server’s TCP port ( port 4460).

Another possible cause of failure is a certificate that is failing to verify because the client’s clock is wrong. This is a chicken-or-the-egg type problem with NTS. You may need to manually correct the date or temporarily disable NTS in order to get NTS working. If your computer has a real-time clock, as almost all computers do, and it’s backed up by a good battery, this operation should be needed only once.

If the computer doesn’t have a real-time clock or battery, as is common with
some small ARM computers like the Raspberry Pi, you can add the -s
option to /etc/sysconfig/chronyd to restore time saved on the last
shutdown or reboot. The clock will be behind the true time, but if the
computer wasn’t shut down for too long and the server’s certificates were not
renewed too close to their expiration, it should be sufficient for the time
checks to succeed. As a last resort, you can disable the time checks with the
nocerttimecheck directive. See the chrony.conf(5) man page
for details.

Run the following command to confirm that the client is making NTP
measurements:

# chronyc -N sources

MS Name/IP address Stratum Poll Reach LastRx Last sample ===============================================================================

^* time.cloudflare.com 3 6 377 45 +355us[ +375us] +/- 11ms

^+ nts.sth1.ntp.se 1 6 377 44 +237us[ +237us] +/- 23ms

^+ nts.sth2.ntp.se 1 6 377 44 -170us[ -170us] +/- 22ms

The Reach column should have a non-zero value; ideally 377. The value 377 shown above is an octal number. It indicates that the last eight requests all had a valid response. The validation check will include NTS authentication if enabled. If the value only rarely or never gets to 377, it indicates that NTP requests or responses are getting lost in the network. Some major network operators are known to have middleboxes that block or limit rate of large NTP packets as a mitigation for amplification attacks that exploit the monitoring protocol of ntpd. Unfortunately, this impacts NTS-protected NTP packets, even though they don’t cause any amplification. The NTP working group is considering an alternative port for NTP as a workaround for this issue.

Enable NTS on the server

If you have your own NTP server running chronyd, you can enable server NTS support to allow its clients to be synchronized securely. If the server is a client of other servers, it should use NTS or a symmetric key for its own synchronization. The clients assume the synchronization chain is secured between all servers up to the primary time servers.

Enabling server NTS is similar to enabling HTTPS on a web server. You just need a private key and certificate. The certificate could be signed by the Let’s Encrypt authority using the certbot tool, for example. When you have the key and certificate file (including intermediate certificates), specify them in chrony.conf with the following directives:

ntsserverkey /etc/pki/tls/private/foo.example.net.key

ntsservercert /etc/pki/tls/certs/foo.example.net.crt

Make sure the ntsdumpdir directive mentioned previously in the
client configuration is present in chrony.conf. It allows the server
to save its keys to disk, so the clients of the server don’t have to get new
keys and cookies when the server is restarted.

Restart the chronyd service:

systemctl restart chronyd

If there are no error messages in the system log from chronyd, it should be
accepting client connections. If the server has a firewall, it needs to allow
both the UDP 123 and TCP 4460 ports for NTP and NTS-KE respectively.

You can perform a quick test from a client machine with the following command:

$ chronyd -Q -t 3 'server foo.example.net iburst nts maxsamples 1'

2020-10-13T12:00:52Z chronyd version 4.0 starting (+CMDMON +NTP +REFCLOCK +RTC +PRIVDROP +SCFILTER +SIGND +ASYNCDNS +NTS +SECHASH +IPV6 +DEBUG)

2020-10-13T12:00:52Z Disabled control of system clock

2020-10-13T12:00:55Z System clock wrong by -0.001032 seconds (ignored)

2020-10-13T12:00:55Z chronyd exiting

If you see a System clock wrong message, it’s working
correctly.

On the server, you can use the following command to check how many NTS-KE
connections and authenticated NTP packets it has handled:

# chronyc serverstats

NTP packets received : 2143106240

NTP packets dropped : 117180834

Command packets received : 16819527

Command packets dropped : 0

Client log records dropped : 574257223

NTS-KE connections accepted: 104

NTS-KE connections dropped : 0

Authenticated NTP packets : 52139

If you see non-zero NTS-KE connections accepted and Authenticated
NTP packets, it means at least some clients were able to connect to the
NTS-KE port and send an authenticated NTP request.

— Cover photo by Louis. K on Unsplash —

1. The Fedora 33 Beta installer contains an older chrony prerelease which doesn’t work with current NTS servers because the NTS-KE port has changed. Consequently, in the Network Time configuration in the installer, the servers will always appear as not working. After installation, the chrony package needs to be updated before it will work with current servers.

Expensive-but-fantastic statue maker First 4 Figures has shared an unboxing video of its delightful Varia Suit Samus figure.

Available as a standard edition or a super fancy Exclusive edition that includes LED lights, the figure has entered its ‘last chance to pre-order’ stage on First 4 Figures’ website. The standard model costs US$533.99, with the Exclusive model setting you back US$587.99.

The figure shows Samus in her Varia Suit as it was seen in Metroid Prime 2: Echoes:

First 4 Figures is proud to showcase Samus in the Varia Suit. Instantly recognisable from games as far back as the original Metroid game on the NES, the Varia Suit has remained a series mainstay, and is here depicted as it was seen during Metroid Prime 2: Echoes. Captured in a stunning ¼ scale in hand painted polystone, Samus measures an awesome 20 inches tall, standing upon a base inspired by the series insignia.

It’s actually the second in the company’s series of Metroid Master Arts statues; a few years ago, fans were also treated to an equally delicious Light Suit variant.

Watching that unboxing video, we were already getting excited just seeing that Metroid logo base. It’s not easy to justify spending that kind of cash, but these figures sure are wonderful.

Please note that some external links on this page are affiliate links, which means if you click them and make a purchase we may receive a small percentage of the sale. Please read our FTC Disclosure for more information.