DEV Community: Oshan Upreti

Simple Java Command Line Argument Parser Implementation

Oshan Upreti — Wed, 24 Feb 2021 12:43:48 +0000

Here, we will create a Custom CommandLineParser class to parse the arguments passed via the command line in Java.

Let's first see the sample entry point for the Java program.

public class MyProgram{
    public static void main(String args[])
    {
        System.out.println("This is my program.");
    }
}

Ever wondered why do we need to pass an array of strings as arguments in main method of Java?

It's for the command line arguments. When you run your Java program from the command line:

java MyProgram Oshan

It takes "Oshan" as an argument. So, if you want your program to access this String, you can access it using the array of String passed in the main method.

// inside main method 
    //Prints "My name is Oshan"
    System.out.println("My name is ", args[0]);

You can pass the initial configuration you want your Java program to follow via command-line arguments. For example:

## if you want to send file path
java MyProgram -filePath file1.txt 

## if you want to send multiple file paths
java MyProgram -filePath file1.txt file2.txt 

## or, if you just want to send flags 
java MyProgram -noprint

By default, Java takes each string as an argument and cannot differentiate between argument names, values, or flags. So, today, we'll write a simple program that will parse the arguments passed through the command line. This way we don't have to hard code the values of the arguments as args[1] or args[2] in our program. Instead, we will be able to see the argument list and choose values using argument names rather than an array of strings.

Here is the code:

import java.util.HashMap;
import java.util.HashSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class CommandLineParser {
    List <String> args = new ArrayList<>();
    HashMap<String, List<String>> map = new HashMap<>();
    Set<String> flags = new HashSet<>();

    CommandLineParser(String arguments[])
    {
        this.args = Arrays.asList(arguments);
        map();
    }

    // Return argument names
    public Set<String> getArgumentNames()
    {
        Set<String> argumentNames = new HashSet<>();
        argumentNames.addAll(flags);
        argumentNames.addAll(map.keySet());
        return argumentNames;
    }

    // Check if flag is given
    public boolean getFlag(String flagName)
    {
        if(flags.contains(flagName))
            return true;
        return false;
    }

    // Return argument value for particular argument name
    public String[] getArgumentValue(String argumentName)
    {
        if(map.containsKey(argumentName))
            return map.get(argumentName).toArray(new String[0]);
        else
            return null;
    }

    // Map the flags and argument names with the values 
    public void map()
    {
        for(String arg: args)
        {
            if(arg.startsWith("-"))
            {
                if (args.indexOf(arg) == (args.size() - 1))
                {
                    flags.add(arg.replace("-", ""));
                }
                else if (args.get(args.indexOf(arg)+1).startsWith("-"))
                {
                    flags.add(arg.replace("-", ""));
                }
                else
                {
                    //List of values (can be multiple)
                    List<String> argumentValues = new ArrayList<>();
                    int i = 1;
                    while(args.indexOf(arg)+i != args.size() && !args.get(args.indexOf(arg)+i).startsWith("-"))
                    {
                        argumentValues.add(args.get(args.indexOf(arg)+i));
                        i++;
                    }
                    map.put(arg.replace("-", ""), argumentValues);
                }
            }
        }
    }
}

Now, you can add the above class to any program you want and easily parse the values.

Let's try with a simple program:

public class MyProgram
{
    public static void main (String args[])
    {
        CommandLineParser clp = new CommandLineParser(args);
    }
}

Make sure you include the CommandLineParser class in the classpath when you compile your program.

javac -classpath /pathToTheCommandLineParserClass MyProgram.java

java MyProgram.java -name Oshan -prints 3 -test

Now, in our program you can easily get these values and use it.

// inside main method
    String name = clp.getArgumentValue("name");
    int prints = Integer.parseInt(clp.getArgumentValue("prints"));
    boolean isTest = clp.getFlag("test");

    if(isTest)
        System.out.println("This is only a test");

    for(int i = 0; i < prints; i++)
    {
        System.out.print(name+" ");
    }

The output of the above program will be:

This is only a test
Oshan
Oshan
Oshan

You can also use the method getArgumentNames to see the passed argument names.

