A really simple, non-preemptive task scheduler.

• Introduction
• How it works
• About the demo

This is a super simple, non-preemptive, task scheduler. This demo project was made in Atmel Studio 7 for ATmega48P microcontroller, but can be ported easily.
The point of this scheduler is to call and execute every task with a selected periodicity.

The scheduler is inside the OS folder (OS.c and OS.h). Although it isn’t an operating system I still call it OS, because the naming is easier this way (OS is shorter, than Scheduler, duh).
There are three main, important functions:

• OS_TaskCreate() is the function, that registers the tasks. The inputs are the task’s function, the task’s burst time (the time you want to call it periodically) and the task’s default state for special needs.
  
  Figure 1. Activity diagram of OS_TaskCreate().

There are three states:

• BLOCKED: waits for a call from timer

• READY: ready for execution

• SUSPENDED: disabled, won’t do anything
  
  Figure 2. State diagram of the tasks.

• OS_TaskTimer() is the function, that organizes the tasks. It should be in a timer interrupt (in the demo it is a 1 sec timer, but can be anything). There is a counter inside the function. If the counter is bigger, then the task’s burst time, it puts it into READY state.
  
  Figure 3. Activity diagram of OS_TaskTimer().

• OS_TaskExecution() is the function, that calls the tasks. It should be in the main() infinite loop. It checks if there are any READY tasks, and then executes them in a FIFO style. It is worth to mention that because of this, it is just soft real time. If you choose the timings wrong, then there might be too many tasks in READY state and unwanted delays might happen.
  
  Figure 4. Activity diagram of OS_TaskExecution().

The demo is intended to demonstrate how the scheduler works. There are three tasks and each task blinks a LED (on port D 0,1,2) with 1, 2 and 5 seconds. The second task starts in SUSPENDED state, so it never gets executed.

Open-source, end-to-end encrypted tool to manage secrets and configs across your team and infrastructure.

This is now considered a legacy SDK, as we have released a new SDK that will be receiving all future updates. You can find it here.

• Links
• Basic Usage
• Secrets
  • Get Secrets
  • Get Secret
  • Create Secret
  • Update Secret
  • Delete Secret
• Cryptography
  • Create Symmetric Key
  • Encrypt Symmetric
  • Decrypt Symmetric

• Infisical

import express from "express";
import InfisicalClient from "infisical-node";
const app = express();
const PORT = 3000;

const client = new InfisicalClient({
    token: "YOUR_INFISICAL_TOKEN"
});

app.get("https://github.com/", async (req, res) => {
    // access value
    const name = await client.getSecret("NAME", {
        environment: "dev",
        path: "https://github.com/",
        type: "shared"
    });
    res.send(`Hello! My name is: ${name.secretValue}`);
});

app.listen(PORT, async () => {
    // initialize client
    console.log(`App listening on port ${port}`);
});

This example demonstrates how to use the Infisical Node SDK with an Express application. The application retrieves a secret named “NAME” and responds to requests with a greeting that includes the secret value.

It is also possible to use the SDK to encrypt/decrypt text; the implementation uses aes-256-gcm with components of the encryption/decryption encoded in base64.

import InfisicalClient from "infisical-node";
const client = new InfisicalClient();

// some plaintext you want to encrypt
const plaintext = "The quick brown fox jumps over the lazy dog";

// create a base64-encoded, 256-bit symmetric key
const key = client.createSymmetricKey();

// encrypt
const { ciphertext, iv, tag } = client.encryptSymmetric(plaintext, key);

// decrypt
const cleartext = client.decryptSymmetric(ciphertext, key, iv, tag);

$ npm install infisical-node

Import the SDK and create a client instance with your Infisical Token.

const InfisicalClient = require("infisical-node");

const client = new InfisicalClient({
    token: "your_infisical_token"
});

Using ES6:

import InfisicalClient from "infisical-node";

const client = new InfisicalClient({
    token: "your_infisical_token"
});

// your app logic

Using Infisical Token V3 (Beta):

In v1.4.0, we released a superior token authentication method; this credential is a JSON containing a publicKey, privateKey, and serviceToken and can be used to initialize the Node SDK client instead of the regular service token.

You can use this beta feature like so:

const InfisicalClient = require("infisical-node");

const client = new InfisicalClient({
    tokenJson: "your_infisical_token_v3_json"
});

The SDK caches every secret and updates it periodically based on the provided cacheTTL. For example, if cacheTTL of 300 is provided, then a secret will be refetched 5 minutes after the first fetch; if the fetch fails, the cached secret is returned.

const secrets = await client.getAllSecrets({
    environment: "dev",
    path: "/foo/bar/",
    attachToProcessEnv: false,
    includeImports: false
});

Retrieve all secrets within a given environment and folder path. The service token used must have access to the given path and environment.

