Server virtualization solution like LXC/LXD gives you a great way to easily provision high performance, secure, SEO friendly WordPress websites.

So, you have your shining, ticketing, tomato-shaped timer on your desk and you are a proud practitioner of the Pomodoro Technique®. I've got bad news and good news. The bad news is the Pomodoro Technique® can seriously damage your team's productivity. The good news is that it's very likely that you are not practicing the…

a simple INFORMATION_SCHEMA query to find largest MySQL tables

Blackbox tool to disable SSL certificate validation - including certificate pinning - within iOS and macOS applications. - nabla-c0d3/ssl-kill-switch2

I had long been aware of the [effort of cznic](https://gitlab.com/cznic/sqlite) to automatically translate the C source of SQLite to Go while avoiding the complexity CGo would introduce. SQLite was always meant to be a database you embed into your application, and I was curious what tradeoffs that meant, if any, and just generally how it differed from the usual suspects (PostgreSQL, etc.). To explore these trade-offs and differences, I decided to dive deeper into the usage of this library. SQLite is a single-writer multiple-reader database. Using just a single instance of database/sql.DB will not work well with this, because it will make it hard to avoid receiving SQLITE_BUSY errors when multiple writers try to run at the same time (because sql.DB is a connection pool). So we will need to separate readers from writers by making two instances of database/sql.DB and limiting the writer to a single [MaxOpenConn](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns) and the reader to as many as you require. So far, SQLite is behaving remarkably like other databases apart from the single-writer gotcha; we still have connections and per-connection settings. The usual way to pass these settings is usually in the DSN you pass to [sql.Open](https://pkg.go.dev/database/sql#Open) and this is [definitely possible](https://pkg.go.dev/modernc.org/sqlite#Driver.Open), but I find that it would be more straightforward if I could just run my custom SQL when a new connection is made[1]. We can do that with [sqlite.RegisterConnectionHook](https://pkg.go.dev/modernc.org/sqlite#RegisterConnectionHook). Now the question is what settings to use, because [there are quite a few of them](https://www.sqlite.org/pragma.html). These are the ones I am using personally: - `PRAGMA journal_mode = WAL;` Use write-ahead-logging. Better concurrency, but with an edge-case: with heavy writers, the wal can grow idefinitely ([see for more](https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md)). I don't expect this will happen in my use-case. For a good description on the various jornal modes, [see this blogpost](https://www.mycelial.com/learn/sqlite-journal-mode-options). - `PRAGMA synchronous = NORMAL;` Since with the WAL journal mode, this is safe, there is no reason to use FULL. - `PRAGMA temp_store = MEMORY;` Let's store temporary indices, tables, etc. in memory, my use-case is not very resource-constrained to require using the filesystem (also, [this is a fun read](https://www.sqlite.org/fasterthanfs.html) if we are talking about additional syscalls to the kernel) - `PRAGMA mmap_size = 30000000000; -- 30GB` Just making sure, access to my database is always done with memory-mapped I/O. - `PRAGMA busy_timeout = 5000;` How much time to wait in milliseconds after which SQLITE_BUSY is returned when waiting for the db to unlock. - `PRAGMA automatic_index = true;` Make sure [automatic indexing](https://www.sqlite.org/optoverview.html#autoindex) is enabled, it can only help, and is a great way to get warnings about indexes that should be created. - `PRAGMA foreign_keys = ON;` Make sure foreign key enforcement is enabled. - `PRAGMA analysis_limit = 1000;` Make sure [ANALYZE](https://www.sqlite.org/lang_analyze.html#approx) returns quickly in case the DB gets large. - `PRAGMA trusted_schema = OFF;` No idea what security audited functions are, but this setting makes sure only those can be run. The manual page tells me to turn it off anyway, so let's do that. Not all of these settings are per-connection settings, but it doesn't hurt to always run all of these on every connection, and having a single "Init SQL" makes things simpler. Let's deal with explicit transactions next. The default transaction mode is DEFERRED, meaning that it depends on the next statement what type of transaction is started (if a SELECT statement comes first, a read transaction is started, with the possibility of upgrading it to a write transaction depending on the statements that follow). With our setup, there should never be multiple writers concurrently, so making all transactions write transactions from the get-go (with BEGIN IMMEDIATE) can only help us show if this invariant is violated. Putting this all together, this is the code we arrive at: ```go package main import ( "bytes" "context" "crypto/sha1" "database/sql" "database/sql/driver" "encoding/hex" "fmt" "time" "modernc.org/sqlite" ) type DB struct { dbPath string Read *sql.DB Write *sql.DB } const initSQL = ` PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL; PRAGMA temp_store = MEMORY; PRAGMA mmap_size = 30000000000; -- 30GB PRAGMA busy_timeout = 5000; PRAGMA automatic_index = true; PRAGMA foreign_keys = ON; PRAGMA analysis_limit = 1000; PRAGMA trusted_schema = OFF; ` func New(ctx context.Context, dbPath string) (db *DB, err error) { db = &DB{ dbPath: dbPath, } // make sure every opened connection has the settings we expect sqlite.RegisterConnectionHook(func(conn sqlite.ExecQuerierContext, _ string) error { _, err = conn.ExecContext(ctx, initSQL, nil) return err }) write, err := sql.Open("sqlite", "file:"+db.dbPath) if err != nil { return } // only a single writer ever, no concurrency write.SetMaxOpenConns(1) write.SetConnMaxIdleTime(time.Minute) if err != nil { return } read, err := sql.Open("sqlite", "file:"+db.dbPath) if err != nil { return } // readers can be concurrent read.SetMaxOpenConns(100) read.SetConnMaxIdleTime(time.Minute) db.Read = read db.Write = write return } func (db *DB) InTransaction(ctx context.Context, tx func(context.Context, *sql.Conn) error) (err error) { // cancel anything that takes longer than 5 seconds var cancel func() ctx, cancel = context.WithTimeout(ctx, time.Duration(5*time.Second)) defer cancel() // separate conn thats just for us // so that the transactions queries are executed together conn, err := db.Write.Conn(ctx) if err != nil { return } defer conn.Close() _, err = conn.ExecContext(ctx, "BEGIN IMMEDIATE TRANSACTION") if err != nil { return } defer func() { if r := recover(); r != nil || err != nil { if _, err = conn.ExecContext(ctx, "ROLLBACK"); err != nil { return } } }() err = tx(ctx, conn) if err != nil { return } _, err = conn.ExecContext(ctx, "COMMIT") return } ``` Just as a small added bonus, it's also very easy to register our own go functions that we can then call from SQL. In this example, we define the sha1 function, receiving and returning a single argument, and always returning the same output for the same input (thus the deterministic). For more information, [see the docs](https://www.sqlite.org/appfunc.html) ```go func registerFuncs() { // lets add our own sha1 hash function usable from SQL sqlite.MustRegisterDeterministicScalarFunction( "sha1", 1, func(ctx *sqlite.FunctionContext, args []driver.Value) (driver.Value, error) { var arg *bytes.Buffer switch argTyped := args[0].(type) { case string: arg = bytes.NewBuffer([]byte(argTyped)) case []byte: arg = bytes.NewBuffer(argTyped) default: return nil, fmt.Errorf("expected argument to be a string, got: %T", argTyped) } h := sha1.Sum(arg.Bytes()) return hex.EncodeToString(h), nil }, ) } ``` In conclusion, this solution works perfectly well for most of the usage scenarios out there where immense scaling is neither expected nor needed. There are faster ways to use SQLite with Go (see the [excellent cvilsmeier benchmarks](https://github.com/cvilsmeier/go-sqlite-bench)), but its still plenty-fast enough, and avoiding CGo makes it very convenient also. [1]: This is another thing that database/sql.DB being a connection pool makes harder.

RMTT serves small and medium business with all technology related needs—a one stop shop for IT needs. We are a growing company with a relaxed work environment that encourages implementation of new technology and creativity. We've been successful because we encourage and appreciate customer service and being nice to people. Apply Online

This page may contain affiliate links. As an Amazon Affiliate, I earn on qualifying purchases. Please see our disclaimer for more information. Welcome back to Simple Lives Thursday! Each week we enjoy reading through all of the wonderful tips, ideas and recipes for simple living.  If you are new here, Hello! And enjoy the Simple […]

Yubikeys are great for security, but their benefits decrease somewhat when you leave them in your computer unattended. I also have login passwords that are way too long. How to solve these problems? Use a Yubikey to unlock your computer!

Look no further. This is it.

Given that the SIP credentials passed by Asterisks real-time backends are stored as either MD5 or plain-text It's best that we think about securing the communication over TLS. Modify the pjsip.conf to point to your certificates. I got mine using certbot and Lets Encrypt, then copied them into the etc/asterisk/keys folder as this seems to…

Software Engineering Manager interested in all kinds of development related topics. Strong focus on automating workflows and lean development processes. - memoryleak

  In 1964, Stanley Kubrick wrote to Arthur C. Clarke.  He told the science fiction author he was a “a great admirer” of his books, and “had always wanted to discuss with [him] the possibility of doing the proverbial really good science-fiction movie.” Kubrick briefly outlined his ideas: My main interest lies along these broad areas, naturally assuming great plot and character: The reasons for believing in the existence of intelligent extra-terrestrial life. The impact (and perhaps even lack of impact in some quarters) such discovery would have on Earth in the near future. A space probe with a landing...

Are you going in production with Galera Cluster for MySQL? Here are 9 tips to consider before going live. These are applicable to all 3 Galera versions (Codership, Percona XtraDB Cluster and MariaDB Galera Cluster).

I periodically post various thoughts, tips, and frustrations with software. My writing style has changed over time, for the better I believe, so please forgive my younger self. Frequently the topics are related to errors that may no longer be present in the software that provoked my ire so I recommend double checking the content with official documentation where possible.

A map of recent contributions to Wikipedia from unregistered users.

Ndume always keeps a protective eye out for Koko, especially when they"re in the yard together. Here, he stands guard while Koko looks for food.

I’m using Xubuntu 12.04.03 32bit

An elegant and modern git repository viewer. Contribute to klaussilveira/gitlist development by creating an account on GitHub.

Meaning is not found, but made.

So, thanks to everyone!! Was an issue related to the specific IP. In love with Pfsense again :)

