In this post I’ll describe a use case that I am currently using. I have a standard Internet connection that goes to my Eero mesh router and behind that I have a homelab on 192.168.1.0/24 network as shown in the diagram. I have a port forwarding configured on the router so I can access one of my Linux servers, but if I want to access other servers, I have to either port forward SSH on some other-than-22/tcp port or use the Linux server as a jump-box. None of this is good, so I decided to create an OpenVPN server. Anytime I VPN to this server I can ssh/rdp to any of the internal servers. The OpenVPN server requires one nic.
NOTE: This post is very FreeBSD specific so if you want to use some Linux server as OpenVPN server, this guide won’t help you at all.

IMPORTANT: On your home router port-forward port 1194/udp to your OpenVPN server.

OpenVPN server

Let’s install OpenVPN server first.

pkg install openvpn

Make sure it starts on boot and enable the NAT.

sysrc openvpn_enable=YES
sysrc gateway_enable=YES

Next, we need a directory where we’ll store our config files and the PKI.

mkdir /usr/local/etc/openvpn
cd /usr/local/etc/openvpn

Create the PKI structure.

easyrsa init-pki

Go to the newly created pki directory and make a copy of the vars.example file.

cd pki
cp vars.example vars

Now edit this file and uncomment the following lines and change to match your needs. It’s optional and you can keep everything-as-is.

set_var EASYRSA_REQ_COUNTRY     "US"
set_var EASYRSA_REQ_PROVINCE    "NJ"
set_var EASYRSA_REQ_CITY        "Allentown"
set_var EASYRSA_REQ_ORG         "iAndreev"
set_var EASYRSA_REQ_EMAIL       "mail@somemail.com"
set_var EASYRSA_REQ_OU          "iAndreev"
set_var EASYRSA_CA_EXPIRE       3650
set_var EASYRSA_CERT_EXPIRE     825

Now create the Certificate Authority based on these values.

cd /usr/local/etc/openvpn
easyrsa build-ca

This command will prompt you to create a password that you will you to sign the certificates for the server and the clients.
Then create the DH parameters. It might take 30+ seconds.

easyrsa gen-dh

Create the server request and sign it.

easyrsa build-server-full server nopass

You have to type yes to confirm and then use the password that you created above to sign the cert.
The command will create some files under the pki directory and we’ll need those later.
Next, we’ll create the same for the client. In my case it’s a Dell laptop, so I use the word dell, but you can use client, client1, something-whatever…

easyrsa build-client-full dell nopass

Same thing, answer yes and then use the password to sign the certs.
Copy the OpenVPN config example file that comes with the package.

cp /usr/local/share/examples/openvpn/sample-config-files/server.conf /usr/local/etc/openvpn/openvpn.conf

Edit openvpn.conf and make sure these values are changed and match the certs you created earlier.

ca /usr/local/etc/openvpn/pki/ca.crt
cert /usr/local/etc/openvpn/pki/issued/server.crt
key /usr/local/etc/openvpn/pki/private/server.key

dh /usr/local/etc/openvpn/pki/dh.pem

In addition to that, find the line that says push route and create a new one that matches your internal subnet. In my case it looks like this.

push "route 192.168.1.0 255.255.255.0"

If you have internal DNS and you want to send that as well, uncomment the following line and change to match your DNS IP.

push "dhcp-option DNS 208.67.222.222"

Now, you can start the OpenVPN server. Make sure you check the syslog for any errors.

service openvpn start
tail /var/log/messages

OpenVPN client

On your laptop that you want to use as a VPN client, download the OpenVPN client from here. When you install the client, you’ll have a generic config file under C:\Program Files\OpenVPN\sample-config folder. Copy that file under c:\users\[your_username]\OpenVPN\config.
Then, edit the file and change the following lines.

remote public-ip-or-hostname-of-your-router 1194
ca ca.crt
cert dell.crt
key dell.key

NOTE: Make sure you copy ca.crt from /usr/local/etc/openvpn/pki, dell.crt or client.crt or whatever.crt from /usr/local/etc/openvpn/pki/issued and dell.key or client.key or whatever.key from /usr/local/etc/openvpn/pki/private directories to the same c:\users\[your-user-name]\OpenVPN\config folder. There should be 4 files there. The config file, the CA certificate, the client certificate and the private key for the client.
Start the OpenVPN client and connect. You shouldn’t have any problems and you’ll get 10.8.0.2 IP assigned to your laptop. If you try to ping 10.8.0.1 you’ll get a response. Do route print and you’ll see that the routes for 192.168.1.0 are going over 10.8.0.1. But, if you try to ping some server internally, e.g. 192.168.1.21, you won’t get any response. That’s because that server doesn’t know the route back. You can easily add the route to each server but it’s not practical. Let’s make one more change to the server.

OpenVPN server

Add these two lines to /etc/rc.conf. That’s the FreeBSD pf firewall.

pf_enable="YES"
pf_rules="/etc/pf.conf"

Now, create this config file in /etc/pf.conf. Many thanks to this guy.

vpnclients = "10.8.0.0/24"
# The name of your NIC. I am using a VM on ESXi and vmx0 is my NIC.
wanint = "vmx0"
# put your tunnel interface here, it is usually tun0
vpnint = "tun0"
# OpenVPN by default runs on udp port 1194
udpopen = "{1194}"
# Open the SSH port.
tcpopen = "{22}"
icmptypes = "{echoreq, unreach}"

set skip on lo
# the essential line
nat on $wanint inet from $vpnclients to any -> $wanint

block in
pass in on $wanint proto udp from any to $wanint port $udpopen
pass in on $wanint proto tcp from any to $wanint port $tcpopen
# the following two lines could be made stricter if you don't trust the clients
pass out quick
pass in on $vpnint from any to any
pass in inet proto icmp all icmp-type $icmptypes

Reboot the OpenVPN server and if you reconnect from the client, you can use the internal IPs directly to connect.

I have several scripts that I use to do some maintenance on my servers (snapshots, backups, cleanups etc) and they are all scattered on different servers. I’ve decided to consolidate them and use AWS Lambda to do the scheduling and execution for me. So, in this post I’ll explain how to create simple snapshot clean up script that deletes some old AWS snapshots and runs once a day. In addition, I’ll do the same Lambda script, but this time using the serverless framework.

The setup below requires Full Access to AWS.

SNS

First, let’s configure SNS that we’ll use to send us the notifications from the script. Go to SNS and click on Create topic.

Name your topic and click on Create topic.

Once there, click on Create subscription.

In my case, I want to receive an e-mail. Click on Create subscription.

If you check your e-mail, you’ll see that you have to confirm the subscription. Click on Confirm subscription in the e-mail and you are done with this part.

Lambda function

We are ready to deploy the script now. Go to Lambda and click on Create a function. Fill out the form so it looks like this.

Once you select Create a custom role a new window will pop up.

Click Allow and the window will close. You’ll be back to the initial screen. Click Create function here.

