toksdotdev

{
  "$schema": "https://zed.dev/schema/themes/v0.1.0.json",
  "name": "Vesper",
  "author": "Rauno Freiberg",
  "themes": [
    {
      "name": "Vesper",
      "appearance": "dark",
      "style": {
        "border": "#101010",

toksdotdev

use super::RoundRobinStrategy;
use crate::balancer::StrategyProducer;
use crate::Target;
use futures::future::abortable;
use futures::stream::AbortHandle;
use futures::stream::Abortable;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering;
use std::sync::Arc;

toksdotdev

Someone asked a question some weeks back about why size_of::<Option<T>> is always double. Answer is because of alignment.

Explanation

How are Rust enum represented in C?

C doesn't have the ability to directly represent complex Rust enum, hence, the need for a workaround. To understand that, let's take a look at how Option<i32> is represnted in C.

E.g. Given:

toksdotdev

/// Perform assertion on a location span type.
macro_rules! assert_span {
    ($actual: expr, line = $value: expr) => {
        assert_eq!($actual.location_line(), $value);
    };
    ($actual: expr, fragment = $value: expr) => {
        assert_eq!(*$actual.fragment(), $value);
    };
    ($actual: expr, column = $value: expr) => {
        assert_eq!($actual.get_column(), $value);

toksdotdev

use std::future::Future;

use actix_rt::Runtime;

/// Runs the provided future, blocking the current thread until the future completes.
///
/// A good use case for this would be initialising
pub fn run_sync<F>(future: F) -> F::Output
where
    F: Future,

toksdotdev

# Scale deployments
DEPLOYMENT=traefik
NAMESPACE=kube-system

kubectl scale deploy $DEPLOYMENT --replicas=0 -n $NAMESPACE


# Fetch k8s secret for any namespace (you must be authorized to fetch the secet)
SERVICE_NAME=whoami
NAMESPACE=kube-system

toksdotdev

• What do Etcd, Consul, and Zookeeper do?
  • Service Registration:
    • Host, port number, and sometimes authentication credentials, protocols, versions numbers, and/or environment details.
  • Service Discovery:
    • Ability for client application to query the central registry to learn of service location.
  • Consistent and durable general-purpose K/V store across distributed system.
    • Some solutions support this better than others.
    • Based on Paxos or some derivative (i.e. Raft) algorithm to quickly converge to a consistent state.
• Centralized locking can be based on this K/V store.

toksdotdev

NAMESPACE=production
POD_LABEL=app=core-service
HOST_PORT=8080
APP_PORT=3333

kubectl port-forward --namespace $NAMESPACE \
  $(
    kubectl get pod \
    --namespace $NAMESPACE \
    --selector="$POD_LABEL" \

toksdotdev

PROJECT_ID=boringcompany
GCLOUD_K8_ZONE=us-central1-c
GCLOUD_K8_CLUSTER=production

gcloud auth login
gcloud auth configure-docker
gcloud config set project $PROJECT_ID
gcloud container clusters get-credentials $GCLOUD_K8_CLUSTER --zone $GCLOUD_K8_ZONE --project $PROJECT_ID

toksdotdev

const Bull = use("Rocketseat/Bull");
const moment = require("moment");
const Redis = use("Redis");

/**
 * Prepare queue configuration. Options provided overrides
 * the field value of the default configuration.
 *
 * @param {object} [options]
 */