Assuming you've

• Create a VM and have a service running on a port

• Opened the port in your security list and security group

SSH to the VM

First, let's ssh to our VM. We need to save our current iptables by running below command in the SSH shell

iptables-save > current-rules.txt

After that, we need to run the below command to allow all traffic to flow.

sudo iptables -I INPUT -j ACCEPT

This will temporarily enable the flow of all traffic. Test everything and make sure it works.

After you've verified everything is fine, we need to persist this rule across reboots.

Run the below command

sudo iptables-save -f /etc/iptables/rules.v4

This will persist the rule across reboot.

Now, for any firewalling, you need to use either a security list or a security group.

Credit goes to https://stackoverflow.com/a/73400079

Happy OCI'ing

Prerequisite

• A pc/laptop with a fresh installation of proxmox

• OPNSense/PFSense ISO downloaded and uploaded to proxmox

• A switch that supports 802.1q port tagging, I used the TP-Link SG108E switch.

Making Proxmox VLAN Aware

When you set up proxmox the first time, it will automatically create a network bridge and most probably the name will be vmbr0. Go to Your Node > Networks and it will look something like below

To make your NIC VLAN award, just select the bridge vmbr0 and click edit.

Click the VLAN Aware checkbox and click ok. You will see a button "Apply Configuration", click that and wait for some time for network services to reload.

Congratulations, your proxmox can now receive and send VLAN traffic.

Creating PFSense/OPNSense VM

The next step will be to create a VM and configure network interfaces. So go ahead and create VM and once it's complete go to the hardware tab of the VM

You will see there's one network device added to it that you have selected during the creation process. Make sure this device uses vmbr0 as a bridge and there's no VLAN. We will use this device as a WAN interface for our router.

Now, click Add and select a network device

This time everything stays the same as above, the only thing that needs to change is the VLAN tag. Enter a VLAN tag (i.e. 10) that you will use for LAN traffic. It does not matter what you enter but make sure you don't enter a VLAN that switch uses as a Native VLAN ID. Click Add and you're done.

Now, complete the setup of PFSense/OPNSense. Do note that you have to assign the correct WAN and LAN interfaces or else it won't work. In my case, I saw the names vtnet0 and vtnet1 in the setup wizard. So vtnet0 became my WAN as it's the first network device in the hardware tab of the VM and vtnet1 became LAN.

Congratulation, you're almost done.

Configuring Switch

Here the steps will change depending on the switch you use. I will show you how I configured my TP-Link SG108E switch. The basic configuration will stay the same across the switch manufacturer, UI may change.

We are going to pick WAN and LAN ports on our switches. The port that connects to the proxmox machine automatically becomes the WAN port. Now it's up to you to pick LAN ports. In my case -

After you've decided on WAN and LAN ports make the below configuration to your switch