If you scroll down a bit, you’ll see a placeholder for a Python code. I already have my function ready, so I’ll just delete what’s in there and paste my script. Make sure you change the values in line numbers 8 and 10. Line number 8 is your AWS account and line number 10 is the amount of days that you want your snapshots to be kept. Also, if you have any snapshots that you want to keep no matter how many days they are old, you can specify their IDs in line 6. They’ll be skipped. Anything older than diff_time days will be deleted. Also, if your SNS topic was named differently, change the line number 53.

import json, boto3, datetime

def lambda_handler(event, context):

    # Do not delete these snaps
    snap_ignore = ['snap-12718f7046cc2add6','snap-0e738d4c47b2d6e14']    
    # Enter the AWS account number here
    accountId = '123456789012'
    # Delete snapshots older than diff_time days   
    diff_time = 30
    # Constant string
    no_snap = 'No snaps were found for clean up.'  
    # Constant string
    skip_str = 'was skipped because it is in use.'
    # Leave it empty
    mail_body = ''

    
    ec2 = boto3.resource('ec2')
    sns = boto3.client('sns')

    # Get all the snaps from the account
    snaps = ec2.snapshots.filter(OwnerIds=[accountId])
    # Get the current time
    now_time = datetime.datetime.now().date()
    # Iterate through the snaps
    for snap in snaps:
        # Check for protected snaps, e.g the ones that we have to skip and ignore
        if (snap.id in snap_ignore): 
            continue
        # Get the creation time of the snap
        snap_time = snap.start_time.date()
        # Get the current time
        now_time = datetime.datetime.now().date()
        # Calculate the difference
        snapage_time = (now_time - snap_time).days
        # If the creation time is older than the required difference
        if(snapage_time > diff_time):
            try:
                # Delete the snap
                snap.delete(snap.id)
                # Print the snap that will be deleted
                print(snap.id,'created on',snap_time,'was deleted')
                mail_body = mail_body + snap.id + ' created on ' + str(snap_time) + ' was deleted.\n'
            # Catch an exception if the snap is in use
            except:
                print(snap.id, skip_str)
                mail_body = mail_body + snap.id + ' ' + skip_str + '\n'
                continue
    if (mail_body == ''):
        mail_body = no_snap
    response = sns.publish(
        TopicArn = 'arn:aws:sns:us-east-1:' + accountId + ':topSnapCleanUp',
        Message = mail_body,
        Subject = 'Snapshot Clean up ' + str(now_time)
    )

Click Save in the upper right corner and click Test. Enter something for the Event name and click Create. Click Test again. You’ll get an error at the top of the screen.

The error means that we don’t have rights. So, we have to add a policy to our role that we created earlier.

IAM Roles and Policies

If you go to the IAM service and search for the role that you’ve created, you’ll see that it’s there and that there is a simple Lambda policy attached.

If you look at the policy, you’ll see that this policy gives access to CloudWatch logs. What we need in the policy is access to snapshots and SNS. Click on Edit policy and copy and paste this one. Replace your account number in line 16.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:DeleteSnapshot",
                "ec2:DescribeVolumes",
                "ec2:DescribeSnapshots"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "sns:Publish",
            "Resource": "arn:aws:sns:us-east-1:123456789012:topSnapCleanUp"
        }
    ]
}

If you save the policy and run the Lambda function, you’ll see that everything works as expected. But, we want to go a step further and automate the execution of the script.

CloudWatch

First, we need to decide when we want this script to start. In my case, I want the script to run at 1AM in the morning. Go to CloudWatch, click on Rules on the left side and click on Create rule button.

Click on Cron expression and enter 0 1 * * ? *. If you don’t know what this means, it’s a cron syntax. Google it and you’ll figure it out. It’s easy. On the right side, under Targets, choose our Lambda function from the drop-down. Then click Configure details.

Under Step 2, enter the rule name, description and click on Create rule.

In case your function times out because you have way too many snapshots, you can increase the time-out settings for the function from the main Lambda screen.

You are all set.

Serverless

You can deploy the same solution without even logging to the console. All you need is the serverless framework. I won’t explain how to install and configure serverless, so once you are done, let’s create our first serverless project.

sls create -t aws-python3 -p SnapCleanUp
Serverless: Generating boilerplate...
Serverless: Generating boilerplate in "/home/klimenta/SnapCleanUp"
 _______                             __
|   _   .-----.----.--.--.-----.----|  .-----.-----.-----.
|   |___|  -__|   _|  |  |  -__|   _|  |  -__|__ --|__ --|
|____   |_____|__|  \___/|_____|__| |__|_____|_____|_____|
|   |   |             The Serverless Application Framework
|       |                           serverless.com, v1.37.1
 -------'

Serverless: Successfully generated boilerplate for template: "aws-python3"

Serverless will generate the skeleton code and YAML config file for you. If you go to that directory, you’ll see two files: handler.py which is our Python function and serverless.yml which is the AWS config written in YAML. You can take a look at the generic files to see what’s going on. In our case we’ll replace these two files with ours. So, here is the handler.py file. As you can see it’s pretty much the same as the Python file that we used initially.

import json, boto3, datetime

def snapcleanup(event, context):

    # Do not delete these snaps
    snap_ignore = ['snap-12718f7046cc2add6','snap-0e738d4c47b2d6e14']
    # Enter the AWS account number here
    accountId = '123456789012'
    # Delete snapshots older than diff_time days
    diff_time = 30
    # Constant string
    no_snap = 'No snaps were found for clean up.'
    # Constant string
    skip_str = 'was skipped because it is in use.'
    # Leave it empty
    mail_body = ''

    ec2 = boto3.resource('ec2')
    sns = boto3.client('sns')

    # Get all the snaps from the account
    snaps = ec2.snapshots.filter(OwnerIds=[accountId])
    # Get the current time
    now_time = datetime.datetime.now().date()
    # Iterate through the snaps
    for snap in snaps:
        # Check for protected snaps, e.g the ones that we have to skip and ignore
        if (snap.id in snap_ignore):
            continue
        # Get the creation time of the snap
        snap_time = snap.start_time.date()
        # Get the current time
        now_time = datetime.datetime.now().date()
        # Calculate the difference
        snapage_time = (now_time - snap_time).days
        # If the creation time is older than the required difference
        if(snapage_time > diff_time):
            try:
                # Delete the snap
                snap.delete(snap.id)
                # Print the snap that will be deleted
                print(snap.id,'created on',snap_time,'was deleted')
                mail_body = mail_body + snap.id + ' created on ' + str(snap_time) + ' was deleted.\n'
            # Catch an exception if the snap is in use
            except:
                print(snap.id, skip_str)
                mail_body = mail_body + snap.id + ' ' + skip_str + '\n'
                continue
    if (mail_body == ''):
        mail_body = no_snap
    response = sns.publish(
        TopicArn = 'arn:aws:sns:us-east-1:' + accountId + ':topSnapCleanUp',
        Message = mail_body,
        Subject = 'Snapshot Clean up ' + str(now_time)
    )

And here is the YAML file that does the heavy lifting of creating and gluing everything for you.

service: SnapCleanUp