I recently encountered a problem that made me write this custom CommandLineParser. Obviously, you can modify this to fit your requirements or go with the traditional approach. But, making such class removes the ambiguity when multiple arguments are passed via command line.

I hope you find this useful.

Thanks for reading.

Linux Commands Documentation

Oshan Upreti — Mon, 15 Feb 2021 00:27:26 +0000

I was preparing for an interview for a position where I was supposed to be tested for LINUX commands. So, as I was preparing and testing my commands knowledge on the terminal, I realized it would be better if I created documentation that might be helpful for others. I have also created documentation of this in GitHub, so, you can view it there, and if you'd like to contribute, you are free to do so.

oshanoshu / LinuxCommandsDocumentation

You can use this to learn commands, practice for interviews, or whatever you want to do. I just hope you find this useful.

1. Linux Network Commands

2. Linux File Commands

3. Linux Date Commands

4. Linux Search Commands

5. Linux Package Manager Commands

6. Linux User Commands

7. Linux Process Management Commands

8. Linux Hardware Commands

9. Linux Remote Commands

10. Linux File Permission Commands

Linux Network Commands

whois

Shows whois information about the given domain such as registrar info, registrant info, admin info if available.

## Displays available information of apple.com
whois apple.com

ping

Sends ICMP packets to the given address to check connectivity.

## Sends ICMP packets to google.com to check connectivity
ping google.com

ifconfig

Shows IP addresses of all interfaces

ifconfig

iwconfig

Shows wireless properties of the interfaces such as ESSID, Encryption keys.

iwconifg

host

Performs IP lookup for the domain name or vice-versa.

## Displays IP address of apple.com
host apple.com

## Displays domain name of 17.253.144.10
host 17.253.144.10

ss

Displays the information on all connections (TCP, UDP, unix Sockets). Previously accomplished by netstat command.

## Displays information on all connections
ss            

## Only currently listening sockets
ss -l    

## Displays UDP sockets
ss -u    

## Displays TCP sockets
ss -t 

## Displays Unix sockets
ss -x         

## Displays TCP sockets that are listening. Works with -u and -x as well
ss -t -a

wget

Download the file from a given source.

## Saves the index.html file of the google homepage
wget google.com         

##Downloads the D5100 manual pdf at the given location
wget https://cdn-10.nikon-cdn.com/pdf/manuals/dslr/D5100_EN.pdf

curl

Transfer data to or from a server using supported protocols like HTTP, FTP, SMTP, IMAP.

## displays the content of the URL on the terminal 
curl https://www.google.com

## download and saves the pdf in your local machine
curl -O https://cdn-10.nikon-cdn.com/pdf/manuals/dslr/D5100_EN.pdf

## download files from FTP servers. You don't need -u parameter if it's not authenticated.
curl -u <username>:<password> ftp://oshan.net/index.js 

## display the definition of the word using DICT protocol. The following line displays the dictionary definition of 'aversion'
curl dict://dict.org/d:aversion

EXTRA TIP: You can view manual for curl using your terminal with man curl command.

Linux File Commands

pwd

Displays the path of the current directory.

## Outputs the path of the directory you are in
pwd

ls

Shows the content of your directory.

## Shows the content of current directory
ls

## Shows the content including . files or hidden files of current directory
ls -a

## Shows the content with permission and other details
ls -l
ls -al

cd

Change your current directory to given path.

## Takes you to the downloads folder if there is one 
cd Downloads

## Toggle between your last two working directories 
cd -

## Takes you to the parent directory
cd ..

## Takes you to the HOME directory
cd

mkdir

Create a new directory in a given filepath.

## Creates a directory named Projects in current directory
mkdir Projects

rm

Delete a file or directory.

## Deletes the file.txt in working directory or specified path
rm file.txt

## Deletes the directory dir1 iff it's empty
rmdir dir1

## Deletes the directory dir1 along with its contents
rm -r dir1

mv

Move file/directory from one place to other. You can also use this to rename files.

## Move file.txt to directory dir1
mv file.txt dir1

## Rename file.txt to index.txt
mv file.txt index.txt

## Move directory dir1 to directory dir2
mv dir1 dir2