• Configure proxmox WAN and LAN to be a member of VLAN ID (i.e. which you've entered in proxmox VM above)

• Proxmox WAN port is set as TAGGED port, so it accepts LAN traffic on the above VLAN ID

• Proxmox WAN port is also part of native VLAN ID, in my case VLAN 1. Here if you have the default configuration of the switch it should work. This needs to make proxmox WAN work.

• Set LAN port Primary/Native VLAN ID to the VLAN ID you entered above. This is for the devices that do not support VLAN Tagging.

This is how it looks in my switch -

Primary/Native VLAN ID configuration -

Troubleshooting

• In case you can't access PFSense/OPNSense from LAN, make sure you've entered the correct gateway and IP address when configuring LAN. I forgot to set the gateway and it took 1 day to figure that out.

• Reboot your proxmox host after VLAN configuration if something is not working.

• Wait for some time to switch to process the configuration, for me it took a couple of seconds to re-configure the ports.

That's all. Congratulations, you've virtualized your router.

Nest.js uses CacheInterceptor to intercept our HTTP request and decide whether to cache it or not. We can create our own custom interceptor that extends default CacheInterceptor and add some logic to ignore a route.

A suggested way can be found on StackOverflow but I did not want to hard code the route paths in my interceptor.

There's another way we can do it by combining our custom CacheInterceptor and a CustomDecorator.

First, we need to create a custom cache interceptor. Note that this is slightly different from the accepted StackOverflow answer.

my-cache.interceptor.ts

import { CacheInterceptor, ExecutionContext } from '@nestjs/common';

export class MyCacheInterceptor extends CacheInterceptor {
  protected isRequestCacheable(context: ExecutionContext): boolean {
    const http = context.switchToHttp();
    const request = http.getRequest();

    const ignoreCaching: boolean = this.reflector.get(
      'ignoreCaching',
      context.getHandler(),
    );

    return !ignoreCaching || request.method === 'GET';
  }
}

Here, we're overriding a method on default interceptor isRequestCacheable which tells nest.js whether to go ahead and cache it or ignore it. In this method, we are using nest.js Reflector to get the metadata value. If metadata ignoreCaching is set to true, we tell nest.js to ignore it otherwise cache it if the request method is GET. We're going to create a custom decorator to set this metadata value.

Let's create a no-cache.decorator.ts file somewhere -

import { SetMetadata } from '@nestjs/common';

export const NoCache = () => SetMetadata('ignoreCaching', true);

We're almost done. Now let's test it. Let's use this decorator in our controller

@Controller('coupon')
export class CouponController {
  constructor(private readonly couponService: CouponService) {}

  @Get('code')
  @NoCache()
  code() {
    return this.couponService.generateCode();
  }

}

and, that's all. Now any controller which is decorated with NoCache will be ignored from caching. Pretty Neat right?

The MongoDB schema for orders collection is like this -

{
  orderNum: Number,
  scheduledAt: Date,
  services: [{
    staffId: ObjectId,
    averageTimeMinute: Number // time taken to complete the service
    // ....
  }],
  // ...
}

scheduledAt tells when is the service scheduled to be serviced to the customer. And averageTimeMinute tells the average time takes for that service. The problem here is the scheduledAt is a Date while averageTimeMinute is minutes in Number. And I needed to come up with a solution that gives us a range of time when the staff is assigned to do the service. That can be calculated using plain javascript by -

const fromTime = scheduledAt;
const endTime = new Date(scheduledAt);
endTime.setMinutes(endTime.getMinutes() + services[i].averageTimeMinute)

But the better way of doing anything like this, is with the help of MongoDB aggregations. It is very powerful to manipulate data in a way we want. If you don't know what an aggregation is, you can think of it like a pipeline where you input data from one end and it does something with data and outputs from another end.

The thing is aggregations are hard to understand and write. After hours of trial and error, I finally came up with an aggregation which will give me the desired output I need. Here it is

db.getCollection("orders").aggregate([
  { $unwind: { path: "$services" } },
  {
    $group: {
      _id: "$service.staffId",
      services: {
        $push: {
          start: "$scheduledAt",
          end: {
            $toDate: {
              $add: [
                { $toLong: "$scheduledAt" },
                { $multiply: ["$services.averageMinuteTime", 60000.0] },
              ],
            },
          },
        },
      },
    },
  },
]);

So the trick here is, since scheduledAt is a Date and averageMinuteTime is a Number, we need both of these in same unit, Number. So the first step was to convert scheduledAt to a unix timestamp and in mongo we can do like this

{ $toLong: "$scheduledAt" }

Now we have both in same type, Number, we also need to make both numbers in same type. Now scheduledAt is in miliseconds, we also need to make our averageMinuteTime into miliseconds. We can do it by multiplying by 60000. And in MongoDB we can do like this -

 { $multiply: ["$services.averageMinuteTime", 60000.0] },

Now, both our scheduledAt and averageMinuteTime is in same type and unit. Let's add both and we will get our desired endTime for the service.

$add: [
   { $toLong: "$scheduledAt" },
   { $multiply: ["$services.averageMinuteTime", 60000.0] },
],

And the last step is to convert it back to date, which in very easy to do -

$toDate: {
  $add: [
     { $toLong: "$scheduledAt" },
     { $multiply: ["$services.averageMinuteTime", 60000.0] },
  ],
},

and here it is, we got out desired output from the pipeline. Now I can render beautiful charts to see when our staffs are scheduled to work.

I hope you found this interesting. Please let me know if you have any feedback.

Thanks

In this article, we will see how easy it is to set up unit testing by creating a hello world API in node.js.

Creating a basic server

Let's create a folder and init a node.js project.

$> cd hello-world-test
$> npm init --yes

This will create a package.json file to track project dependencies.

We need to install express. If you don't know, express is a web framework. And we will use it to create our hello world API

$> npm i express

Now let's create our main entry point file. Create a file server.js

const express = require('express')
const app = express()

// start the server on port 3000
app.listen(3000)

Let's create our hello world api. Edit your server.js file to match following -

const express = require('express')
const app = express()

// hello world api
app.get('/', (req, res) => {
  res.send({ message: 'hello world' })
})

// start the server on port 3000
app.listen(3000, () => {
  console.log('server started')
})

Let's start our server and see

$> node server.js

You should see server started printed in the console. We are good to go.

Testing our API

To test our hello world API, we need to make few changes to the server.

First, let's create a new file named app.js. This file will export our express app but won't start the server. This is required for the supertest library.

app.js

const express = require('express')
const app = express()

// hello world api
app.get('/', (req, res) => {
  res.send({ message: 'hello world' })
})

// export our express app
module.exports = app;

and let's modify our server.js file to use the express app instance from app.js.

server.js

const app = require('./app');
// start the server on port 3000
app.listen(3000, () => {
  console.log('server started')
})

Now we're ready to set up our API testing. We need our testing and assertion libraries.

Let's install

$> npm install -D jest supertest

Let's create a folder tests and create a file hello-world.spec.ts, and add the following.

const request = require('supertest');
const app = require("../app");


describe("test hello-world", () => {
  it("should return hello world", (done) => {
    request(app)
      .get("/")
      .expect("Content-Type", /json/)
      .expect(200)
      .then((response) => {
        expect(response.body.message).toBe("hello world");
        done();
      })
      .catch((e) => done(e));
  });
});

Finally, let's run our test and see it passing -

$> npx jest

If everything worked as expected, you should see below.

 PASS  tests/hello-world.spec.js
  test hello-world
    ✓ should return hello world (18 ms)

Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        0.872 s, estimated 1 s
Ran all test suites.

This means we have created an endpoint and ran a test to verify the response of the endpoint.

If you are still struggling you can see and compare your code from the source code found here.

And you can also connect me on Twitter.

I hope you find this article helpful. Let me know your suggestions in the comment.