provider:
  name: aws
  runtime: python3.7
  timeout: 10
  stage: prod
  region: us-east-1
  iamRoleStatements:
    - Effect: "Allow"
      Action:
      - ec2:DeleteSnapshot
      - ec2:DescribeVolumes
      - ec2:DescribeSnapshots
      Resource: "*"
    - Effect: Allow
      Action: sns:Publish
      Resource: {"Ref" : "SNSTopic"}

functions:
  snapcleanup:
    handler: handler.snapcleanup
    description: Deletes snaps older than XX days
    events:
      - schedule: cron(* 1 * * ? *)
        enabled: true
resources:
  Resources:
    SNSTopic:
      Type: AWS::SNS::Topic
      Properties:
        DisplayName: 'Snap Clean'
        TopicName: topSnapCleanUp

    SNSSubscription:
      Type: AWS::SNS::Subscription
      Properties:
        Endpoint: klimenta@iandreev.com
        Protocol: email
        TopicArn: {"Ref" : "SNSTopic"}

Here is a brief description. In the provider section you specify that you’ll use Python 3, the timeout for the execution will be 10 seconds and the region is us-east-1. We also have the role defined here. If you look the initial JSON script for the role, well, this is the same, except it’s in YAML. You can use any online converter to translate JSON to YAML. The function section is where I specify the name of the function and I also create the CloudWatch rule so the script runs at 1AM every day. Finally in the resources section I create the SNS topic and the subscription. For more information about the syntax, see the docs on the serverless site.
Anyway, we can deploy the function now.

sls deploy -v

It takes about a minute for all resources to be completed. Once deployed, check your e-mail and look for the confirmation e-mail. You have to confirm your subscription. And pretty much that’s it. If you take a look at the console (Lambda, IAM roles, CLoudWatch rules and logs), you’ll see that pretty much every AWS resource looks the same as our first manual try.

Helpful tips

If you have to make a change in the function (handler.py), you don’t have to redeploy the whole solution. You can just deploy the function itself.

sls deploy function -f snapcleanup

Also, we have a scheduled that runs the function at a specified interval, but you can run the script manually.

sls invoke -f snapcleanup -l

Check the logs of the function in real-time.

sls logs -f snapcleanup -t

If you want to remove all resources and delete the function, use the remove parameter.

sls remove

I was playing with python and pygame and decided to make a variant of the Tetris game (called KAtrix). This one is a little easier because the shapes do not fall automatically from the top. You have to move them with the left, right and down cursor keys and confirm the position with the space key.
Here is the screenshot and the source.

git clone https://github.com/klimenta/KAtrix

Not well documented, but it gives an idea what’s going on.

__author__ = 'Kliment Andreev'
__version__ = '20151108 15:48'

# Imports
import random
import time
import pygame
import sys
from pygame.locals import *

# Constants and dictionaries
# Frames per second
FPS = 25
# The top left column where the falling shape is positioned initially
START_COL = 4
# Represent a box or empty space for a shape
EMPTY_BOX = '-'
FULL_BOX = 'X'
# Window dimensions
WINDOW_WIDTH = 640
WINDOW_HEIGHT = 480
# Matrix dimensions, including 4 borders (left, right, top, bottom)
MATRIX_WIDTH = 12
MATRIX_HEIGHT = 22
# Fill the matrix with zeros
MATRIX = [[0 for x in range(MATRIX_WIDTH)] for x in range(MATRIX_HEIGHT)]
#Box width in pixels. Each shape is composed of boxes.
BOX_SIZE = 20
# Define 16 web colors
BLACK = (0x00, 0x00, 0x00)
YELLOW = (0xff, 0xff, 0x00)
WHITE = (0xff, 0xff, 0xff)
SILVER = (0xc0, 0xc0, 0xc0)
GRAY = (0x80, 0x80, 0x80)
RED = (0xff, 0x00, 0x00)
MAROON = (0x80, 0x00, 0x00)
OLIVE = (0x80, 0x80, 0x00)
LIME = (0x00, 0xff, 0x00)
GREEN = (0x00, 0x80, 0x00)
AQUA = (0x00, 0xff, 0xff)
TEAL = (0x00, 0x80, 0x80)
BLUE = (0x00, 0x00, 0xff)
NAVY = (0x00, 0x00, 0x80)
FUCHSIA = (0xff, 0x00, 0xff)
PURPLE = (0x80, 0x00, 0x80)
# Top left coordinates of the matrix
TOP_X = 199
TOP_Y = 19
# Top left coordinates of the the box at (0,0)
# This is the top left coordinate of the top-left shape can be
TOP_BOX_X = TOP_X + BOX_SIZE
TOP_BOX_Y = TOP_Y + BOX_SIZE
# These are the shapes
# Each line represent an original position
# and three possible rotations
SHAPE_I = (("----"), ("XXXX"), ("----"), ("----")), \
          (("-X--"), ("-X--"), ("-X--"), ("-X--")), \
          (("----"), ("XXXX"), ("----"), ("----")), \
          (("-X--"), ("-X--"), ("-X--"), ("-X--"))
SHAPE_J = (("--X-"), ("--X-"), ("-XX-"), ("----")), \
          (("-X--"), ("-XXX"), ("----"), ("----")), \
          (("-XX-"), ("-X--"), ("-X--"), ("----")), \
          (("-XXX"), ("---X"), ("----"), ("----"))
SHAPE_L = (("-X--"), ("-X--"), ("-XX-"), ("----")), \
          (("XXX-"), ("X---"), ("----"), ("----")), \
          (("-XX-"), ("--X-"), ("--X-"), ("----")), \
          (("--X-"), ("XXX-"), ("----"), ("----"))
SHAPE_O = (("-XX-"), ("-XX-"), ("----"), ("----")), \
          (("-XX-"), ("-XX-"), ("----"), ("----")), \
          (("-XX-"), ("-XX-"), ("----"), ("----")), \
          (("-XX-"), ("-XX-"), ("----"), ("----"))
SHAPE_S = (("----"), ("-XX-"), ("XX--"), ("----")), \
          (("-X--"), ("-XX-"), ("--X-"), ("----")), \
          (("----"), ("-XX-"), ("XX--"), ("----")), \
          (("-X--"), ("-XX-"), ("--X-"), ("----"))
SHAPE_T = (("XXX-"), ("-X--"), ("----"), ("----")), \
          (("--X-"), ("-XX-"), ("--X-"), ("----")), \
          (("-X--"), ("XXX-"), ("----"), ("----")), \
          (("X---"), ("XX--"), ("X---"), ("----"))
SHAPE_Z = (("----"), ("-XX-"), ("--XX"), ("----")), \
          (("--X-"), ("-XX-"), ("-X--"), ("----")), \
          (("----"), ("-XX-"), ("--XX"), ("----")), \
          (("--X-"), ("-XX-"), ("-X--"), ("----"))
