Forem: ignazio gandolfo

how to establish an SSH tunnel using Cloudflare to expose your local web server to the internet

ignazio gandolfo — Thu, 02 Feb 2023 16:57:07 +0000

Do you want to host your website or web application on your local machine, but don't want to deal with the hassle of setting up a public IP address or a dynamic DNS service? Then this guide is for you! In this article, we will show you how to securely expose your local web server to the world using an SSH tunnel through Cloudflare. This setup provides a secure and convenient way to access your local web server from anywhere in the world, without having to worry about managing a public IP address or setting up dynamic DNS.

Prerequisites

Before getting started, you should have the following:

A local machine running a web server, such as Apache or Nginx.
An account with Cloudflare.
A domain name that you can associate with your Cloudflare account.

Additionally, this guide assumes that you have a default installation of OpenSSH. If you have a firewall or other security measures in place on your local machine, you may need to configure them to allow incoming traffic to your web server.

Step 1: Set up a Cloudflare account and add your domain

Go to Cloudflare.com, sign up for a free account, and log in.
Click on the "Add a website" button.
Enter your domain name and follow the on-screen instructions to add your domain to Cloudflare.

Step 2: Configure your local machine to allow incoming SSH traffic

Open a terminal on your local machine.
Run the following command to allow incoming SSH traffic:

sudo ufw allow 22/tcp

Step 3: Set up an SSH key pair on your local machine

Open a terminal on your local machine.
Run the following command to generate an SSH key pair:

ssh-keygen -t rsa

Follow the on-screen instructions to create the key pair.
Copy the contents of the public key, which is usually located in ~/.ssh/id_rsa.pub, to your clipboard.

Step 4: Add the public key to your Cloudflare account

Log in to your Cloudflare account.
Navigate to the "Crypto" section.
Scroll down to the "SSH/TLS Certificates" section.
Click the "Add Certificate" button.
Paste the public key you copied in step 3 into the "Public Key" field.
Give the certificate a name and click the "Add Certificate" button.

Step 5: Create an SSH tunnel on your local machine

Open a terminal on your local machine.
Run the following command to create the SSH tunnel:

ssh -R 80:localhost:80 <username>@<domain>.ssh.cloudflare.com

Replace <username> with your Cloudflare username, and <domain> with your domain name.
The -R flag tells OpenSSH to create a reverse tunnel from port 80 on the Cloudflare servers to port 80 on your local machine.

Step 6: Test the connection to your local web server

Open a web browser and go to http://<domain>.
You should see the default page of your web server, which is hosted on your local machine.

Once the SSH connection is established, you can now test the connection to your local web server. Testing the connection ensures that the setup is complete and you can now use your domain name to access your local web server from anywhere in the world.

Conclusion

Exposing your local web server to the world is a convenient and secure way to access your web server from anywhere, without having to worry about managing a public IP address or setting up dynamic DNS. Using an SSH tunnel through Cloudflare provides a secure and easy-to-set-up solution for accessing your local web server from anywhere in the world.

Note that this setup is intended for development and testing purposes only. If you want to host a public-facing website, you should consider using a more robust solution, such as a dedicated server or a cloud-based hosting service.

Binary Search Java

ignazio gandolfo — Fri, 30 Dec 2022 00:01:12 +0000

Binary search is a fundamental algorithm that is used to efficiently locate a specific element within a sorted array. It has a time complexity of O(log n), making it significantly faster than linear search, which has a time complexity of O(n).

In order to implement binary search in Java, it is important to first ensure that the array being searched is sorted. This can be done using a sorting algorithm such as quicksort or mergesort.

There are two common approaches to implementing binary search: iterative and recursive. The iterative approach involves using a loop to repeatedly divide the search interval in half until the element is found, while the recursive approach involves using a recursive function to continually divide the search interval in half until the element is found.

Here is an example of binary search implemented using an iterative approach:

public class BinarySearch {
  public static int binarySearch(int[] arr, int x) {
    int low = 0;
    int high = arr.length - 1;
    int mid;

    while (low <= high) {
      mid = low + (high - low) / 2;

      if (arr[mid] < x) {
        low = mid + 1;
      } else if (arr[mid] > x) {
        high = mid - 1;
      } else {
        return mid;
      }
    }

    return -1;
  }
}

And here is an example of binary search implemented using a recursive approach:

public class BinarySearch {
  public static int binarySearch(int[] arr, int x, int low, int high) {
    if (low > high) {
      return -1;
    }

    int mid = low + (high - low) / 2;

    if (arr[mid] < x) {
      return binarySearch(arr, x, mid + 1, high);
    } else if (arr[mid] > x) {
      return binarySearch(arr, x, low, mid - 1);
    } else {
      return mid;
    }
  }
}