## To avoid overwriting index.txt if it already exists
mv -n file.txt index.txt

You can also move multiple files such as mv file1 file2 file3 dir.

cp

Copy file/directory from one place to another.

Basic format:

cp [Options] sourceFile/Dir destinationFile/Dir

## Copies file.txt to dir1
cp file.txt dir1

## Copies directory dir1 to dir2 along with the contents
cp -R dir1 dir2

## Copies content of file.txt to file2.txt. You can use -i or -b or -f options according to your requirement. -i asks for confirmation if the file needs to be overwritten. -b creates a backup before overwriting file. -f forces the overwriting without any warning/backup.
cp file.txt file2.txt

You can also move multiple files such as cp file1 file2 file3 dir.

touch

Create or update a file on a specified path.

## Creates file file1.txt in the current director
touch file1.txt

## Creates multiple files file1.txt and index.js in the current working directory
touch file1.txt index.js

cat

Displays the content of the file
Create a new file
Copy the content of one file to other
Merge files

## Display the content of file.txt
cat file.txt

## Create a file with the text "This is the first line"
cat > file2.txt
This is the first line.

## Copy the content of file2.txt to file.txt
cat file2.txt > file.txt

## Append "This is the second line" in the existing file file2.txt
cat >> file2.txt
This is the second line.

## Merge contents of file1 and file2 as merged_file
cat file1.txt file2.txt > merged_file.txt

head/tail

Displays the first 10 lines of file or last 10 lines of file. Helps when you are viewing a large file.

## Displays the first 10 lines of file.txt
head file.txt

## Displays the last 10 lines of file.txt
tail file.txt

Linux Date Commands

date

Displays date and time of the system.

## Displays date and time of the system
date

## Displays date and time of 5 days ago
date --date="5 days ago"

## Similarly, displays date and time of 10 seconds ago
date --date="10 seconds ago"

cal

Displays calendar.

## Displays the current month with day highlighted
cal

## Displays the third month of 1997 
cal 03 1997

Linux Search Commands

grep

Search for pattern in given file.

## Searches and displays lines containing string "linux" in file.txt
grep "linux" file.txt

## Searches and displays lines containing string "linux" in files in directory dir
grep -r "linux" dir

## Searches for the exact word "linux" in file.txt 
grep -w "linux" file.txt

## Ignores the case while searching
grep -i "linux" file.txt

find

Searches for files in given directory with given criteria.

Generally the pattern is:

find [starting_directory] [criteria]

## displays the path of all files in the current directory
find . 

## displays the path of files with name "index.js" in current directory
find . -name index.js

## displays the path of files greater than 500kb in size
find . -size +500k

You can use +/- with -atime or -mtime to get the files with last accessed time or modified time.

You can also execute commands on the result with -exec command or with prompt using -ok command.

## finds the file named index.js and delete it after displaying prompt
find . -name index.js -ok rm {} \;

Package Manager Commands

rpm

Manages rpm packages.

## Install package named "oshan.rpm"
rpm -ivh oshan.rpm

## Update if the package is already installed "oshan.rpm"
rpm -Uvh oshan.rpm

## Remove package named "oshan.rpm"
rpm -e oshan.rpm

## Verify package named "oshan.rpm"
rpm -V oshan.rpm

## List all the RPM packages 
rpm -qa

Generally, most of the distros use their own package manager, and it's prefereable to use package manager like yum or dnf instead of rpm because it handles all the dependencies.

I use OpenSUSE, and I have zypper as my package manager.

apt is used commonly for Debian family systems to handle dpkg.

User Commands

useradd

Add new users. (needs superuser privileges)

## Add new user named friends
sudo useradd friends

## Set password for friends
sudo passwd friends

## Specify userid 3001, group as users while adding user
sudo useradd -u 3001 -g users oshan

## Create user with expiry date as 2021-02-30
sudo useradd -e 2021-02-30 oshan

## Check Account/Password expiry dates for oshan
sudo chage -l oshan

userdel

Delete users. (need superuser privileges)

## Delete user named friends
sudo userdel friends

## Delete user friends and it's home directory
sudo userdel -r friends

last

Displays the last logins on the system.

Tips:
If you want to check if anyone is using your computer when you are not home this is the command you need.