Headless browsers are currently gaining popularity as an efficient way to test web applications because they do not affect the user interface. In this post, I am going to discuss the benefits of Headless Chrome and two approaches for using Headless Chrome to automatically create PDF reports.  What is Headless Chrome? Headless Chrome is a…

Departments Plugin for Redmine. Contribute to peelman/redmine_departments development by creating an account on GitHub.

Postfix is an MTA (Mail Transfer Agent), an application used to send and receive email. In this tutorial, we will install and configure Postfix so that it ca…

USB WiFi Adapter Information for Linux. Contribute to morrownr/USB-WiFi development by creating an account on GitHub.

Enhanced and security-focused fork of Signal. Contribute to mollyim/mollyim-android development by creating an account on GitHub.

Contribute to evolvingweb/redmine_slack development by creating an account on GitHub.

High-def online color ascii art generator! Easily convert pictures to text art and share easier than ever! Supports many character sets...

This project lets you use a PyPortal to control a Roku media device

United States or Remote

Keybase is for keeping everyone's chats and files safe, from families to communities to companies. MacOS, Windows, Linux, iPhone, and Android.

All of this was prior to the latest versions of Security Onion which now run inside docker instances. I’ve not yet looked to see how this would be replicated there. But I’m leaving this up for historical purposes. Another tool in the arsenal of Security Onion is OSSEC, a “scalable, multi-platform, open source Host-based Intrusion Detection System (HIDS).” OSSEC examines log and alert events and correlates them against pre-built (or custom) rules and sends alerts as configured. When installed on the Security Onion server, OSSEC alerts are logged in the sguil database and managed alongside alerts from the network IDS.