# List of shapes
SHAPES = (SHAPE_I, SHAPE_J, SHAPE_L, SHAPE_O, SHAPE_S, SHAPE_T, SHAPE_Z)
# Shape Colors - Dictionary
SHAPE_COLOR = {SHAPE_I: BLUE,
               SHAPE_J: PURPLE,
               SHAPE_L: RED,
               SHAPE_O: GREEN,
               SHAPE_S: WHITE,
               SHAPE_T: FUCHSIA,
               SHAPE_Z: AQUA}
# Colors, web colors - dictionary
COLOR_COLOR = {BLACK: 0,
               YELLOW: 1,
               BLUE: 2,
               PURPLE: 3,
               RED: 4,
               GREEN: 5,
               WHITE: 6,
               FUCHSIA: 7,
               AQUA: 8}
# This is a reverse dictionary finder
find_color = dict([[value, key] for key, value in COLOR_COLOR.items()])
# All possible combinations of rotations
ROTATE_0_DEGREES = 0
ROTATE_90_DEGREES = 1
ROTATE_180_DEGREES = 2
ROTATE_270_DEGREES = 3
# This is the size of one shape, 4 x 4
SHAPE_SIZE = 4


class Shape(object):
    """A class for shapes"""
    def __init__(self, name, rotation, pos_y, pos_x):
        self.name = name            # Name of the shape, e.g. SHAPE_T
        self.rotation = rotation    # Rotation index of the shape
        self.pos_x = pos_x          # X position of the shape, it can be from 1 to 10
        self.pos_y = pos_y          # Y position of the shape, it can be from 1 to 20

    def drawShapeOnScreen(self):
        """
        This method draws all boxes that form a shape on the screen
        and outline each box with a black edge line
        """
        piece = self.name[self.rotation]
        for x in range(SHAPE_SIZE):
            for y in range(SHAPE_SIZE):
                if piece[y][x] != EMPTY_BOX:
                    # This line draws all the squares on the screen
                    pygame.draw.rect(DISPLAY_SURFACE, SHAPE_COLOR[self.name],
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y,
                                      BOX_SIZE,
                                      BOX_SIZE))
                    # The following lines outline each square with 1 pixel black line
                    # Top vertical
                    pygame.draw.line(DISPLAY_SURFACE, BLACK,
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y),
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x + BOX_SIZE,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y), 1)
                    # Right horizontal
                    pygame.draw.line(DISPLAY_SURFACE, BLACK,
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x + BOX_SIZE,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y),
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x + BOX_SIZE,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y + BOX_SIZE),
                                     1)
                    # Left horizontal
                    pygame.draw.line(DISPLAY_SURFACE, BLACK,
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y),
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y + BOX_SIZE),
                                     1)
                    # Bottom vertical
                    pygame.draw.line(DISPLAY_SURFACE, BLACK,
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y + BOX_SIZE),
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x + BOX_SIZE,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y + BOX_SIZE),
                                     1)

    def deleteShapeFromScreen(self):
        """
        This method deletes the shape from the screen
        """
        piece = self.name[self.rotation]
        for x in range(SHAPE_SIZE):
            for y in range(SHAPE_SIZE):
                if piece[y][x] != EMPTY_BOX:
                    # This line erases all the squares
                    pygame.draw.rect(DISPLAY_SURFACE, BLACK,
                                     (x * BOX_SIZE + TOP_X + BOX_SIZE * self.pos_x,
                                      y * BOX_SIZE + TOP_Y + BOX_SIZE * self.pos_y,
                                      BOX_SIZE, BOX_SIZE))


    def deleteShapeFromMatrix(self):
        """
        This method deletes the shape from the matrix
        """
        piece = self.name[self.rotation]
        for x in range(SHAPE_SIZE):
            for y in range(SHAPE_SIZE):
                if x + self.pos_x < (MATRIX_WIDTH - 1) \
                        and y + self.pos_y < (MATRIX_HEIGHT -1) \
                        and piece[y][x] == FULL_BOX:
                    MATRIX[y + self.pos_y][x + self.pos_x] = COLOR_COLOR[BLACK]
        resetMatrix()

    def returnMaxWidth(self):
        """
        Each shape is 4 x 4, but the actual width is different
        for each shape, e.g. horizontal "I" shape is 4 boxes in width
        but the same vertical shape is 2 boxes in width
        This method returns the width from the left. See the shape definition above
        """
        max_x = 0
        piece = self.name[self.rotation]
        for x in range(SHAPE_SIZE):
            for y in range(SHAPE_SIZE):
                if piece[x][y] == FULL_BOX and y > max_x :
                    max_x = y
        return max_x

    def returnMinWidth(self):
        """
        Each shape is 4 x 4, but the actual width is different
        for each shape, e.g. horizontal "I" shape is 4 boxes in width
        but the same vertical shape is 2 boxes in width
        This method returns the width from right. See the shape definition above
        """
        min_x = SHAPE_SIZE
        piece = self.name[self.rotation]
        for x in range(SHAPE_SIZE):
            for y in range(SHAPE_SIZE):
                if piece[x][y] == FULL_BOX and y < min_x :
                    min_x = y
        return min_x

    def returnMaxHeight(self):
        """
        Each shape is 4 x 4, but the actual height is different
        for each shape, e.g. horizontal "I" shape is 2 boxes in width
        but the same vertical shape is 4 boxes in height
        This method returns the height. See the shape definition above
        """
        max_y = 0
        piece = self.name[self.rotation]
        for x in range(SHAPE_SIZE):
            for y in range(SHAPE_SIZE):
                if piece[x][y] == FULL_BOX and x > max_y :
                    max_y = x
        return max_y

    def returnMaxHeightPerColumn(self, column):
        """
        Each shape is 4 x 4, but the actual height is different per column
        for each shape, e.g. horizontal "T" shape can be 1 boxes or 3 boxes in height
        This method return the max height and that's the box that's the lowest in a shape
        """
        max_y = 0
        piece = self.name[self.rotation]
        for y in range(SHAPE_SIZE):
            if piece[y][column] == FULL_BOX and y > max_y:
                max_y = y
        return max_y

    def moveLeft(self):
        """
        Move the shape left if possible
        """
        if isAvailableLeft(self):
            self.deleteShapeFromMatrix()
            self.deleteShapeFromScreen()
            self.pos_x -= 1
            updateShapeInMatrix(self)
            self.drawShapeOnScreen()

    def moveRight(self):
        """
        Move the shape right if possible
        """
        if isAvailableRight(self):
            self.deleteShapeFromMatrix()
            self.deleteShapeFromScreen()
            self.pos_x += 1
            updateShapeInMatrix(self)
            self.drawShapeOnScreen()

    def moveDown(self):
        """
        Move the shape down if possible
        """
        if isAvailableDown(self):
            self.deleteShapeFromMatrix()
            self.deleteShapeFromScreen()
            self.pos_y += 1
            updateShapeInMatrix(self)
            self.drawShapeOnScreen()

    def moveRotate(self):
        """
        Rotate the shape if possible
        """
        if isAvailableRotate(self):
            self.deleteShapeFromMatrix()
            self.deleteShapeFromScreen()
            self.rotation += 1
            if self.rotation == 4:
                self.rotation = 0
            updateShapeInMatrix(self)
            self.drawShapeOnScreen()

