Pull Specific Folders Git

### Method 1: Use Sparse Checkout

1. **Navigate to Your Local Repository:**
Change to your local repository directory on your hosting server.

cd /path/to/your/repository

2. **Enable Sparse Checkout:**
Run the following command to enable sparse checkout:

git config core.sparseCheckout true

3. **Specify the Folders to Checkout:**
Create or edit the `.git/info/sparse-checkout` file to specify the folders you want to pull. For example, if you want to pull only the `folder1` and `folder2` directories, add these lines:

folder1/*
   folder2/*

4. **Pull from the Remote Repository:**
Now, pull the changes from the master branch of your remote repository:

git pull origin master

### Method 2: Manual Pull with Specific Folders

If you prefer not to use sparse checkout, you can also manually copy specific folders from your repository:

1. **Pull Changes:**
First, perform a regular pull to ensure your local repository is up to date:

git pull origin master

2. **Copy Specific Folders:**
Use the `rsync` or `cp` command to copy specific folders from your local repository to the desired location in your hosting environment:

rsync -av --progress /path/to/your/repository/folder1/ /path/to/your/hosting/folder1/
   rsync -av --progress /path/to/your/repository/folder2/ /path/to/your/hosting/folder2/

Alternatively, you can use the `cp` command:

cp -r /path/to/your/repository/folder1 /path/to/your/hosting/
   cp -r /path/to/your/repository/folder2 /path/to/your/hosting/

### Notes
– Adjust the paths based on your specific folder structure.
– If using sparse checkout, be aware that only the specified folders will be checked out; other files in the repository will not be present in your working directory.
– Consider using branches for different environments (e.g., staging, production) to manage changes more effectively.

By following these methods, you can pull only specific folders from your Bitbucket repository to your hosting environment.

### Option 1: Undo the Last Commit but Keep Changes

If you want to remove the last commit but keep the changes you made in that commit in your working directory, you can use the following command:

git reset --soft HEAD~1

– `HEAD~1` refers to the commit before the last one.
– The `–soft` option means that the changes will be kept staged in the index.

### Option 2: Undo the Last Commit and Discard Changes

If you want to completely remove the last commit along with all the changes, use:

git reset --hard HEAD~1

– The `–hard` option will discard all changes in the last commit, reverting your working directory to the state of the previous commit.

### Important Notes
– **Caution with `–hard`:** Using `–hard` will permanently delete any changes made in the last commit, so make sure you really want to do this.
– **Remote Repository:** If you have already pushed the commit to a remote repository (like Bitbucket), you will need to force push the changes after resetting:

git push origin master --force

Choose the method that fits your needs based on whether you want to keep or discard the changes.

git config core.sparseCheckout

### Steps to Check Sparse Checkout Status

1. **Open Terminal:** Navigate to your Git repository directory.

2. **Run the Command:**

git config core.sparseCheckout

3. **Interpret the Output:**
– If sparse checkout is enabled, the output will be `true`.
– If sparse checkout is not enabled, there will be no output or it may show as `false`.

### Additional Information

If you want to see the configuration details in your repository, you can also run:

git config --get-regexp sparseCheckout

This will show you all related configurations, including the status of `core.sparseCheckout`. If it returns `core.sparseCheckout true`, then sparse checkout is enabled.

If you need to enable or disable sparse checkout, you can use:

– To enable:

git config core.sparseCheckout true

– To disable:

git config core.sparseCheckout false

Using these commands, you can easily check and manage the sparse checkout feature in your Git repository.

Here are a few options to resolve this issue:

### Option 1: Commit Your Changes

If you want to keep your changes in `vite.config.js`, you can commit them:

git add vite.config.js
git commit -m "Save local changes before pulling"

After committing your changes, you can proceed with the pull:

git pull origin master

### Option 2: Stash Your Changes

If you want to temporarily set aside your local changes without committing them, you can stash them:

git stash

After stashing your changes, you can pull from the remote:

git pull origin master

Once the pull is successful, you can reapply your stashed changes with:

git stash pop

### Option 3: Discard Your Changes

If you don't need the local changes in `vite.config.js`, you can discard them:

git checkout -- vite.config.js

After discarding the changes, you can pull from the remote:

git pull origin master

### Summary

– **Commit**: If you want to keep your changes.
– **Stash**: If you want to temporarily set aside your changes.
– **Discard**: If you do not need the changes and want to revert to the last committed state.

Choose the option that best fits your situation.

### Option 1: Use `git reset` (Keep Local Changes)

If you want to revert the last pull but keep your local changes, you can use:

git reset --mixed HEAD@{1}

– `HEAD@{1}` refers to the state of the branch before the last pull.
– The `–mixed` option will reset the branch to the previous commit while keeping your changes in the working directory.

### Option 2: Use `git reset` (Discard Local Changes)

If you want to revert the last pull and discard any local changes, you can use:

git reset --hard HEAD@{1}

– This command resets your branch to the state before the last pull and discards any local changes.

### Option 3: Revert the Merge Commit (If You Want to Keep History)

If you pulled changes that included a merge commit and want to create a new commit that undoes the effects of that merge while keeping your history intact, you can use:

git revert -m 1 HEAD

– The `-m 1` option specifies the parent number to revert to, where `1` usually refers to the first parent (the branch you merged into).
– This will create a new commit that undoes the changes introduced by the last pull.

### Summary

– Use `git reset –mixed HEAD@{1}` to revert and keep local changes.
– Use `git reset –hard HEAD@{1}` to revert and discard local changes.
– Use `git revert -m 1 HEAD` to create a new commit that undoes the last merge.

Choose the method that best suits your needs!

### 1. Check Server Status
Make sure that the server hosting your application is up and running. You can do this by:

– Logging into your EC2 instance via SSH and checking if your application is running.
– Using commands like `docker ps` if you're running your application inside a Docker container.

### 2. Verify Application Port
Ensure that your application is configured to listen on port 3000. If you are using a framework or a tool (like Node.js or Vite), check the configuration to confirm it is set to run on the correct port.

### 3. Security Group Configuration
Make sure that the security group associated with your EC2 instance allows inbound traffic on port 3000:

1. Go to the **AWS Management Console**.
2. Navigate to **EC2**.
3. Select your instance and check the **Security** tab.
4. Click on the **Security Group** link.
5. Ensure there is an inbound rule allowing traffic on port 3000 (for HTTP, this should be TCP).

### 4. Check Firewall Settings
If you have a firewall configured on your EC2 instance (like `ufw` or `iptables`), make sure it allows traffic on port 3000:

– For `ufw`, you can check with:

sudo ufw status

To allow traffic on port 3000, run:

sudo ufw allow 3000

### 5. Check Application Logs
Look at your application's logs to see if there are any errors or indications that it is not running correctly. The logs can often provide insights into what might be causing the timeout.

### 6. Verify Network Connectivity
Test connectivity to your server from another terminal or machine:

telnet ec2-51-20-60-238.eu-north-1.compute.amazonaws.com 3000

If the connection times out, it indicates an issue with your server or network configuration.

### 7. Use Localhost for Testing
If you're running the application locally on your EC2 instance, you can try accessing it via `localhost` or `127.0.0.1` in the terminal of your EC2 instance:

curl http://localhost:3000/resources/js/Pages/Welcome.vue

### 8. Restart the Application
Sometimes, simply restarting your application or server can resolve connection issues. If you are using a process manager like PM2 or Docker, restart your application using the appropriate command.

### Conclusion
By following these steps, you should be able to identify the cause of the `ERR_CONNECTION_TIMED_OUT` error and take appropriate action to resolve it. If you continue to experience issues, feel free to provide more details about your setup, and I can help further!

Here are some additional steps you can take to troubleshoot the connection issue:

### 1. **Check Your Application**
– Ensure that your application is running on port 3000. You can do this by checking the logs or the process list. For example, if you're using Node.js, you can check the running processes with:

ps aux | grep node

### 2. **Check Network Configuration**
– Make sure that your application is bound to the correct network interface. If your application is set to listen only on `localhost`, it won't be accessible from external IPs. Ensure that your application is set to listen on `0.0.0.0` or the specific public IP address of your EC2 instance.

### 3. **Security Groups in AWS**
– Check the **Security Group** associated with your EC2 instance. Ensure that it has inbound rules allowing traffic on port 3000. You should add a rule like this if it doesn’t exist:
– **Type**: Custom TCP
– **Protocol**: TCP
– **Port Range**: 3000
– **Source**: 0.0.0.0/0 (for public access, but you may want to restrict this to your IP for security)

### 4. **Verify Connectivity**
– Test connectivity directly from your EC2 instance. You can use `curl` to see if your application is accessible from within the instance:

curl http://localhost:3000

– If you want to test from your local machine, you can use:

curl http://<your-ec2-public-ip>:3000

### 5. **Application Logs**
– Check your application logs for any errors or warnings that may indicate issues with starting the server or handling requests.

### 6. **Restart the Application**
– If the application is not running, or if you suspect it may be in a bad state, restart it. For example, if you're using Docker:

docker restart <container_name>

### 7. **Use the Correct URL**
– Ensure you are using the correct URL in your browser. It should be:

http://ec2-51-20-60-238.eu-north-1.compute.amazonaws.com:3000/resources/js/Pages/Welcome.vue

### Conclusion
If you've gone through these steps and are still experiencing issues, please provide additional details about how your application is set up (e.g., which framework you're using, how it's being run, etc.), and I can assist further!

### 1. **Check If Your Application is Running**
First, ensure that your application is running and listening on port 3000. You can check this by using the following command:

sudo lsof -i -P -n | grep LISTEN

This command lists all processes that are currently listening on ports. Look for an entry that indicates your application is listening on port 3000.

### 2. **Confirm Application Binding**
Make sure that your application is set to bind to `0.0.0.0` or the EC2 instance's public IP address instead of just `localhost`. If your application is only listening on `localhost`, it won't accept external connections. Check your application configuration.

### 3. **Check Security Group Settings**
Ensure that your AWS Security Group settings allow inbound traffic on port 3000:

1. **Go to the AWS Management Console**.
2. Navigate to **EC2**.
3. Select your EC2 instance and look at the **Description** tab.
4. Click on the **Security Groups** link to see the associated security group.
5. Ensure that there is an inbound rule allowing traffic on port 3000:
– **Type**: Custom TCP
– **Protocol**: TCP
– **Port Range**: 3000
– **Source**: 0.0.0.0/0 (for public access, but restrict it as needed for security)

### 4. **Firewall and Network Configuration**
Since you confirmed that UFW is inactive, ensure there are no other firewall settings or network configurations that might be blocking access. If you are using other firewall services or settings on your instance, ensure they allow traffic on port 3000.

### 5. **Test with Telnet**
You can use `telnet` to check if you can reach the port from your local machine. If you don't have `telnet` installed, you can typically install it using your package manager. To test:

telnet ec2-51-20-60-238.eu-north-1.compute.amazonaws.com 3000

If the connection is refused or times out, it indicates that there is likely no service listening on that port.

### 6. **Review Application Logs**
Check the logs of your application for any errors or messages that might indicate issues with startup or binding to the port.

### 7. **Restart the Application**
If the application is not running, or if there are no logs indicating that it started correctly, restart your application. If you are using a process manager like PM2 or a Docker container, ensure the application starts without issues.

### 8. **Check Other Network Issues**
If you've tried everything above, consider other potential network issues:
– Is there a VPN or proxy that might be affecting your connection?
– Are you behind a corporate firewall that could be blocking access?

### Conclusion
By going through these troubleshooting steps, you should be able to determine why you cannot connect to your application on port 3000. If you continue to have issues, please provide any relevant details about your application setup and configurations.