Update: 2016-02-06. New greatly updated tutorial in new post with NodeMCU dev board and ArduinoIDE. A lot simpler approach. Update: 2015-04-11. Update with deep sleep now in new post. Testing the battery operation time in progress. Update: 2015-03-18. Updated the connection drawing with upda

Network/Application security specialist | Open Source contributor | @nmap NSE developer | websec.mx & websec.ca | @pwnlabmx - cldrn

Ok, now on Insider builds you can't get it past anymore by killing OOBE Connection Flow. This is just nonsense. How are we supposed to set up PCs that don't have any Wi-Fi/Ethernet drivers in the first place? When killing Connection Flow you just get…

Auf YouTube findest du die angesagtesten Videos und Tracks. Außerdem kannst du eigene Inhalte hochladen und mit Freunden oder gleich der ganzen Welt teilen.

Web interface to manage multiple instance of lxd. Contribute to turtle0x1/LxdMosaic development by creating an account on GitHub.

Drop a LAN Turtle. Get a Shell. The LAN Turtle is a covert Systems Administration and Penetration Testing tool providing stealth remote access, network intelligence gathering, and man-in-the-middle surveillance capabilities through a simple graphic shell. Housed within a generic "USB Ethernet Adapter" case, the LAN Tur

Presidential candidate's email server wasn't very private after all ...