def resetMatrix():
    """
    Updates the edges of the matrix in memory, that's the YELLOW borders
    """
    for x in range(0, MATRIX_HEIGHT):
        MATRIX[x][0] = COLOR_COLOR[YELLOW]
        MATRIX[x][MATRIX_WIDTH - 1] = COLOR_COLOR[YELLOW]
    for y in range(0, MATRIX_WIDTH):
        MATRIX[0][y] = COLOR_COLOR[YELLOW]
        MATRIX[MATRIX_HEIGHT - 1][y] = COLOR_COLOR[YELLOW]

def isAvailable(Shape):
    """
    Is the shape available to be moved in the matrix
    Checks the new position initially when dropping it for the first time
    """
    allowed = True
    piece = Shape.name[Shape.rotation]
    for x in range(SHAPE_SIZE):
        for y in range(SHAPE_SIZE):
            if piece[y][x] == FULL_BOX and \
                            MATRIX[y + Shape.pos_y][x + Shape.pos_x] >= COLOR_COLOR[YELLOW]:
                allowed = False
                break
    return allowed

def isAvailableLeft(Shape):
    """
    Is the shape available to be moved left in the matrix
    """
    allowed = True
    piece = Shape.name[Shape.rotation]
    for y in range(SHAPE_SIZE):
        if piece[y][Shape.returnMinWidth()] == FULL_BOX \
                and MATRIX[y + Shape.pos_y][Shape.pos_x +Shape.returnMinWidth() - 1] >= COLOR_COLOR[YELLOW] :
            allowed = False
            break
    return allowed

def isAvailableRight(Shape):
    """
    Is the shape available to be moved right in the matrix
    """
    allowed = True
    piece = Shape.name[Shape.rotation]
    for y in range(SHAPE_SIZE):
        if piece[y][Shape.returnMaxWidth()] == FULL_BOX \
                and MATRIX[y + Shape.pos_y][Shape.pos_x + Shape.returnMaxWidth() + 1] >= COLOR_COLOR[YELLOW]:
            allowed = False
            break
    return allowed

def isAvailableRotate(Shape):
    """
    Is the shape available to be moved rotated in the matrix
    """
    allowed = True
    oldMaxWidth= Shape.returnMaxWidth()
    oldMinWidth = Shape. returnMinWidth()
    oldMaxHeight = Shape.returnMaxHeight()
    oldRotation = Shape.rotation
    Shape.rotation += 1
    if Shape.rotation == 4:
        Shape.rotation = 0
    newMaxWidth = Shape.returnMaxWidth()
    newMinWidth = Shape.returnMinWidth()
    newMaxHeight = Shape.returnMaxHeight()
    if (newMinWidth - oldMinWidth) + Shape.pos_x < 0 \
            or (newMaxWidth - oldMaxWidth) + Shape.pos_x >= (MATRIX_WIDTH - 2):
        allowed = False
    if (newMaxHeight - oldMaxHeight) + Shape.pos_y >= (MATRIX_HEIGHT -2):
        allowed = False
    Shape.rotation = oldRotation
    return allowed

def isAvailableDown(Shape):
    """
    Is the shape available to be moved down in the matrix
    """
    allowed = True
    piece = Shape.name[Shape.rotation]
    for x in range(SHAPE_SIZE):
        if piece[Shape.returnMaxHeightPerColumn(x)][x] == FULL_BOX and \
                        MATRIX[Shape.pos_y + Shape.returnMaxHeightPerColumn(x) + 1][x + Shape.pos_x] >= COLOR_COLOR[YELLOW] :
            allowed = False
            break
    return allowed

def updateShapeInMatrix(Shape):
    """
    Updates the matrix with the moved shape
    """
    piece = Shape.name[Shape.rotation]
    for x in range(SHAPE_SIZE):
        for y in range(SHAPE_SIZE):
            if piece[y][x] == "X" and (y + Shape.pos_y) in range (1, MATRIX_HEIGHT - 1) \
                    and (x + Shape.pos_x) in range(1, MATRIX_WIDTH - 1) \
                    and MATRIX[y + Shape.pos_y][x + Shape.pos_x] == COLOR_COLOR[BLACK]:
                MATRIX[y + Shape.pos_y][x + Shape.pos_x] = COLOR_COLOR[SHAPE_COLOR[Shape.name]]
    resetMatrix()

def drawMatrixOnScreen():
    """
    Draws four bars where the game occurs
    """
    # Left bar
    pygame.draw.rect(DISPLAY_SURFACE, YELLOW, (TOP_X,
                                               TOP_Y,
                                               BOX_SIZE,
                                               MATRIX_HEIGHT * BOX_SIZE + 1))
    # Right bar
    pygame.draw.rect(DISPLAY_SURFACE, YELLOW, (TOP_X + (MATRIX_WIDTH - 1) * BOX_SIZE + 1,
                                               TOP_Y,
                                               BOX_SIZE,
                                               MATRIX_HEIGHT * BOX_SIZE + 1))
    # Bottom bar
    pygame.draw.rect(DISPLAY_SURFACE, YELLOW, (TOP_X + BOX_SIZE,
                                               TOP_Y + (MATRIX_HEIGHT - 1) * BOX_SIZE + 1,
                                               (MATRIX_WIDTH - 2) * BOX_SIZE + 1,
                                               BOX_SIZE))
    # Top bar
    pygame.draw.rect(DISPLAY_SURFACE, YELLOW, (TOP_X + BOX_SIZE,
                                               TOP_Y,
                                               (MATRIX_WIDTH - 2) * BOX_SIZE + 1,
                                               BOX_SIZE))

def checkFullLine():
    """
    Check if there is a full horizontal line in the matrix.
    """
    for x in range(MATRIX_HEIGHT - 2, 0, - 1):
        if 0 not in MATRIX[x]:
            return x

def printText(msg, FONT, x_cor, y_cor, b_color, f_color):
    """
    Writes Text on the screen
    """
    text = FONT.render(msg, True, b_color, f_color)
    textRect = text.get_rect()
    textRect.centerx = x_cor
    textRect.centery = y_cor
    DISPLAY_SURFACE.blit(text, textRect)

def drawRectangle(x_cor, y_cor, width, height, color):
    """
    Draws rectangle on the screen
    """
    pygame.draw.rect(DISPLAY_SURFACE, color, (x_cor, y_cor, width, height))

def printScore(score):
    """
    Prints score on the screen
    """
    printText('SCORE:', FONT_SMALL, 490, 240, WHITE, BLACK)
    printText(str(score), FONT_SMALL, 580, 240, WHITE, BLACK)