It is important to thoroughly test your implementation of binary search to ensure that it is working correctly and efficiently. This can be done by testing with various sizes and types of input data, as well as edge cases such as the element not being present in the array.

By using binary search, you can improve the performance of your code and effectively locate specific elements within a sorted array.

Tic Tac Toe in terminal using Python

ignazio gandolfo — Tue, 22 Nov 2022 19:53:31 +0000

introduction

Welcome to this tutorial on how to create a tic-tac-toe game using Python. In this guide, we will go through all the steps necessary to build a functional tic-tac-toe game, including creating the grid, initializing the game, handling user input, and checking for a winner. By the end of this tutorial, you will have a fully-functional tic-tac-toe game that you can play with a friend or family member.

the Game

Tic-tac-toe is a paper-and-pencil game for two players who take turns marking the spaces in a three-by-three grid with X or O. The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row is the winner.

Gameplay

Tic-tac-toe is played on a three-by-three grid by two players, alternately placing the marks X and O in one of the nine spaces in the grid.

In the following example, the first player (X) wins the Game in seven steps:

Game of Tic-tac-toe, won by X
There is no universally-agreed rule as to who plays first, but in this article, the convention that X plays first is used.

Setting up the game in Python

To begin building our tic-tac-toe game in Python, we will first need to create the grid. We can represent the grid as a 3x3 matrix of integers, with each element representing a space on the grid. For example:

