Upload 9 files

springboot-app 2/.gitignore

@@ -0,0 +1,70 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs
+hs_err_pid*
+
+# Maven
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+
+# IDE - IntelliJ IDEA
+.idea/
+*.iws
+*.iml
+*.ipr
+out/
+
+# IDE - Eclipse
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+# IDE - VSCode
+.vscode/
+
+# IDE - NetBeans
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+
+# OS Files
+.DS_Store
+Thumbs.db
+
+# Application specific
+application-local.properties
+application-dev.properties

springboot-app 2/Dockerfile

@@ -0,0 +1,32 @@
+# Multi-stage build for optimized image size
+# Stage 1: Build the application
+FROM maven:3.9-openjdk-17 AS builder
+
+# Set working directory
+WORKDIR /app
+
+# Copy Maven files
+COPY pom.xml .
+COPY src ./src
+
+# Build the application
+RUN mvn clean package -DskipTests
+
+# Stage 2: Run the application
+FROM openjdk:17-jdk-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy the JAR from builder stage
+COPY --from=builder /app/target/*.jar app.jar
+
+# Expose the port that Hugging Face expects (7860)
+EXPOSE 7860
+
+# Set the user to non-root for security
+RUN useradd -m -u 1000 user && chown -R user:user /app
+USER user
+
+# Run the Spring Boot application
+ENTRYPOINT ["java", "-jar", "/app/app.jar"]

springboot-app 2/HUGGINGFACE_DEPLOYMENT.md

@@ -0,0 +1,133 @@
+# Hugging Face Deployment Guide
+
+## Quick Start Deployment Steps
+
+### 1. Create a Hugging Face Account
+- Go to [huggingface.co](https://huggingface.co) and sign up if you haven't already
+
+### 2. Create a New Space
+1. Click on your profile picture → "New Space"
+2. Give your Space a name (e.g., "springboot-demo")
+3. Select **Docker** as the SDK (important!)
+4. Choose the hardware (free CPU Basic is fine for this demo)
+5. Set visibility (public or private)
+6. Click "Create Space"
+
+### 3. Upload Your Files
+You have two options:
+
+#### Option A: Using Git
+```bash
+# Clone your Space repository
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+
+# Copy all the Spring Boot files to the cloned repository
+cp -r springboot-app/* YOUR_SPACE_NAME/
+
+# Navigate to the repository
+cd YOUR_SPACE_NAME
+
+# Add, commit, and push
+git add .
+git commit -m "Initial Spring Boot application"
+git push
+```
+
+#### Option B: Using Web Interface
+1. Go to your Space's "Files" tab
+2. Click "Add file" → "Upload files"
+3. Upload the following structure:
+   ```
+   Dockerfile
+   pom.xml
+   src/
+   ├── main/
+   │   ├── java/com/example/demo/
+   │   │   ├── DemoApplication.java
+   │   │   └── controller/GreetingController.java
+   │   └── resources/
+   │       └── application.properties
+   └── test/java/com/example/demo/
+       └── DemoApplicationTests.java
+   ```
+
+### 4. Wait for Build and Deployment
+- Hugging Face will automatically detect the Dockerfile and start building
+- You can monitor the build logs in the "Logs" tab
+- The build typically takes 3-5 minutes
+
+### 5. Access Your Application
+Once deployed, your application will be available at:
+```
+https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/
+```
+
+## Testing Your Endpoints
+
+Once deployed, you can test your API endpoints:
+
+```bash
+# Test the home endpoint
+curl https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/
+
+# Test the greeting endpoint
+curl https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/greeting?name=HuggingFace
+
+# Test the health endpoint
+curl https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/health
+
+# Test the echo endpoint
+curl -X POST https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/echo \
+  -H "Content-Type: application/json" \
+  -d '{"message":"Hello from Hugging Face!"}'
+```
+
+## Troubleshooting
+
+### Common Issues and Solutions
+
+1. **Port Configuration Error**
+   - Ensure `server.port=7860` in application.properties
+   - Hugging Face requires port 7860
+
+2. **Build Fails**
+   - Check the Dockerfile syntax
+   - Ensure all file paths are correct
+   - Verify Java version compatibility
+
+3. **Application Doesn't Start**
+   - Check logs in the "Logs" tab
+   - Verify the JAR file name in Dockerfile matches the build output
+   - Ensure proper permissions (running as non-root user)
+
+4. **Slow Response Times**
+   - Free tier hardware has limited resources
+   - Consider upgrading to better hardware if needed
+
+## Environment Variables (Optional)
+
+You can add environment variables in the Space settings:
+1. Go to Settings → "Repository secrets"
+2. Add variables like:
+   - `SPRING_PROFILES_ACTIVE=production`
+   - `JAVA_OPTS=-Xmx512m`
+
+## Updating Your Application
+
+To update your deployed application:
+1. Make changes to your code locally
+2. Push updates to the Space repository
+3. Hugging Face will automatically rebuild and redeploy
+
+## Additional Resources
+
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Spring Boot Documentation](https://spring.io/projects/spring-boot)
+- [Docker Documentation](https://docs.docker.com/)
+
+## Support
+
+If you encounter issues:
+1. Check the Space logs first
+2. Visit Hugging Face forums
+3. Check Spring Boot community resources

springboot-app 2/README.md

@@ -0,0 +1,157 @@
+# Spring Boot Application for Hugging Face Spaces
+
+A simple Spring Boot REST API application designed to be deployed on Hugging Face Spaces.
+
+## Features
+
+- REST API with multiple endpoints
+- Health check endpoint for monitoring
+- Containerized with Docker
+- Configured for Hugging Face Spaces deployment (port 7860)
+
+## API Endpoints
+
+### GET /api/
+Returns a welcome message with current status.
+
+**Response:**
+```json
+{
+  "message": "Welcome to Spring Boot on Hugging Face!",
+  "status": "running",
+  "timestamp": "2024-11-13T10:30:00"
+}
+```
+
+### GET /api/greeting
+Returns a personalized greeting.
+
+**Parameters:**
+- `name` (optional): Name for the greeting (default: "World")
+
+**Example:** `/api/greeting?name=John`
+
+**Response:**
+```json
+{
+  "greeting": "Hello, John!",
+  "timestamp": "2024-11-13T10:30:00"
+}
+```
+
+### GET /api/health
+Health check endpoint.
+
+**Response:**
+```json
+{
+  "status": "UP",
+  "service": "Spring Boot Demo"
+}
+```
+
+### POST /api/echo
+Echoes back the received JSON payload.
+
+**Request Body:**
+```json
+{
+  "message": "test",
+  "data": "example"
+}
+```
+
+**Response:**
+```json
+{
+  "received": {
+    "message": "test",
+    "data": "example"
+  },
+  "timestamp": "2024-11-13T10:30:00"
+}
+```
+
+## Local Development
+
+### Prerequisites
+- Java 17 or higher
+- Maven 3.6 or higher
+
+### Running Locally
+
+1. Clone the repository
+2. Navigate to the project directory
+3. Run the application:
+   ```bash
+   mvn spring-boot:run
+   ```
+4. Access the application at `http://localhost:7860/api/`
+
+### Building the JAR
+```bash
+mvn clean package
+```
+
+### Running with Docker
+```bash
+# Build the Docker image
+docker build -t springboot-hf-demo .
+
+# Run the container
+docker run -p 7860:7860 springboot-hf-demo
+```
+
+## Deploying to Hugging Face Spaces
+
+1. Create a new Space on Hugging Face
+2. Choose "Docker" as the SDK
+3. Upload these files to your Space repository:
+   - `Dockerfile`
+   - `pom.xml`
+   - `src/` directory with all Java files and resources
+   - `README.md`
+
+4. The Space will automatically build and deploy your application
+
+### Hugging Face Configuration
+
+The application is configured to:
+- Listen on port 7860 (required by Hugging Face)
+- Bind to all network interfaces (0.0.0.0)
+- Run as a non-root user for security
+
+## Project Structure
+
+```
+springboot-app/
+├── src/
+│   └── main/
+│       ├── java/
+│       │   └── com/example/demo/
+│       │       ├── DemoApplication.java
+│       │       └── controller/
+│       │           └── GreetingController.java
+│       └── resources/
+│           └── application.properties
+├── Dockerfile
+├── pom.xml
+└── README.md
+```
+
+## Technologies Used
+
+- Spring Boot 3.2.1
+- Java 17
+- Maven
+- Docker
+- Spring Web
+- Spring Boot Actuator
+
+## License
+
+This project is open source and available for educational purposes.
+
+## Contributing
+
+Feel free to fork this project and customize it for your needs!

springboot-app 2/pom.xml

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+         http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.2.1</version>
+        <relativePath/>
+    </parent>
+    
+    <groupId>com.example</groupId>
+    <artifactId>demo</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>demo</name>
+    <description>Demo Spring Boot project for Hugging Face</description>
+    
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>

springboot-app 2/src/main/java/com/example/demo/DemoApplication.java

@@ -0,0 +1,11 @@
+package com.example.demo;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class DemoApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(DemoApplication.class, args);
+    }
+}

springboot-app 2/src/main/java/com/example/demo/controller/GreetingController.java

@@ -0,0 +1,44 @@
+package com.example.demo.controller;
+
+import org.springframework.web.bind.annotation.*;
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api")
+public class GreetingController {
+    
+    @GetMapping("/")
+    public Map<String, String> home() {
+        Map<String, String> response = new HashMap<>();
+        response.put("message", "Welcome to Spring Boot on Hugging Face!");
+        response.put("status", "running");
+        response.put("timestamp", LocalDateTime.now().toString());
+        return response;
+    }
+    
+    @GetMapping("/greeting")
+    public Map<String, String> greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
+        Map<String, String> response = new HashMap<>();
+        response.put("greeting", "Hello, " + name + "!");
+        response.put("timestamp", LocalDateTime.now().toString());
+        return response;
+    }
+    
+    @GetMapping("/health")
+    public Map<String, String> health() {
+        Map<String, String> response = new HashMap<>();
+        response.put("status", "UP");
+        response.put("service", "Spring Boot Demo");
+        return response;
+    }
+    
+    @PostMapping("/echo")
+    public Map<String, Object> echo(@RequestBody Map<String, Object> payload) {
+        Map<String, Object> response = new HashMap<>();
+        response.put("received", payload);
+        response.put("timestamp", LocalDateTime.now().toString());
+        return response;
+    }
+}

springboot-app 2/src/main/resources/application.properties

@@ -0,0 +1,21 @@
+# Server Configuration
+server.port=7860
+server.address=0.0.0.0
+
+# Application Name
+spring.application.name=SpringBoot-HuggingFace-Demo
+
+# Actuator Configuration
+management.endpoints.web.exposure.include=health,info
+management.endpoint.health.show-details=always
+
+# Logging
+logging.level.root=INFO
+logging.level.com.example.demo=DEBUG
+
+# JSON Configuration
+spring.jackson.serialization.indent-output=true
+
+# Error Handling
+server.error.include-message=always
+server.error.include-stacktrace=never

springboot-app 2/src/test/java/com/example/demo/DemoApplicationTests.java

@@ -0,0 +1,45 @@
+package com.example.demo;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+import static org.hamcrest.Matchers.*;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class DemoApplicationTests {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @Test
+    void contextLoads() {
+    }
+
+    @Test
+    void testHomeEndpoint() throws Exception {
+        mockMvc.perform(get("/api/"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.message").value("Welcome to Spring Boot on Hugging Face!"))
+                .andExpect(jsonPath("$.status").value("running"));
+    }
+
+    @Test
+    void testGreetingEndpoint() throws Exception {
+        mockMvc.perform(get("/api/greeting").param("name", "Test"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.greeting").value("Hello, Test!"));
+    }
+
+    @Test
+    void testHealthEndpoint() throws Exception {
+        mockMvc.perform(get("/api/health"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.status").value("UP"));
+    }
+}