#Outputs the info on last logins 
last

Similar commands:

## Shows the active user id and group id
id 

## Shows the username and login time of active user
who

Process Management Commands

ps

Displays process status.

## returns all the process running under the current user
ps ux 

## returns the status of process with process ID 5266
ps 5266

top

Displays in real time all the running process along with CPU usage, Memory usage, Priority, CPU time.

## You can press q to exit from the display
top

kill

kills the process with given process ID

## Terminates the process with PID 5766
kill 5766

## Kills all process named code
killall code

pidof

returns the Process ID of given process name

## returns the process ID of process name code
pidof code

## returns the process ID of process name containing code. Here code is the pattern instead of process name.
pgrep code

pkill

kills the process with the process name of the given pattern

## kills all the processes whose names has pattern code
pkill code

jobs

returns the list of background jobs

## returns the background jobs with status
jobs

## send stopped processes to background jobs
bg

## bring the background job code to foreground 
fg code

free

returns the memory status (RAM)

## Outputs the memory status in kilobytes
free

## Outputs the memory status in gigabytes or you can use -m for megabyte, -b for byte 
free -g

Hardware Commands

lsusb

Lists USB buses and the devices connected to them.

## Displays USB buses and the devices connected
lsusb

## Displays detailed information about USB buses and connected devices
lsusb -v

lspci

Lists PCI buses and the devices connected ot them. You might need root privileges to run this command.

## Displays PCI buses and the devices connected
lspci

## Displays detailed information of PCI buses. The amount of details increase with the number of v in the options
lspci -v
lspci -vv
lspci -vvv

lshw

Lists the hardware configuration of the machine. Device information, Motherboarad configuration, CPU version, Memory configuration, etc. You might need root privileges to run this command.

## Displays the hardware configuration of the machine
lshw

## Displays the information in html format with tree structure
lshw -html

EXTRA TIPS: lshw -html > index.html to save the output as index.html and view it in your browser.

lsblk

Lists the information about block devices.

## Lists the block devices 
lsblk

Using different options you can modify your result. Some of the useful ones are:

lsblk -all list all devices including empty ones

lsblk -O list all devices with all the availables columns

lsblk -o ColumnName list devices with given column information

fdisk

List out partition information and lets you modify it as well. You might need root privileges to run this command.

## List the partition and their sizes, number of sectors
fdisk -l

## lets you create/delete partition or other commands in given disk
fdisk /dev/sdb1

dmidecode

List hardware information from the BIOS. You might need root privileges to run this command.

## List the hardware information from the BIOS
dmidecode

## List the hardware information with little detail only. It's more readable.
dmidecode -q

dmesg

List detected hardware and boot messages.

## List the boot messages with detected hardware
dmesg

## List the messages in human readable format
dmesg -H

## Read the information and clear it 
dmesg -c

EXTRA TIP: dmesg -H > file.txt saves the output in file.txt.

badblocks

Used to check for badblocks in disk partition. You might need root privileges to run this command.

## Check for bad blocks in partition /dev/sda with progress of the scan. -s parameter is optional. 
badblocks -s /dev/sda

EXTRA TIP: badblocks -s /dev/sda -o file.txt saves the list of badblocks found in file.txt.

hdparms

Get/Set hard disk parameters.

## Check hard disk drive speed. I got 999.36 MB/sec
hdparm -t /dev/sda1 

## Check hard disk cache read speed. I got 6458.49 MB/sec
hdparm -T /dev/sda1

## you can see all other things you can do with this command
hdparm -h

Linux Remote Commands

ssh (Secure Shell)

SSH lets you connect remote systems and enables secured transfer of files over insecure networks. It is used widely over its predecessors telnet which isn't as secured as SSH, and there are possible problems like eavesdropping.

## Install ssh server (On debian systems ) 
sudo apt-get install openssh-server

## Install ssh server on OpenSUSE or you can use your Package Manager
sudo zypper install openssh-server

## Start ssh server 
sudo service ssh start

## Check ssh server status 
sudo service ssh status

## Connect to remote server
ssh <username>@<host_ip_address>