def shiftShapesOnScreen(row):
    """
    Shift shapes down on the screen when one line is full and collapses
    """
    for col in range(1, MATRIX_WIDTH -1):
        pygame.draw.rect(DISPLAY_SURFACE,
                         find_color[MATRIX[row][col]],
                         (TOP_X + BOX_SIZE * col,
                          TOP_Y + BOX_SIZE * row,
                          BOX_SIZE,
                          BOX_SIZE))

        # This line outlines each square with 1 pixel black line
        # Top vertical
        pygame.draw.line(DISPLAY_SURFACE, BLACK,
            (TOP_X + BOX_SIZE * col,
            TOP_Y + BOX_SIZE * row),
            (TOP_X + BOX_SIZE * col + BOX_SIZE,
            TOP_Y + BOX_SIZE * row), 1)
        # Right horizontal
        pygame.draw.line(DISPLAY_SURFACE, BLACK,
            (TOP_X + BOX_SIZE * col + BOX_SIZE,
            TOP_Y + BOX_SIZE * row),
            (TOP_X + BOX_SIZE * col + BOX_SIZE,
            TOP_Y + BOX_SIZE * row + BOX_SIZE),
            1)
        # Left horizontal
        pygame.draw.line(DISPLAY_SURFACE, BLACK,
            (TOP_X + BOX_SIZE * col,
            TOP_Y + BOX_SIZE * row),
            (TOP_X + BOX_SIZE * col,
            TOP_Y + BOX_SIZE * row + BOX_SIZE),
            1)
        # Bottom vertical
        pygame.draw.line(DISPLAY_SURFACE, BLACK,
            (TOP_X + BOX_SIZE * col,
            TOP_Y + BOX_SIZE * row + BOX_SIZE),
            (TOP_X + BOX_SIZE * col + BOX_SIZE,
            TOP_Y + BOX_SIZE * row + BOX_SIZE),
            1)

def shiftShapesInMatrix(row):
    """
    Shift shapes down in the matrix when one line is full and collapses
    """
    while row > 1:
        for xx in range(1, MATRIX_WIDTH):
            MATRIX[row][xx] = MATRIX[row - 1][xx]
        shiftShapesOnScreen(row)
        row -= 1

def main():
    global FPS_CLOCK, DISPLAY_SURFACE, FONT_BIG, FONT_SMALL, FONT_SUPER_SMALL, SCORE
    pygame.init()
    FPS_CLOCK = pygame.time.Clock()
    DISPLAY_SURFACE = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
    pygame.display.set_caption('KAtrix')
    FONT_BIG = pygame.font.SysFont(None, 44)
    FONT_SMALL = pygame.font.SysFont(None, 24)
    FONT_SUPER_SMALL = pygame.font.SysFont(None, 12)
    DISPLAY_SURFACE.fill(BLACK)
    resetMatrix()
    drawMatrixOnScreen()
    SCORE = 0
    printScore(SCORE)
    printText('Program by: Kliment ANDREEV, 2015', FONT_SUPER_SMALL, 320, 470, SILVER, BLACK)
    # MAIN GAME LOOP
    while True:
        new_shape = Shape(SHAPES[random.randint(0, len(SHAPES) - 1)], ROTATE_0_DEGREES, 1, START_COL)
        NewPiece = True
        if isAvailable(new_shape):
            Shape.drawShapeOnScreen(new_shape)
            updateShapeInMatrix(new_shape)
        else:
            NewPiece=False
            Shape.drawShapeOnScreen(new_shape)
            drawRectangle(TOP_X, WINDOW_HEIGHT / 2 - 50, 241, 160, BLUE)
            printText("G A M E  O V E R", FONT_BIG, WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2 + 30, YELLOW, BLUE)
            pygame.display.update()
            pygame.time.delay(3000)
            pygame.quit()
            sys.exit()
        while NewPiece:
            for event in pygame.event.get():
                if event.type == QUIT:
                    pygame.quit()
                    sys.exit()
                if event.type == KEYDOWN:
                    if (event.key == K_LEFT):
                        Shape.moveLeft(new_shape)
                    elif (event.key == K_RIGHT):
                        Shape.moveRight(new_shape)
                    elif (event.key == K_UP):
                        Shape.moveRotate(new_shape)
                    elif (event.key == K_DOWN):
                        Shape.moveDown(new_shape)
                    elif (event.key == K_SPACE):
                        while isAvailableDown(new_shape):
                            Shape.moveDown(new_shape)
                        NewPiece = False
                        while checkFullLine() > 0:
                            SCORE += 10
                            printScore(SCORE)
                            shiftShapesInMatrix(checkFullLine())
            pygame.display.update()
            FPS_CLOCK.tick(FPS)

if __name__ == '__main__':
    main()

pass variables between two forms in Visual C++

This example will show you how to pass variables between two forms in Visual C++. We’ll create two forms, drop a button and a text box on the first form and a label box on the second form. When we start the program, we can type something in the text box. Once we click the button, the second form will show up with the label containing the text from the text box that’s on the first form.
First, let’s create a project in VC++ 2008. Click File | New, then Visual C++ and then Windows Forms Application. From the Toolbox, drag and drop, a button and a text box. Next, from the Solution Explorer on the right, right-click the name of your project, choose Add, New Item and then Windows Form. When the second form appears, drag and drop a label on the form. Save all files. Open the source for the first form (probably Form1.h) and right after the #pragma statement insert:

#include "Form2.h"
// Make sure that the source file name is correct

Then, switch to the design mode for the first form, double-click the button control and put the following lines between the brackets. This is an event-handler that runs when the button is clicked.

Form2^ newform = gcnew Form2;
newform -> strSomething = textBox1->Text
if (newform->ShowDialog(this) == ::DialogResult::OK) delete newform;

Switch to the source of the second form and define the string strSomething as shown. That’s the variable that we are using to pass values.

public:
		Form2(void)
		{
			InitializeComponent();
			//
			//TODO: Add the constructor code here
			//
		}    

		        String^ strSomething;

	protected:
		///

Now, switch to the desing mode of the second form, double-click anywhere on the form to invoke the event-handler that runs when the form is loaded. Here, insert the following statement.

label1->Text = strSomething;

As you can probably see, we created the second form with an extra parameter of string type. When we created this form within the source of the first form, we passed the value of textBox1 to that parameter and then in the second form, we take that value and assign it to the label. We can’t use something like this:

newform->label1->Text = textBox1->Text;

That’s because label1 is a private member of the Form2 class and strSomething is a public member.

System uptime – Visual C++ utility

It’s been a while when I was programming in C, maybe more than 15 years. I decided to refresh my memory and create a small console application that will give me the system uptime and the date and time when the OS was installed. This small app should work on all platforms after Windows 2000.

I used Visual C++ 2008 and this program compiles without any errors or warnings. While I was browsing for the solutions implemented in this program, I found that some of the proposed solutions won’t compile on VC 2008.

Start VC2008, choose File | New | Project. For Project Types choose Win32 and then Win32 Console Application. You can copy and paste the whole source below. This is a simple console application and there are no extra header files or any resource files. You can also, download the executable that’s attached.

#include "stdafx.h"
#include <windows.h>       

