DEV Community: Abhay Kochar

How to run WGET in background on logout

Abhay Kochar — Wed, 16 Sep 2020 10:42:43 +0000

When transfer large files from one server to another we usually use WGET command to download it, but when network speed is slow on specific server it gets stopped on logging out.

wget http://path-to-url/file.zip

-b : Go to background
-q : Turn off wget’s output aka save disk space.
-c : Resume broken download i.e. continue getting a partially-downloaded file

wget -bqc http://path-to-url/file.zip

Nohup command

Nohup prevents the processes or jobs from receiving the SIGHUP (Signal Hang UP) signal. This is a signal that is sent to a process upon closing or exiting the terminal.

nohup wget -qc http://path-to-url/file.zip &

Create REST API with MySQL using DENO secured Javascript Lib

Abhay Kochar — Wed, 10 Jun 2020 04:26:57 +0000

Deno is a Secure Runtime for Javascript and TypeScript

In this tutorial we will learn how to do

Deno Installation
Running HTTP Server on Deno
Routing using Oak Middleware
How to connect to MySQL Database
REST API with Database Connection

If you prefer YouTube :

1. Deno Installation

Deno ships as a single executable and doesn’t require any dependencies.

We will install it using these shell commands, which can be found on https://deno.land

Run following command on terminal
Shell (Mac, Linux):

$ curl -fsSL https://deno.land/x/install/install.sh | sh

PowerShell (Windows):

> iwr https://deno.land/x/install/install.ps1 -useb | iex

You can verify if deno installed correctly or not using following command

deno -V

If you have deno already installed you can upgrade that using

deno upgrade

Now lets install Deno Extension for VScode.

You can browse and install extensions from within VS Code. Bring up the Extensions view by clicking on the Extensions icon in the Activity Bar on the side of VS Code or the View: Extensions command (⇧⌘X).

Search for Deno Extension and Install it.

2. Running HTTP Server

To run HTTP Server on deno, use the following code.

import { serve } from "https://deno.land/std/http/server.ts";
const s = serve({ port: 8000 });

console.log('Http Server started. Press Ctrl + C to stop');

for await (const req of s) {
 req.respond({ body: "Hello World\n" });
}

Save this file as http-server.ts or any name of your choice.

Now lets run this file using

deno run --allow-net http-server.ts

Open http://localhost:8000/

3. Routing using Oak Middleware

We will be using Oak a middleware framework for Deno's http server, including a router middleware.

import {Application, Router} from "https://deno.land/x/oak/mod.ts";

const app = new Application();
const router = new Router();

const books = new Map([[ 1, 'one' ],[ 2, 'two' ],[3,'three']]);

router
.get('/',(context)=>{
   context.response.body = 'I am at homepage';
})
.get('/about',(context)=>{
   context.response.body = 'This is about page';
});

app.use(router.routes());

await app.listen({ port: 80 });

Now let's switch to browser and check if that works ?

http://localhost/

http://localhost/about

In routing you will need to pass parameters in url


.get('/book/:id',(context)=>{
context.response.body = 'Book name:\n';
    context.response.body += books.get(Number(context.params.id));
})

http://localhost/book/2

This way we can pass parameters in URL.

You can find more information about Oak on https://deno.land/x/oak/

4. Connecting to MySQL Database

Now let’s see how we can connect to mysql database

We will be using third party module: MySQL and MariaDB (5.5 and 10.2+) database driver for Deno.

import { Client } from "https://deno.land/x/mysql/mod.ts";
const client = await new Client().connect({
hostname: "127.0.0.1",
username: "root",
password: "password",
});
await client.execute("CREATE DATABASE IF NOT EXISTS webgile");
await client.execute("USE webgile");

I have installed MySQL on my localhost with above details

await client.execute(`
   CREATE TABLE IF NOT EXISTS books (
       id int(11) NOT NULL AUTO_INCREMENT,
       name varchar(100) NOT NULL,
       PRIMARY KEY (id)
   );
`);

As we have created table in mysql, lets insert some data in that.

let result = await client.execute(`INSERT INTO books(name) values(?)`, ["My Book One"]
);
console.log(result);

const books_all = await client.query(“select * from books”);
console.log(books_all);

You can pass parameters in query as follows

const book = await client.query(
 "select * from books where id = ?",[3]
);
console.log(book);

await client.close();

5. REST API Example with Database

Lets combine REST API and MySQL database code


import {Application, Router} from "https://deno.land/x/oak/mod.ts";
import { Client } from "https://deno.land/x/mysql/mod.ts";

const client = await new Client().connect({
hostname: "127.0.0.1",
username: "root",
password: "password",
});
await client.execute("USE webgile");

const app = new Application();
const router = new Router();