## Connect to host using specific port
ssh -p <port> <username>@<host_ip_address>

telnet

Telnet is a client-server protocol based on TCP connections. It dates back to almost 50 years ago. SSH is preferred over, but still it doesn't hurt to learn about this as it is still in use.

## Install ssh server (On debian systems ) 
sudo apt-get install openssh-server

## Install ssh server on OpenSUSE or you can use your Package Manager
sudo zypper install openssh-server

## start the connection setup
telnet <hostname>

## start using IP address and port number
telnet <IP_ADDRESS> <PORT>

Linux File Permission Commands

chmod

Change the file access rights. The permission is expressed in three sets of three characters to denote permission for file owner, group owner, and all other users.

For files:

1st set of rwx - Read, write, and execute permission for file owner
2nd set of rwx - Read, write and execute permission for group owner
3rd set of rwx - Read, write, and execute permission for all other users

Here, we will use octal notation to make changes to file permissions.

rwx rwx rwx 111 111 111
--- --- --- 000 000 000
rw- rw- rw- 110 110 110

111 => 7
110 => 6
101 => 5
100 => 4
011 => 3
010 => 2
001 => 1
000 => 0

So, it's easy to give permission using octal notation to files.

## Give read, write, and execution permission to everybody
chmod 777 index.js

## Give read, write, and execution permission to nobody
chmod 000 index.js

## Give all permission to directory owner and no permission to anybody else
chmod 700 dir

sudo

Get superuser (root) privileges temporarily. You need to enter root password for that. There are some commands that need superuser privileges because the file containing them don't have permission for other users.

sudo fdisk -l

chown

Change ownership of files. You need sudo privileges for executing this command.

## Change ownership of index.js from user to root
sudo chown root index.js

chgrp

Change group owner of file. You need sudo privileges for executing this command.

## Change group ownership of index.js from user to root
sudo chgrp root index.js

A Simple Express Server and MySQL Database

Oshan Upreti — Tue, 09 Feb 2021 21:04:44 +0000

Let's create a MySQL database and create an Express server to expose its data via API endpoints.

Prerequisites:

Desire to learn
Simple Command Line Usage
MySQL server installed in your device
Some knowledge of JavaScript

For installing MySQL server on your system, go to this My SQL Installation Guide, and follow according to your system requirements. I use OpenSUSE Tumbleweed, and it shouldn't matter what system you use.

Let's login with your MySQL username and password.

mysql -u root -p

It's better to create a new user other than root to handle your database. So, let's create a new user:

CREATE USER 'oshan'@'localhost' IDENTIFIED BY 'oshan';
GRANT ALL ON *.* TO 'oshan'@'oshan';

And, we granted privileges to user oshan to create a database and all kinds of stuff. Now, login with the new user you created.

mysql -u oshan -p

Now, let's create a database.

CREATE DATABASE Restaurant;
USE Restaurant;

Now, let's create a table called Menu.

CREATE TABLE Menu
(
    id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
    foodname VARCHAR(30) NOT NULL,
    price DECIMAL(13, 2) NOT NULL,
    description VARCHAR(255),
    availability BOOLEAN
)

Let's populate the table with some values:

Insert into Menu (foodname, price, description, availability) values ("Chicken Sandwich", 5.99, "Sandwich with Chicken and Pickel on the side", true);
Insert into Menu (foodname, price, description, availability) values ("Chicken Fried Rice", 7.99, "Fried Rice with chicken bits, comes with a complimentary
drink", true);

Now, let's create an Express server to communicate with the database. We can set up the initial files as follows:

touch .env index.js package.json config.js

We need to set up the environment variables for the server. So, in the .env file, we state the following variables. These variables are the configurations for your MySQL database which we will use later to connect to a database.

PORT=11000
DBHOST=localhost
DBUSERNAME=oshan
DBPASSWORD=oshan

Now, in package.json add the following JSON.

{
    "name": "restaurant_server",
    "version": "1.0.0",
    "description": "Serves Menu for restaurant",
    "main": "index.js",
    "engines": {
        "node" : "14.x"
    },
    "scripts": {
        "start": "node index.js",
    }
}

Let's install some dependencies. This will further populate the package.json. If you are curious to see what dependencies were installed, you can go to package.json.

npm install dotenv mysql express nodemon

We add nodemon in the scripts in package.json so that we don't have to manually restart the server every time we make some changes in our code.

"start:auto" : "nodemon index.js"

Let's set up the connection to the database in config.js.

const dotenv = require("dotenv");
dotenv.config();

const mysql = require('mysql');
let connection;
try {
    connection = mysql.createConnection({
        host: process.env.DBHOST,
        user: process.env.DBUSERNAME,
        password: process.env.DBPASSWORD,
        database: process.env.DBNAME
    });
} catch (error) {
    console.log("We got an error");
}

module.exports = {connection}

Once we do this, let's create our app that would act as a server to expose our database as API endpoints.

const dotenv = require("dotenv");

//this is the connection to the database 
const {connection} = require("./config");
const express = require("express");
const bodyParser = require('body-parser')

const app = express();

//body-parser helps parse the request body in POST request
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({extended: true}))