#        row_1   row_2   row_3
grid = [[0,0,0],[0,0,0],[0,0,0]]`

In this representation, each 0 represents an empty space. Later, these zeros will be replaced by 1 for player One and 2 for player Two.

Displaying the grid

To display the grid to the user, we can define a function that takes the grid as an argument and prints it to the console. To give the grid a more visually appealing look, we can create a dictionary of symbols to use for each element in the grid. For example:

grid_symbols = {
    0: ' ',
    1: 'X',
    2: 'O'
}

def display_grid(grid):
    row_1 = [grid_symbols[i] for i in grid[0]]
    row_2 = [grid_symbols[i] for i in grid[1]]
    row_3 = [grid_symbols[i] for i in grid[2]]
    print(f'      1   2   3  columns \n1  r {row_1}\n2  o {row_2}\n3  w {row_3}')

grid = [[1, 0, 0],
        [0, 2, 0],
        [0, 0, 0]]
display_grid(grid)

# Output:
#       1   2   3  columns
# 1  r ['X', ' ', ' ']
# 2  o [' ', 'O', ' ']
# 3  w [' ', ' ', ' ']

Handling user input

To allow the players to make a move, we can define a function that prompts the user for a row and column and marks the chosen space with the current player's symbol. The function should take the player as a parameter, which will be used to display which player's turn it is. The function should also check that the input is valid (i.e., a number between 1 and 3). For example:

def user_input(player):
    row_valid = False
    column_valid = False
    player = player
    While not row_valid:
        row = input(f"{player} please Choose a row: ")
        if row.isnumeric() and int(row) < 4 and int(row) >=1:
            row_valid = True
        else:print("Input invalid please choose a number from 1 to 3")
    While not column_valid:
        column = input(f"{player} please Choose a column: ")
        if column.isnumeric() and int(column) < 4 and int(column) >=1:
            column_valid = True
        else:print("Input invalid please choose a number from 1 to 3")
    return (int(row),int(column))

output: Player One, please Choose a row: or Player Two, please Choose a row:

step Three

create a function to check whether a position in the grid is already taken.

def check_grid(row,column):
    if grid[row][column] == 1 or grid[row][column] == 2:
        return False
    else: return True

step four

let's create the main loop where we can actually play the Game.

def start_game():
    player_one_choose = True
    while True:
        print_grid()
        if player_one_choose:
            player_row,player_column = user_input("Player One")
            if check_grid(player_row - 1,player_column - 1):
                grid[player_row - 1][player_column - 1] = 1
                clear()
                player_one_choose = False
            else:
                player_one_choose = True
                clear()
                print("The position is already taken")
        else:
            player_row,player_column = user_input("Player Two")
            if check_grid(player_row - 1,player_column - 1):
                grid[player_row - 1][player_column - 1] = 2
                clear()
                player_one_choose = True
            else:
                player_one_choose = False
                clear()
                print("The position is already taken")

The Game is now playable, but there's one final step. The last function is to determine who will be the winner of the Game.

step five

create a function to check the winner. Then implement the function inside the main loop of the Game.

def checkWinner(grid):
    for i in range(0,3):
        if grid[i][0] == grid[i][1] == grid[i][2] != 0:
            return grid[i][0]
        elif grid[0][i] == grid[1][i] == grid[2][i] != 0:
            return grid[0][i]

    if grid[0][0] == grid[1][1] == grid[2][2] != 0:
        return grid[0][0]
    elif grid[0][2] == grid[1][1] == grid[2][0] != 0:
        return grid[0][0]

    elif 0 not in grid[0] and 0 not in grid[1] and 0 not in grid[2]:
        return 0
    else:
        return -1

def start_game():
    player_one_choose = True
    while True:
        print_grid()
        if player_one_choose:
            player_row,player_column = user_input("Player One")
            if check_grid(player_row - 1,player_column - 1):
                grid[player_row - 1][player_column - 1] = 1
                clear()
                player_one_choose = False
            else:
                player_one_choose = True
                clear()
                print("The position is already taken")
        else:
            player_row,player_column = user_input("Player Two")
            if check_grid(player_row - 1,player_column - 1):
                grid[player_row - 1][player_column - 1] = 2
                clear()
                player_one_choose = True
            else:
                player_one_choose = False
                clear()
                print("The position is already taken")
        if checkWinner(grid) == 1:
            print("X WON!")
            print_grid()
            break
        if checkWinner(grid) == 2:
            print("O WON!")
            print_grid()
            break

Now that we have all the necessary functions, we can put them together to create a complete tic-tac-toe game. First, we will define a function to initialize the game, which will create an empty grid and set the current player to "X". Then, we will create a loop that will continue until the game is over (either because a player has won or the grid is full). Within the loop, we will call the display_grid and get_move functions to allow the players to make their moves and update the grid accordingly. Finally, we will call the check_winner function to see if the game is over and display the result.

Here is an example of what the complete code might look like:

full code

grid = [[0,0,0],[0,0,0],[0,0,0]]
import os
clear = lambda: os.system('cls')
clear()
grid_simbols = {
    0:'',
    1:'X',
    2:"O"
}

def start_game():
    player_one_choose = True
    while True:
        print_grid()
        if player_one_choose:
            player_row,player_column = user_input("Player One")
            if check_grid(player_row - 1,player_column - 1):
                grid[player_row - 1][player_column - 1] = 1
                clear()
                player_one_choose = False
            else:
                player_one_choose = True
                clear()
                print("The position is already taken")
        else:
            player_row,player_column = user_input("Player Two")
            if check_grid(player_row - 1,player_column - 1):
                grid[player_row - 1][player_column - 1] = 2
                clear()
                player_one_choose = True
            else:
                player_one_choose = False
                clear()
                print("The position is already taken")
        if checkWinner(grid) == 1:
            print("X WON!")
            print_grid()
            break
        if checkWinner(grid) == 2:
            print("O WON!")
            print_grid()
            break

def user_input(player):
    row_valid = False
    column_valid = False
    player = player
    while not row_valid:
        row = input(f"{player} please Choose a row: ")
        if row.isnumeric() and int(row) < 4 and int(row) >=1:
            row_valid = True
        else:print("Input invalid please choose a number from 1 to 3")
    while not column_valid:
        column = input(f"{player} please Choose a column: ")
        if column.isnumeric() and int(column) < 4 and int(column) >=1:
            column_valid = True
        else:print("Input invalid please choose a number from 1 to 3")
    return (int(row),int(column))

def print_grid():
    row_1 = [grid_simbols[i] for i in grid[0]]
    row_2 = [grid_simbols[i] for i in grid[1]]
    row_3 = [grid_simbols[i] for i in grid[2]]
    print(f'      1   2   3  columns \n1  r {row_1}\n2  o {row_2}\n3  w {row_3}')



def check_grid(row,column):
    if grid[row][column] == 1 or grid[row][column] == 2:
        return False
    else: return True

def checkWinner(grid):
    for i in range(0,3):
        if grid[i][0] == grid[i][1] == grid[i][2] != 0:
            return grid[i][0]
        elif grid[0][i] == grid[1][i] == grid[2][i] != 0:
            return grid[0][i]

    if grid[0][0] == grid[1][1] == grid[2][2] != 0:
        return grid[0][0]
    elif grid[0][2] == grid[1][1] == grid[2][0] != 0:
        return grid[0][0]

    elif 0 not in grid[0] and 0 not in grid[1] and 0 not in grid[2]:
        return 0
    else:
        return -1

start_game()

Conclusion

Congratulations! You have now created a fully-functional tic-tac-toe game using Python. You can try running the code and playing the game with a friend or family member to see how it works. You can also try adding additional features, such as a scoreboard to keep track of wins and losses, or the ability to play against the computer. I hope you have enjoyed this tutorial and learned something new about Python programming.