• options (object)
  • environment The slug name (dev, prod, etc) of the environment from where secrets should be fetched from
  • path The path from where secrets should be fetched from
  • attachToProcessEnv (boolean, optional): Whether or not to attach fetched secrets to process.env. If not specified, the default value is false.
  • includeImports (boolean, optional): Whether or not to include imported secrets from the current path. Read about secret import.

Retrieve a secret from Infisical:

const secret = await client.getSecret("API_KEY", {
    environment: "dev",
    path: "https://github.com/",
    type: "shared"
});
const value = secret.secretValue; // get its value

By default, getSecret() fetches and returns a personal secret. If not found, it returns a shared secret, or tries to retrieve the value from process.env. If a secret is fetched, getSecret() caches it to reduce excessive calls and re-fetches periodically based on the cacheTTL option (default is 300 seconds) when initializing the client — for more information, see the caching section.

To explicitly retrieve a shared secret:

const secret = await client.getSecret("API_KEY", {
    environment: "dev",
    path: "https://github.com/",
    type: "shared"
});
const value = secret.secretValue; // get its value

• secretName (string): The key of the secret to retrieve.
• options (object, optional): An options object to speify the type of secret.
  • environment The slug name (dev, prod, etc) of the environment from where secrets should be fetched from
  • path The path from where secrets should be fetched from
  • type (string, optional): The type of the secret. Valid options are “shared” or “personal”. If not specified, the default value is “personal”.

Create a new secret in Infisical:

const newApiKey = await client.createSecret("API_KEY", "FOO", {
    environment: "dev",
    path: "https://github.com/",
    type: "shared"
});

• secretName (string): The key of the secret to create.
• secretValue (string): The value of the secret.
• options (object, optional): An options object to specify the type of secret.
  • environment The slug name (dev, prod, etc) of the environment where secret should be created
  • path The path from where secret should be created.
  • type (string, optional): The type of the secret. Valid options are “shared” or “personal”. If not specified, the default value is “shared”. A personal secret can only be created if a shared secret with the same name exists.

Update an existing secret in Infisical:

const updatedApiKey = await client.updateSecret("API_KEY", "BAR", {
    environment: "dev",
    path: "https://github.com/",
    type: "shared"
});

• secretName (string): The key of the secret to update.
• secretValue (string): The new value of the secret.
• options (object, optional): An options object to specify the type of secret.
  • environment The slug name (dev, prod, etc) of the environment where secret should be updated.
  • path The path from where secret should be updated.
  • type (string, optional): The type of the secret. Valid options are “shared” or “personal”. If not specified, the default value is “shared”.

Delete a secret in Infisical:

const deletedSecret = await client.deleteSecret("API_KEY", {
    environment: "dev",
    path: "https://github.com/",
    type: "shared"
});

• secretName (string): The key of the secret to delete.
• options (object, optional): An options object to specify the type of secret to delete.
  • environment The slug name (dev, prod, etc) of the environment where secret should be deleted.
  • path The path from where secret should be deleted.
  • type (string, optional): The type of the secret. Valid options are “shared” or “personal”. If not specified, the default value is “shared”. Note that deleting a shared secret also deletes all associated personal secrets.

Create a base64-encoded, 256-bit symmetric key to be used for encryption/decryption.

const key = client.createSymmetricKey();

key (string): A base64-encoded, 256-bit symmetric key.

Encrypt plaintext -> ciphertext.

const { ciphertext, iv, tag } = client.encryptSymmetric(plaintext, key);

• plaintext (string): The plaintext to encrypt.
• key (string): The base64-encoded, 256-bit symmetric key to use to encrypt the plaintext.

An object containing the following properties:

• ciphertext (string): The base64-encoded, encrypted plaintext.
• iv (string): The base64-encoded, 96-bit initialization vector generated for the encryption.
• tag (string): The base64-encoded authentication tag generated during the encryption.

Decrypt ciphertext -> plaintext/cleartext.

const cleartext = client.decryptSymmetric(ciphertext, key, iv, tag);

• ciphertext (string): The ciphertext to decrypt.
• key (string): The base64-encoded, 256-bit symmetric key to use to decrypt the ciphertext.
• iv (string): The base64-encoded, 96-bit initiatlization vector generated for the encryption.
• tag (string): The base64-encoded authentication tag generated during encryption.

cleartext (string): The decrypted encryption that is the cleartext/plaintext.

Bug fixes, docs, and library improvements are always welcome. Please refer to our Contributing Guide for detailed information on how you can contribute.

If you want to familiarize yourself with the SDK, you can start by forking the repository and cloning it in your local development environment. The project requires Node.js to be installed on your machine.

After cloning the repository, install the depenencies by running the following command in the directory of your cloned repository:

$ npm install

To run existing tests, you need to make a .env at the root of this project containing a INFISICAL_TOKEN and SITE_URL. This will execute the tests against a project and environment scoped to the INFISICAL_TOKEN on a running instance of Infisical at the SITE_URL (this could be Infisical Cloud).

To run all the tests you can use the following command:

$ npm test

infisical-node is distributed under the terms of the MIT license.