# Module Service - Application
## Overview
The Application Service provides distributed application hosting and lifecycle management within the Cellframe SDK. This service enables deployment, execution, and management of decentralized applications (dApps) across the Cellframe network infrastructure with integrated resource management and billing.
*Based on: `dap_chain_net_srv_app.h`, `dap_chain_net_srv_app.c`*
## Document Structure
- [[#Overview|Overview]]
- [[#Application Structures|Application Structures]]
- [[#Application Metadata|Application Metadata - App information]]
- [[#Resource Management|Resource Management - Resource allocation]]
- [[#Application Functions|Application Functions]]
- [[#Application Management|Application Management Functions]]
- [[#Resource Management|Resource Management Functions]]
- [[#Typical Examples|Typical Examples]]
## Application Structures
### Application Metadata Structure
Structure for managing application information and configuration.
```c
typedef struct dap_chain_net_srv_app_metadata {
char app_name[64]; // Application name
char app_version[16]; // Version string
char app_description[256]; // Description
uint64_t app_size; // Application size in bytes
uint32_t resource_requirements; // Required resources
dap_chain_addr_t owner_addr; // Application owner address
dap_chain_hash_fast_t app_hash; // Application hash
uint64_t created_timestamp; // Creation timestamp
uint64_t updated_timestamp; // Last update timestamp
bool is_active; // Application status
} dap_chain_net_srv_app_metadata_t;
```
### Resource Allocation Structure
Structure for managing application resource allocation.
```c
typedef struct dap_chain_net_srv_app_resources {
uint32_t cpu_limit; // CPU usage limit (percentage)
uint64_t memory_limit; // Memory limit in bytes
uint64_t storage_limit; // Storage limit in bytes
uint32_t bandwidth_limit; // Bandwidth limit in KB/s
uint32_t concurrent_users; // Maximum concurrent users
uint64_t execution_time_limit; // Maximum execution time
} dap_chain_net_srv_app_resources_t;
```
## Application Functions
### Application Management
#### `dap_chain_net_srv_app_deploy()`
Deploys a new application to the service.
```c
int dap_chain_net_srv_app_deploy(
dap_chain_net_t *a_net,
const char *a_app_name,
const void *a_app_data,
size_t a_app_size,
dap_chain_net_srv_app_resources_t *a_resources
);
```
**Parameters:**
- `a_net` (dap_chain_net_t *) - Network context
- `a_app_name` (const char *) - Application name
- `a_app_data` (const void *) - Application binary data
- `a_app_size` (size_t) - Size of application data
- `a_resources` (dap_chain_net_srv_app_resources_t *) - Resource requirements
**Returns:**
- `0` - Deployment successful
- `-1` - Invalid parameters
- `-2` - Insufficient resources
- `-3` - Deployment failed
#### `dap_chain_net_srv_app_start()`
Starts a deployed application.
```c
int dap_chain_net_srv_app_start(dap_chain_net_t *a_net, const char *a_app_name);
```
**Parameters:**
- `a_net` (dap_chain_net_t *) - Network context
- `a_app_name` (const char *) - Application name to start
**Returns:**
- `0` - Application started successfully
- `-1` - Application not found
- `-2` - Start failed
#### `dap_chain_net_srv_app_stop()`
Stops a running application.
```c
int dap_chain_net_srv_app_stop(dap_chain_net_t *a_net, const char *a_app_name);
```
**Parameters:**
- `a_net` (dap_chain_net_t *) - Network context
- `a_app_name` (const char *) - Application name to stop
**Returns:**
- `0` - Application stopped successfully
- `-1` - Application not found
- `-2` - Stop failed
#### `dap_chain_net_srv_app_remove()`
Removes an application from the service.
```c
int dap_chain_net_srv_app_remove(dap_chain_net_t *a_net, const char *a_app_name);
```
**Parameters:**
- `a_net` (dap_chain_net_t *) - Network context
- `a_app_name` (const char *) - Application name to remove
**Returns:**
- `0` - Application removed successfully
- `-1` - Application not found
- `-2` - Removal failed
### Resource Management
#### `dap_chain_net_srv_app_get_status()`
Gets current application status and resource usage.
```c
int dap_chain_net_srv_app_get_status(
dap_chain_net_t *a_net,
const char *a_app_name,
dap_chain_net_srv_app_metadata_t *a_metadata,
dap_chain_net_srv_app_resources_t *a_usage
);
```
**Parameters:**
- `a_net` (dap_chain_net_t *) - Network context
- `a_app_name` (const char *) - Application name
- `a_metadata` (dap_chain_net_srv_app_metadata_t *) - Output metadata
- `a_usage` (dap_chain_net_srv_app_resources_t *) - Output resource usage
**Returns:**
- `0` - Status retrieved successfully
- `-1` - Application not found
- `-2` - Status retrieval failed
#### `dap_chain_net_srv_app_update_resources()`
Updates resource allocation for an application.
```c
int dap_chain_net_srv_app_update_resources(
dap_chain_net_t *a_net,
const char *a_app_name,
dap_chain_net_srv_app_resources_t *a_new_resources
);
```
**Parameters:**
- `a_net` (dap_chain_net_t *) - Network context
- `a_app_name` (const char *) - Application name
- `a_new_resources` (dap_chain_net_srv_app_resources_t *) - New resource limits
**Returns:**
- `0` - Resources updated successfully
- `-1` - Application not found
- `-2` - Insufficient resources available
- `-3` - Update failed
## Typical Examples
### Application Deployment Example
```c
#include <dap_chain_net_srv_app.h>
void application_deployment_example() {
log_it_info("=== Application Deployment Example ===");
// Step 1: Setup network context
dap_chain_net_t *net = dap_chain_net_by_name("backbone");
if (!net) {
log_it_error("✗ Network 'backbone' not found");
return;
}
// Step 2: Define application details
const char *app_name = "MyDApp";
const char *app_description = "Example decentralized application";
log_it_info("Application Details:");
log_it_info(" Name: %s", app_name);
log_it_info(" Description: %s", app_description);
log_it_info(" Network: %s", net->pub.name);
// Step 3: Create application binary data (simulated)
const char *app_code = "#!/bin/bash\necho 'Hello from DApp!'\n";
size_t app_size = strlen(app_code);
log_it_info(" Binary size: %zu bytes", app_size);
// Step 4: Define resource requirements
dap_chain_net_srv_app_resources_t resources = {
.cpu_limit = 25, // 25% CPU limit
.memory_limit = 128 * 1024 * 1024, // 128MB memory
.storage_limit = 1024 * 1024, // 1MB storage
.bandwidth_limit = 1024, // 1KB/s bandwidth
.concurrent_users = 10, // 10 concurrent users
.execution_time_limit = 3600 // 1 hour execution limit
};
log_it_info("Resource Requirements:");
log_it_info(" CPU: %u%% limit", resources.cpu_limit);
log_it_info(" Memory: %.1f MB", resources.memory_limit / (1024.0 * 1024.0));
log_it_info(" Storage: %.1f KB", resources.storage_limit / 1024.0);
log_it_info(" Bandwidth: %u KB/s", resources.bandwidth_limit);
log_it_info(" Max users: %u", resources.concurrent_users);
log_it_info(" Time limit: %u seconds", resources.execution_time_limit);
// Step 5: Deploy application
log_it_info("--- Deploying Application ---");
int deploy_result = dap_chain_net_srv_app_deploy(
net,
app_name,
app_code,
app_size,
&resources
);
switch (deploy_result) {
case 0:
log_it_info("✓ Application deployed successfully");
break;
case -1:
log_it_error("✗ Invalid deployment parameters");
return;
case -2:
log_it_error("✗ Insufficient resources for deployment");
return;
case -3:
log_it_error("✗ Application deployment failed");
return;
default:
log_it_error("✗ Unknown deployment error: %d", deploy_result);
return;
}
// Step 6: Start application
log_it_info("--- Starting Application ---");
int start_result = dap_chain_net_srv_app_start(net, app_name);
switch (start_result) {
case 0:
log_it_info("✓ Application started successfully");
log_it_info(" Status: Running");
log_it_info(" Ready to accept connections");
break;
case -1:
log_it_error("✗ Application not found for starting");
return;
case -2:
log_it_error("✗ Application start failed");
return;
default:
log_it_error("✗ Unknown start error: %d", start_result);
return;
}
// Step 7: Monitor application status
log_it_info("--- Application Status ---");
dap_chain_net_srv_app_metadata_t metadata = {0};
dap_chain_net_srv_app_resources_t current_usage = {0};
int status_result = dap_chain_net_srv_app_get_status(
net,
app_name,
&metadata,
¤t_usage
);
if (status_result == 0) {
log_it_info("✓ Application status retrieved");
log_it_info(" Active: %s", metadata.is_active ? "Yes" : "No");
log_it_info(" Current CPU usage: %u%%", current_usage.cpu_limit);
log_it_info(" Current memory usage: %.1f MB",
current_usage.memory_limit / (1024.0 * 1024.0));
} else {
log_it_warning("Could not retrieve application status");
}
log_it_info("Application deployment example completed");
}
```
### Application Management Example
```c
#include <dap_chain_net_srv_app.h>
void application_management_example() {
log_it_info("=== Application Management Example ===");
// Step 1: Setup network context
dap_chain_net_t *net = dap_chain_net_by_name("backbone");
if (!net) {
log_it_error("✗ Network not found");
return;
}
const char *app_name = "TestApp";
// Step 2: Update application resources
log_it_info("--- Resource Management ---");
dap_chain_net_srv_app_resources_t new_resources = {
.cpu_limit = 50, // Increase to 50% CPU
.memory_limit = 256 * 1024 * 1024, // Increase to 256MB
.storage_limit = 2 * 1024 * 1024, // Increase to 2MB
.bandwidth_limit = 2048, // Increase to 2KB/s
.concurrent_users = 20, // Increase to 20 users
.execution_time_limit = 7200 // Increase to 2 hours
};
int update_result = dap_chain_net_srv_app_update_resources(
net,
app_name,
&new_resources
);
switch (update_result) {
case 0:
log_it_info("✓ Application resources updated successfully");
log_it_info(" New CPU limit: %u%%", new_resources.cpu_limit);
log_it_info(" New memory limit: %.1f MB",
new_resources.memory_limit / (1024.0 * 1024.0));
break;
case -1:
log_it_error("✗ Application not found for resource update");
break;
case -2:
log_it_error("✗ Insufficient resources available");
break;
case -3:
log_it_error("✗ Resource update failed");
break;
default:
log_it_error("✗ Unknown resource update error: %d", update_result);
break;
}
// Step 3: Application lifecycle management
log_it_info("--- Lifecycle Management ---");
// Stop application
log_it_info("Stopping application...");
int stop_result = dap_chain_net_srv_app_stop(net, app_name);
if (stop_result == 0) {
log_it_info("✓ Application stopped successfully");
} else {
log_it_error("✗ Application stop failed: %d", stop_result);
}
// Restart application
log_it_info("Restarting application...");
int restart_result = dap_chain_net_srv_app_start(net, app_name);
if (restart_result == 0) {
log_it_info("✓ Application restarted successfully");
} else {
log_it_error("✗ Application restart failed: %d", restart_result);
}
// Step 4: Application removal (optional)
log_it_info("--- Application Removal (Demonstration) ---");
log_it_info("To remove application, use:");
log_it_info(" int remove_result = dap_chain_net_srv_app_remove(net, \"%s\");", app_name);
log_it_info(" This will permanently delete the application and its data");
log_it_info("Application management example completed");
}
```
---
*See also: [[Modules/Module Service|Module Service]], [[Modules/Module Service - App Database|Module Service - App Database]], [[ETC/Services Overview|Services Overview]]*