char* GetUptime()
{
   int tickCount, nTime[5];
   static char szUptime [1000];
   tickCount = GetTickCount();
   nTime[0] = tickCount / 1000 % 60; // Seconds
   nTime[1] = tickCount / 1000 / 60 % 60; // Minutes
   nTime[2] = tickCount / 1000 / 60 / 60 % 24; // Hours
   nTime[3] = tickCount / 1000 / 60 / 60 / 24 % 7; // Days
   nTime[4] = tickCount / 1000 / 60 / 60 / 24 / 7 % 52; // Weeks
   memset(szUptime, 0, sizeof(szUptime));       

   for(int i = 4; i >= 0; i--)
   {
      char* szLabel;
      char tmpUptime[3];       

      if (i == 4) (nTime[4] > 1 || nTime[4] == 0) ? szLabel = " Weeks, " : szLabel = " Week, ";
      else if (i == 3) (nTime[3] > 1 || nTime[3] == 0) ? szLabel = " Days, " : szLabel = " Day, ";
      else if (i == 2) (nTime[2] > 1 || nTime[2] == 0) ? szLabel = " Hours, " : szLabel = " Hour, ";
      else if (i == 1) (nTime[1] > 1 || nTime[1] == 0) ? szLabel = " Minutes, " : szLabel = " Minute, ";
      else if (i == 0) (nTime[0] > 1 || nTime[0] == 0) ? szLabel = " Seconds" : szLabel = " Second";
      memset(tmpUptime, 0, sizeof(tmpUptime));
      _itoa_s(nTime[i], tmpUptime, 3, 10);
      strcat_s(szUptime, 1000, tmpUptime);
      strcat_s(szUptime, 1000, szLabel);
      }       

   return szUptime;
}       

char* GetInstalled()
{
   HANDLE hFile;
   WIN32_FIND_DATA FileInformation;
   SYSTEMTIME st;
   char tmpChar[12];
   char* month = "";
   char* comma = ", ";
   char* space = " ";
   char* colon = ":";
   TCHAR winDir[MAX_PATH];
   static char szInstalled[1000];
   GetWindowsDirectory(winDir, MAX_PATH);
   hFile = ::FindFirstFile(winDir, &FileInformation);
   FileTimeToSystemTime(&FileInformation.ftCreationTime, &st);
   switch (st.wMonth)
   {
      case 1:
      month = "January ";
      break;
      case 2:
      month ="February ";
      break;
      case 3:
      month = "March ";
      break;
      case 4:
      month ="April ";
      break;
      case 5:
      month = "May ";
      break;
      case 6:
      month ="June ";
      break;
      case 7:
      month = "July ";
      break;
      case 8:
      month ="August ";
      break;
      case 9:
      month = "September ";
      break;
      case 10:
      month ="October ";
      break;
      case 11:
      month = "November ";
      break;
      case 12:
      month ="December ";
      break;
      default:
      break;
   }       

   strcat_s(szInstalled, 1000, month);
   _itoa_s(st.wDay, tmpChar, 12, 10);
   strcat_s(szInstalled, 1000, tmpChar);
   strcat_s(szInstalled, 1000, comma);
   _itoa_s(st.wYear, tmpChar, 12, 10);
   strcat_s(szInstalled, 1000, tmpChar);
   strcat_s(szInstalled, 1000, space);
   _itoa_s(st.wHour, tmpChar, 12, 10);
   strcat_s(szInstalled, 1000, tmpChar);
   strcat_s(szInstalled, 1000, colon);
   _itoa_s(st.wMinute, tmpChar, 12, 10);
   strcat_s(szInstalled, 1000, tmpChar);
   strcat_s(szInstalled, 1000, colon);
   _itoa_s(st.wSecond, tmpChar, 12, 10);
   strcat_s(szInstalled, 1000, tmpChar);
   return szInstalled;
}
int _tmain(int argc, _TCHAR* argv[])
{
      char* upTime;
      char* installed;
      printf("%s\n", "-----------------------------------------------------------------");
      printf("%s\n", "KInfo v0.1 -- Program by Kliment Andreev -- Public Domain -- 2009");
      printf("%s\n", "-----------------------------------------------------------------");
      upTime = GetUptime();
      printf("%s%s"," System Uptime: ", upTime);
      installed = GetInstalled();
      printf("\n%s%s\n","System Installed: ", installed);
      return 0;
}

kinfo2

Enumerating files and folders in Visual C++

This is a program that will enumerate all files, folders and sub-folders under a given folder. Folders with no access will be skipped and an *ERROR* message will be recorded on the console. Attached is the executable file (link at the bottom).

#include "stdafx.h"    

using namespace System;
using namespace System::Collections;
using namespace System::IO;    

int main(array ^args)
{
	array^ strSubFolders = gcnew array(20);
	array^ strFiles = gcnew array(20);
	Stack^ objFolders = gcnew Stack;
	Object^ objItem;
	String^ strSourceFolder;
	String^ strCurrentFolder;
	String^ strEachFile;
	String^ strEachFolder;
	String^ strArgs;
	int ArgsCounter=0,
		FileCounter=0,
		FolderCounter=0,
		ErrorCounter=0;    

	for each (strArgs in args) ArgsCounter++;    

	if (ArgsCounter==0) {
		Console::WriteLine("Usage: eff , enumerates all files and folders under ");
		Console::WriteLine("Public domain - Program by Kliment Andreev, 2009");
		return 0;
	}    

	strSourceFolder = args[0];    

	if (!System::IO::Directory::Exists(strSourceFolder)) {
		Console::WriteLine("Folder doesn't exist!");
		return 0;
	}    

	objFolders->Push(strSourceFolder);	    

	while (objFolders->Count > 0) {
		objItem = objFolders->Pop();
		strCurrentFolder = safe_cast(objItem);
		Console::WriteLine("{0}",strCurrentFolder);    

		try {
			strSubFolders = Directory::GetDirectories(strCurrentFolder);
			strFiles = Directory::GetFiles(strCurrentFolder);    

			for each (strEachFile in strFiles){
				FileInfo^ fi = gcnew FileInfo(strEachFile);
				Console::WriteLine("{0}\\{1} ",fi->DirectoryName,fi->Name);
				FileCounter++;
			}    

			for each (strEachFolder in strSubFolders) {
				objFolders->Push(strEachFolder);
				FolderCounter++;
			}    

		}    

		catch(System::Exception ^ex) {
			Console::WriteLine("*ERROR* {0}",ex->Message);
			ErrorCounter++;
		}
	}    

	Console::WriteLine("\nTotal: {0} files, {1} folders and {2} errors.", \ 
FileCounter, FolderCounter, ErrorCounter);    

    return 0;
}

eff

C#: Recreate directory structure

I made this small utility to help me recreate a directory structure for a project that I was working on. For example, you want to create the same directory structure as C:\Windows but under the D:\ drive. In order to do that, you have to export the directory structure to a file (dirstruct -r c:\windows > file.txt) and then create the directory structure using dirstruct -w file.txt d:\. Expand for the source.

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;