app.use(router.allowedMethods());
app.use(router.routes());

router
.get('/',(context)=>{
   context.response.body = 'I am at homepage';
})
.get('/books',async (context)=>{
   const books_all = await client.query("select * from books");
   context.response.body = books_all;
})
.get('/book/:id',async (context)=>{

   const book = await client.query(
       "select * from books where id = ?",
       [Number(context.params.id)]
      );
      console.log(book);
   context.response.body = book;
})
.post('/book/add',async (context)=>{
   if(await context.request.hasBody)
   {
       var body = await context.request.body();
       var data = body.value;
       let result = await client.execute(`INSERT INTO books(name) values(?)`, [data.name]);
       console.log(result);
       context.response.body = {"message":"Success","error":0};
   }
   else{
       context.response.body = {"message":"Invalid Request","error":1};
   }
});


await app.listen({ port: 80 });

To verify book/add method you can use Postman to sent POST request.

Post URL : http://localhost/book/add

With RAW data

{“name”:”Book name”}

You can find all these files on this link

webgile / deno

Deno

Installation

Deno ships as a single executable with no dependencies. You can install it using the installers below, or download a release binary from the releases page.

Shell (Mac, Linux): curl -fsSL https://deno.land/x/install/install.sh | sh

PowerShell (Windows): iwr https://deno.land/x/install/install.ps1 -useb | iex

View on GitHub

Deno Installation
How to Run HTTP Server on Deno ?
How to do Routing using Oak Middleware on Deno ?
How to connect to MySQL Database in Deno ?
How to build REST API with MySQL on Deno ?

The Beginning of the End ? Deno vs Node.Js

Abhay Kochar — Mon, 08 Jun 2020 21:01:23 +0000

The Beginning of the End ? Deno vs Node.Js

Creator of Node.js regretted !

Yes you heard that right , But WHY ?

Ryan Dahl creator of Node.js thinks he made number of mistakes while designing Node.js

Lets see what are those mistakes

Not sticking to promises: Promises are the necessary abstration for async / await
Security: In Node.js program you have access to all sorts of system calls
The Build System GYP: Which was later dropped by Chrome but Node continued using it.
package.json:That made Node.js dependent on NPM ( Privately controlle repository) and Concept of modules directory of files to look into
node_modules: Heaviest object in the Universe It complicated module resolution algorithm
require("module"):without .js extension Not a JS type of thing index.js,this Needlessly complicated Module loading system just to look fancy.

Ryan Dahl came up with a solution to Node.js Problems

DENO: A SECURED runtime for JavaScript and TypeScript

Built in Rust language
Uses V8 Engine
Tokio
Supports TypeScript out of the box.

Ships as a single executable file with no dependencies.Yup, No dependencies to be installed
Secured by default. No file, network, or environment access (unless explicitly enabled).
Has built-in utilities like a dependency inspector (deno info) and a code formatter (deno fmt).
Bundled into a single JavaScript file.

Node.js vs Deno

Lets see how it fairs against Node.js

Deno does not use npm
It uses modules referenced as URLs or file paths
Deno does not use package.json in its module resolution algorithm.
All async actions in Deno return a promise. Thus Deno provides different APIs than Node.
Deno requires explicit permissions for file, network, and environment access.
Deno always dies on uncaught errors.
It uses "ES Modules" and does not support require(). Third party modules are imported via URLs: For eg:

import * as log from "https://deno.land/std/log/mod.ts";

Remote code is fetched and cached on first execution, and never updated until the code is run with the --reload flag. so this will allow it to run later even if you are offline
Modules/files loaded from remote URLs are intended to be immutable and cacheable.

Deno Installation

Now lets see how easily we can install Deno

Run following command on terminal

Shell (Mac, Linux):

$ curl -fsSL https://deno.land/x/install/install.sh | sh

PowerShell (Windows):

> iwr https://deno.land/x/install/install.ps1 -useb | iex

ref: Deno.land website

Now lets build the HelloWorld !

Create a welcome.ts file and add basic javascript code

console.log('Hello World!');

Run from command line

$ deno run welcome.ts
Hello World!

You can run programs from URL directly without even downloading it.

$ deno run https://deno.land/std/examples/welcome.ts

Isn't it that simple ?

Would you like to have a detailed video on React + Deno with a functional CRUD Operation ?

Please comment.

You can find video on this Deno vs Node.js: The Beginning of the End of Node.js

Also you can more tutorials on Deno
Deno js Tutorial: Installation, HTTP Server, Deno Routing, Deno MySQL & Deno Rest API with MySQL

Deno Installation
How to Run HTTP Server on Deno ?
How to do Routing using Oak Middleware on Deno ?
How to connect to MySQL Database in Deno ?
How to build REST API with MySQL on Deno ?