//you can call your environment variables after this 
dotenv.config();

app.listen(process.env.PORT||11000,() =>{
    console.log("Server is running")
})

module.exports = app;

Now, let's run our server nodemon run start:auto.First, test if our GET request can be made successfully, It should return the two menu items we inserted earlier. You can use an app like Postman or you can simply go to your browser and enter the URL for the GET request. In our case:

const getMenuItems = (request, response) => {
    connection.query("SELECT * FROM Menu", 
    (error, results) => {
        if(error)
            throw error;
        response.status(200).json(results);
    })
}

app.route("/menuItems")
.get(getMenuItems)

Now, lets run our server nodemon run start:auto.First, test if our GET request can be made succesfully, It should return the two menu items we inserted earlier. You can use app like Postman or you can simply go to your browser and enter the url for GET request. In our case:

localhost:11000/menuItems

Now, let's try to add something into the database using the POST request. We'll pass our value as JSON and this app will populate the database for us. We didn't mention id because we have set the id to auto_increment while we created the table.

//Add this to index.js
const postMenuItems = (request, response) => {
    const {foodname, price, discussion, availability} = request.body;
    connection.query("INSERT INTO Menu(foodname, price, discussion, availability) VALUES (?,?,?,?) ", 
    [foodname, price, availability],
    (error, results) => {
        if(error)
            throw error;
        response.status(201).json({"Menu Item Added":results.affectedRows});
    })
}

//route for accessing the endpoint
app.route("/menuItems")
.post(getMenuItems)

Let's see if this works using Postman.

And, it works like a charm. Still, if you want to check, you can make a GET request and see if your recent entry is returned.

Now, let's do a DELETE request to wrap this thing. We'll pass the id of the menu item we want to delete as a parameter via URL. And, make sure you absolutely want to delete the data because you'll be deleting it from the database.

//Add this to index.js

const deleteMenuItems = (request, response) => {
    const id = request.params.id;
    connection.query("Delete from Menu where id = ?", 
    [id],
    (error, results) => {
        if(error)
            throw error;
        response.status(201).json({"Menu Item Deleted":results.affectedRows});
    })
}

//route for accessing this endpoint
app.route("/menuItems/:id")
.delete(deleteMenuItems)

Again you can make the GET request to see if the changes are reflected.

EXTRA:

You can use this method for most SQL databases. All you need to do is simply tweak in config.js.

NEXT: We'll learn some "good to know" Linux/Unix Commands.

You can also find this on my website: Oshan Upreti

For complete code:

oshanoshu / Blog_References

A Simple Express Server and Twitter API

Oshan Upreti — Sat, 06 Feb 2021 12:54:28 +0000

We'll create a simple Express server to get recent tweet information from a given user.

Prerequisites:

You need to have a Twitter Developer Account. To learn more about it: Click Here
Some knowledge of JavaScript
Command Line Usage

Let's create a folder for our application:

mkdir TweetPuller

Now, let's add some files in the folder to start with.

cd TweetPuller
touch .env index.js package.json

Basically, package.json holds information like dependencies, name of your application, description, and start scripts. So, let's populate the package.json in a simple way.

package.json