namespace dirstruct
{
    class Program
    {
        static void Main(string[] args)
        {
            void PrintUsage()
            {
                string strDash = new String('-', 98);
                Console.WriteLine(strDash);
                Console.WriteLine("dirstruct -r <directory>        - Lists all directories and subdirectories.");
                Console.WriteLine("                                  If no <directory> is given, uses the current directory.");
                Console.WriteLine("dirstruct -w <file> <directory> - Recreates the directory structure under the specified directory.");
                Console.WriteLine("                                  If no <directory> is given, uses the current directory.");
                Console.WriteLine(strDash);
                Console.WriteLine("Examples:  dirstruct -r C:\\users > mydirs.txt");
                Console.WriteLine("           dirstruct -w mydirs.txt D:\\");
                Console.WriteLine("           Recreates the structure C:\\users under D:\\");
                Console.WriteLine("           You'll get D:\\users structure same as C:\\users");
                Console.WriteLine(strDash);
                Console.WriteLine("dirstruct : Kliment Andreev - 2020 - Simplified BSD License");
            }

            void CreateDirectories(string strFN, string strEP)
            {
                string strLine;
                System.IO.StreamReader file = new System.IO.StreamReader(@strFN);
                while ((strLine = file.ReadLine()) != null)
                {
                    string strDirectoryName = strEP + strLine.Substring(2);
                    try
                    {
                        DirectoryInfo di = Directory.CreateDirectory(strDirectoryName);
                        Console.WriteLine(strDirectoryName);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("The process failed: {0}", e.ToString());
                    }
                }
                file.Close();
            }

            string strEntryPath = @"";
            string strFileName = @"";
            string strOperation = "";
            int intErr = 0;
            if (args.Length == 0)
            {
                PrintUsage();
                intErr = 0;
                Environment.Exit(intErr);
            }
            if (args.Length > 3)
            {
                PrintUsage();
                intErr = 1;
                Environment.Exit(intErr);
            }
            if (args[0].Length != 2)
            {
                PrintUsage();
                intErr = 1;
                Environment.Exit(intErr);
            }
            switch (args[0].Substring(0, 2))
            {
                case "-r":
                    if (args.Length == 1)
                    {
                        strEntryPath = Directory.GetCurrentDirectory();
                    }
                    if (args.Length == 2)
                    {
                        strEntryPath = args[1];
                    }
                    if (args.Length == 3)
                    {
                        Console.WriteLine("Too many arguments.");
                        intErr = 1;
                    }
                    strOperation = "R";
                    break;
                case "-w":
                    if (args.Length == 1)
                    {
                        intErr = 1;
                        Console.WriteLine("File name missing.");
                    }
                    if (args.Length == 2)
                    {
                        strFileName = args[1];                        
                    }
                    if (args.Length == 3)
                    {
                        strFileName = args[1];
                        strEntryPath = args[2];
                    }
                    strOperation = "W";
                    break;
                case "-h":
                    PrintUsage();
                    break;
                default:
                    Console.WriteLine("Unknown argument.");
                    intErr = 1;
                    break;
            }
            if (intErr == 1) Environment.Exit(intErr);
            if ((!Directory.Exists(@strEntryPath)) & (strEntryPath !=""))
            {
                Console.WriteLine(@strEntryPath + " does not exists or incorrect.");
                intErr = 1;
            }
            if ((!File.Exists(@strFileName)) & (strOperation == "W"))
            {
                Console.WriteLine(@strFileName + " does not exists or incorrect.");
                intErr = 1;
            }
            if (intErr == 1) Environment.Exit(intErr);
            if (strOperation == "R")
            {
                List<string> listDirs = ListDirectories.GetDirectories(@strEntryPath);
                foreach (string strDirectory in listDirs)
                {
                    Console.WriteLine(strDirectory);
                }
            }
            if ((strOperation == "W") && (args.Length == 2))
            {
                Console.WriteLine("You will create a directory structure in the current directory.");
                Console.WriteLine("Are you sure you want to continue (Y/N)?");
                string strYN = Console.ReadLine().ToUpper();
                if (strYN == "Y")
                {
                    strEntryPath = Directory.GetCurrentDirectory();
                    CreateDirectories(strFileName, strEntryPath);
                }
                else
                {
                    Console.WriteLine("Exiting. No changes were made.");
                    Environment.Exit(0);
                }
            }
            if ((strOperation == "W") && (args.Length == 3))
            {
                Console.WriteLine("You will create a directory structure under " + strEntryPath);
                Console.WriteLine("Are you sure you want to continue (Y/N)?");
                string strYN = Console.ReadLine().ToUpper();                
                if (strYN == "Y")
                {
                    CreateDirectories(strFileName, strEntryPath);
                }
                else
                {
                    Console.WriteLine("Exiting. No changes were made.");
                    Environment.Exit(0);
                }
            }

        }
    }
    public class ListDirectories
    {
        public static List<string> GetDirectories(string strPath, string strSearchPattern = "*",
            SearchOption searchOption = SearchOption.AllDirectories)
        {
            if (searchOption == SearchOption.TopDirectoryOnly)
                return Directory.GetDirectories(strPath, strSearchPattern).ToList();

            List<string> listDirectories = new List<string>(GetDirectories(strPath, strSearchPattern));

            for (var i = 0; i < listDirectories.Count; i++)
                listDirectories.AddRange(GetDirectories(listDirectories[i], strSearchPattern));

            return listDirectories;
            
        }

        private static List<string> GetDirectories(string strPath, string searchPattern)
        {
            try
            {
                return Directory.GetDirectories(strPath, searchPattern).ToList();
            }
            catch (UnauthorizedAccessException)
            {
                return new List<string>();
            }
        }
    }
}

Dockerize a Node.js application

My Node.js app has index.html, server.js and styles.css files. First, initialize the app and enter the values for the app.

npm init

Install all the dependent modules for the app.

npm install express socket.io --save

Create the Dockerfile.

FROM node:18

# Create app directory
WORKDIR /usr/src/app

# Install app dependencies
# A wildcard is used to ensure both package.json AND package-lock.json are copied
# where available (npm@5+)
COPY package*.json ./

RUN npm install
# If you are building your code for production
# RUN npm ci --only=production

# Bundle app source
COPY . .

EXPOSE 3000
CMD [ "node", "server.js" ]

Create a .dockerignore file to omit some of the files that are not necessary.

cat <<EOF > .dockerignore
node_modules
npm-debug.log
EOF

Build the image.

docker build . -t <your username>/node-web-app

Check the image.

docker images

Test the image.

docker run -p 3000:3000 -d <your username>/node-web-app

Is the container running?

docker ps

Check the logs for the container.

docker logs <container id>

If needed, attach to the shell of the running container.

docker exec -it <container id> /bin/bash

HTML/CSS/JavaSccript boilerplate

index.html

<!DOCTYPE html>
<html>
  <head>
    <title>HTML 5 Boilerplate</title>
    <link rel="stylesheet" href="style.css" />
  </head>
  <body>
    <p>HTML</p>
    <script src="script.js"></script>
  </body>
</html>

style.css

p {
  background-color: yellow;
}

script.js

'use strict';

console.log('JavaScript');