LCC SDK - Technical Documentation

System Architecture Overview

Core Components

Application Layer

Your business logic code that implements the core functionality of your application. With LCC SDK, you write clean business logic without any license checking code.

LCC SDK Client

The client library that provides the interface between your application and the LCC server. It handles registration, feature checks, and usage reporting.

LCC Server

The central license management system that validates licenses, enforces limitations, and provides usage analytics.

License Files

Cryptographically signed license files that define the customer's entitlements, including tiers, features, and usage limits.

Data Flow Diagram

┌─────────────────┐    1. Register     ┌─────────────────┐
│   Application   │ ──────────────────▶│    LCC SDK      │
│  (Your Code)    │                    │    Client       │
└─────────────────┘                    └─────────────────┘
                                                │
                                        2. Validate │
                                                ▼
┌─────────────────┐                    ┌─────────────────┐
│  License File   │ ◀───────────────── │   LCC Server    │
│ (Signed JSON)   │    3. Enforce      │                 │
└─────────────────┘                    └─────────────────┘
                                                │
                                        4. Report Usage │
                                                ▼
                                        ┌─────────────────┐
                                        │   Analytics     │
                                        └─────────────────┘

Zero Intrusion Approach

Before Compilation (Developer Code)

func ExportToExcel(reportID string) error {
    // Direct business logic
    return generateExcelReport(reportID)
}

After Compilation (Auto-generated Code)

func ExportToExcel(reportID string) error {
    // ===== Auto-generated by LCC compiler =====
    status, err := lccClient.CheckFeature("excel_export")
    if err != nil {
        return fmt.Errorf("license check: %w", err)
    }
    if !status.Enabled {
        return fmt.Errorf("Excel export requires Enterprise tier")
    }
    // ==========================================
    
    // Original developer code
    return generateExcelReport(reportID)
}

Integration Guide

Prerequisites

Go 1.21 or higher
LCC Server running and accessible
Valid license file for your product
lcc-sdk client library

Installation

1. Add Dependency

go get github.com/yourorg/lcc-sdk

2. Initialize Client

import "github.com/yourorg/lcc-sdk/client"
import "github.com/yourorg/lcc-sdk/config"

cfg := &config.SDKConfig{
    LCCURL:         "https://your-lcc-server.com",
    ProductID:      "your-product-id",
    ProductVersion: "1.0.0",
    Timeout:        30 * time.Second,
    CacheTTL:       10 * time.Second,
}

client, err := client.NewClient(cfg)
if err != nil {
    log.Fatal("Failed to create LCC client:", err)
}

Client Lifecycle

1

Create Client

Initialize the LCC client with your configuration.

2

Register with Server

Establish connection and validate license.

3

Use Client

Perform feature checks and report usage.

4

Close Client

Clean up resources when shutting down.

Development Workflow

Step-by-Step Process

1

Define Features in YAML

Create feature definitions in lcc-features.yaml specifying tiers, quotas, and limitations.

features:
  - id: advanced_analytics
    name: "Advanced Analytics with ML"
    tier: professional
    intercept:
      package: "demo-app/internal/analytics"
      function: "RunAdvanced"
    fallback:
      package: "demo-app/internal/analytics"
      function: "RunBasic"
    quota:
      limit: 1000
      period: daily

2

Write Business Logic

Develop your application functionality without any license checking code.

func RunAdvanced(data []byte) (Result, error) {
    // Your advanced analytics implementation
    // No license checking code needed!
    return performAdvancedAnalysis(data)
}

3

Run Code Generation

Execute lcc-codegen to automatically inject license checks.

lcc-codegen -config lcc-features.yaml -output internal/analytics/lcc_gen.go

4

Build and Test

Compile your application and verify license enforcement works correctly.

go build -o myapp cmd/main.go
./myapp

Best Practices

Separate feature definitions from business logic
Use meaningful feature IDs and descriptions
Implement graceful fallbacks for tier limitations
Test with different license tiers during development
Monitor usage analytics to understand customer behavior

API Reference

Core Operations

Consumption

Capacity

TPS

Concurrency

Consume (Quota / Event Count)

Check and consume quota in one step.

POST /api/consume

allowed, remaining, reason, err := client.Consume("advanced_analytics", 1, nil)
if err != nil {
    // network or server error
}
if !allowed {
    // denied by license; reason describes why
}
// proceed with the operation

Parameters

Parameter	Type	Description
featureID	string	Unique identifier for the feature
amount	int	Number of units to consume
meta	map[string]any	Optional metadata for analytics

Returns

allowed - Whether the operation is permitted
remaining - Approximate remaining quota (for UX only)
reason - Denial reason (insufficient_tier, quota_exceeded, etc.)
err - Network or server error

CheckCapacity (State Capacity)

Check if current count exceeds license-defined maximum.

POST /api/check-capacity

allowed, max, reason, err := client.CheckCapacity("capacity.project.count", currentProjects)
if !allowed {
    // stop creating more entities; max reached
}

CheckTPS (Rate Limiting)

Check if current TPS exceeds license-defined maximum.

POST /api/check-tps

currentTPS := 7.5 // measured by your app
allowed, maxTPS, reason, err := client.CheckTPS("api.v1.demo", currentTPS)
if !allowed {
    // throttle or reject requests
}

AcquireSlot (Concurrency Control)

Acquire a concurrency slot for parallel operations.

POST /api/acquire-slot

release, allowed, reason, err := client.AcquireSlot("concurrent.user", map[string]any{
    "job_id": 123,
})
if err != nil {
    // error talking to LCC
}
if !allowed {
    // no slot available; respect the limit
}
defer release()

// run the job here

Configuration Reference

Feature Manifest (lcc-features.yaml)

Complete Example

sdk:
  lcc_url: "https://your-lcc-server.com"
  product_id: "demo-analytics-pro"
  product_version: "1.0.0"

features:
  - id: advanced_analytics
    name: "Advanced Analytics with ML"
    tier: professional
    intercept:
      package: "demo-app/internal/analytics"
      function: "RunAdvanced"
    fallback:
      package: "demo-app/internal/analytics"
      function: "RunBasic"
    quota:
      limit: 1000
      period: daily

  - id: pdf_export
    name: "PDF Export"
    tier: professional
    intercept:
      package: "demo-app/internal/export"
      function: "GeneratePDF"
    quota:
      limit: 200
      period: daily

  - id: excel_export
    name: "Excel Export"
    tier: enterprise
    intercept:
      package: "demo-app/internal/export"
      function: "GenerateExcel"
    on_deny:
      action: error
      message: "Excel export requires Enterprise license"

  - id: scheduled_reports
    name: "Scheduled Reports"
    tier: professional
    intercept:
      package: "demo-app/internal/reporting"
      function: "Schedule"
    quota:
      limit: 100
      period: daily

Configuration Options

SDK Configuration

Option	Type	Description	Default
LCCURL	string	URL of the LCC server	Required
ProductID	string	Product identifier	Required
ProductVersion	string	Product version string	Required
Timeout	duration	HTTP timeout for SDK calls	30s
CacheTTL	duration	How long feature checks are cached	10s

Interactive Configuration Demo

Feature Configuration Generator

Configure a feature and see the generated YAML configuration.

Feature ID

Feature Name

Tier

Package Path

Function Name

Limitation Type

LCC SDK Technical Documentation