{
"name": "TweetPuller",
"version": "1.0.0",
"description": "Pull Tweets",
"main": "index.js",
"engines": {
"node" : "14.x"
},
"scripts": {
"start": "node index.js"
}
}

That should do it. Then, we also created a .env file where we generally store environment variables. If you are working with secret keys, you should never expose it in your application code. So, basically, you can store your secret keys/credentials in your .env file. In our case, we'll store the Bearer Token we get from your Twitter Developer Portal. And, in case we chose to publish this project on GitHub, we will use gitignore to ignore this file while committing.

.env

BEARER_TOKEN="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

Now, let's go ahead and install some dependencies that we will be using in our application. Once we install these dependencies, our package.json is getting populated. So, stay cool.

npm install express dotenv needle

We are installing express because we are creating an Express server. Express is just a Node.js web application framework. We are installing dotenv to get environment variables from the .env file. We are installing needle to make Twitter API calls.

index.js

const express = require("express");
const dotenv = require("dotenv");
const needle = require("needle");


const app = express()


dotenv.config();

//Get Bearer Token from .env 
const BearerToken = process.env.BEARER_TOKEN;

const endpointUrl = "https://api.twitter.com/2/tweets/search/recent";

//Get Tweets from Twitter API
const getTweets = async(id) => {

    const params = {
        'query': 'from:'+id+' -is:retweet',
        'tweet.fields': 'created_at',
        'expansions': 'author_id'
    }
    const response = await needle ('get', endpointUrl, params,{
        headers: {
            "User-Agent": "v2RecentSearchJS",
            "authorization": `Bearer ${BearerToken}`
        }
    })

    if (response.statusCode !== 200) {
        if (response.statusCode === 403) {
            res.status(403).send(response.body);
        } 
        else {
            throw new Error(response.body.error.message);
        }
    }
    if (response.body)
        return response.body;
    else
        throw new Error("Unsuccessful Request");   
}

//This returns the object to client
const getTweetAnalysis = async(req, res) => {
    try {
        let twitterData =await getTweets(req.params.id);
        //res.send(twitterData);
        res.send(await analyze(twitterData));
    } catch (error) {
        res.send(error);
    }

}

//Simple Analysis
const twitterObject = {}
const analyze = async(twitterData) =>
{
    twitterObject["username"] = twitterData.includes.users[0].username;
    twitterObject["name"] = twitterData.includes.users[0].name;
    console.log(twitterData.data[0].text)
    let averageCharacter = 0;
    let averageWord = 0;
    let totalCharacter = 0;
    let totalWord = 0;
    let texts = twitterData.data;
    if(texts)
    {
        for(let index =0 ; index < twitterData.data.length ; index++)
        {
            totalCharacter += texts[index].text.length;
            totalWord += texts[index].text.split(" ").length;
        }
    }
    if(twitterData.meta.result_count > 0)
    {
        twitterObject["usesActively"] =  true;
        averageCharacter = totalCharacter/twitterData.meta.result_count;
        averageWord = totalWord/twitterData.meta.result_count;
    }
    else
    {
        twitterObject["usesActively"] =  false;
    }
    twitterObject["averageWordCount"] = averageWord;
    twitterObject["averageCharacterCount"] = averageCharacter;
    return twitterObject;
}

//API route 
app.get("/api/tweet/:id",getTweetAnalysis);

//You can specify the port in .env file
app.listen(process.env.PORT||3000,()=>
{
    console.log('Currently Listening to the Server')
})

module.exports = app

Now, what we did above was used one of the Twitter API V2 Search Tweets to search for recent tweets by username. And, in turn, created an Express server to analyze the tweets and provide some information via API endpoints.

To run the server, run the following command:

npm start

Now, you can hook this up with your client-side or you can use an application like Postman to test the server.

Extra Tip

You can install nodemon dependency to automate the server restart every time you make changes in the code.
You need to add this in the script of package.json.

"start:auto": "nodemon index.js"

Then, run the following command:

npm run start:auto

You should be able to build an Express server that makes calls using the get method from scratch.

Next time, we'll create the server using the database and do some post and delete calls.

You can also find this on Oshan Upreti Blog

For complete code:

oshanoshu / TweetPuller

Runnable vs Threads

Oshan Upreti — Sun, 24 Jan 2021 01:45:11 +0000

Threads in Java can be created two ways:

Extending Thread Class
Implementing Runnable Interface

Extending Thread Class:

class MyThread extends Thread{
    /*
    This is where your implementation of what happens when you start a thread goes.
    You need to override the run method from the Thread class.
    */
    @Override
    public void run()
    {
        System.out.println("Thread is running");
    }
}

class CreatingThreads {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

Implementing Runnable Interface

class MyRunnable implements Runnable{
    @Override
    public void run()
    {
        System.out.println("Thread is running");
    }
}

class CreatingThreads{
    public static void main(String[] args){
        Runnable myRunnable = new MyRunnable();
        Thread myThread = new Thread(myRunnable);
        myThread.start();
    }
}

Using the Runnable interface, you can also create threads via lambda expressions. The Thread class takes a Runnable object, and the Runnable interface has just one method run which takes no arguments. So, you can create a Thread using the following pattern which is much easier to implement.

class CreatingThreads{
    public static void main(String[] args){
        Thread myThread2 = new Thread(() -> {
        //do something here
        //what do you want your thread to do
        });
        myThread2.start();
    }
}

The advantage of implementing the Runnable interface over extending Thread class is that you'll have space to extend another class if required. (You can only extend one class in Java).
The other advantage is that each thread created by the Thread class is associated with a new object whereas each thread created by the Runnable interface shares the same object.
Let's look at the following code:


class MyRunnable implements Runnable{

    public int number = 0;

    @Override
    public void run() {
        number++;
        System.out.println("Thread is running, "+number);
    }

}

class MyThread extends Thread{

    public int number = 0;

    @Override
    public void run() {
        number++;
        System.out.println("Thread is running, "+number);
    }
}

class CreatingThreads{
    public static void main(String[] args) throws InterruptedException {

        System.out.println("Implementing Runnable Interface: ");

        Runnable myRunnable = new MyRunnable();
        Thread myThread = new Thread(myRunnable);
        Thread myThread2 = new Thread(myRunnable);
        myThread.start();
        Thread.sleep(2000);

        myThread2.start();
        Thread.sleep(2000);

        System.out.println();

        System.out.println("Extending Thread Class: ");

        MyThread secondMyThread = new MyThread();
        MyThread secondMyThread2 = new MyThread();
        secondMyThread.start();
        Thread.sleep(2000);
        secondMyThread2.start();

    }

}

Output:

Implementing Runnable Interface: 
Thread is running, 1
Thread is running, 2

Extending Thread Class: 
Thread is running, 1
Thread is running, 1

As you can see threads created by implementing the Runnable interface are acting on the same object whereas the ones created by extending the Thread class are acting on different objects.

You can also find this on my blog: Oshan Upreti.

DEV Community: Oshan Upreti

Simple Java Command Line Argument Parser Implementation

Linux Commands Documentation

oshanoshu / LinuxCommandsDocumentation

Table of Contents

1. Linux Network Commands

2. Linux File Commands

3. Linux Date Commands

4. Linux Search Commands

5. Linux Package Manager Commands

6. Linux User Commands

7. Linux Process Management Commands

8. Linux Hardware Commands

9. Linux Remote Commands

10. Linux File Permission Commands

Linux Network Commands

whois

ping

ifconfig

iwconfig

host

ss

wget

curl

Linux File Commands

pwd

ls

cd

mkdir

rm

mv

cp

touch

cat

head/tail

Linux Date Commands

date

cal

Linux Search Commands

grep

find

Package Manager Commands

rpm

User Commands

useradd

userdel

last

Process Management Commands

ps

top

kill

pidof

pkill

jobs

free

Hardware Commands

lsusb

lspci

lshw

lsblk

fdisk

dmidecode

dmesg

badblocks

hdparms

Linux Remote Commands

ssh (Secure Shell)

telnet

Linux File Permission Commands

chmod

sudo

chown

chgrp

A Simple Express Server and MySQL Database

Prerequisites:

EXTRA:

oshanoshu / Blog_References

A Simple Express Server and Twitter API

Prerequisites:

package.json