Skip to main content

Building a Webex Chatbot for Testbed Environment Monitoring πŸ€–

πŸš€ Build an Intelligent Testbed Monitoring Bot

Automate testbed management with WebSocket-powered real-time monitoring

πŸ“‹ Table of Contents​

Overview​

The Testbed Monitor Bot is a sophisticated Webex-integrated chatbot that revolutionizes how teams manage and track test environment resources. Built with Python and leveraging WebSocket technology, it eliminates the need for webhooks and public IP addresses.

πŸ“Š

Real-time Monitoring

Track testbed availability and usage with instant updates

πŸ””

Smart Broadcasting

Notify teams across multiple Webex rooms automatically

πŸ“

Easy Registration

Book testbeds with interactive Adaptive Cards UI

πŸ”’

WebSocket Security

No public IP needed - secure behind firewalls

🎯 Key Features​

πŸ”ŒWhy WebSocket?

Unlike traditional webhook-based bots that require:

  • βœ— Public IP address
  • βœ— SSL certificates
  • βœ— Firewall configurations
  • βœ— ngrok tunnels

This bot uses WebSocket connections:

  • βœ“ Works behind corporate firewalls
  • βœ“ No complex network setup
  • βœ“ Real-time bidirectional communication
  • βœ“ Automatic reconnection on failure

Core Capabilities​

Real-time Testbed Status

  • View all testbeds at a glance
  • See who's using what resource
  • Track usage duration and expected release time
  • Color-coded availability indicators
# Bot automatically tracks:
{
  "testbed_name": "Testbed-1",
  "status": "in_use",
  "user_email": "engineer@company.com",
  "registered_time": "2025-10-01T10:30:00Z",
  "expected_release_time": "2025-10-01T18:00:00Z"
}

πŸ—οΈ System Architecture​

πŸ—οΈ Interactive System Architecture

Webex Cloud
Bot Server
JSON DB
Adaptive Cards

Technology Stack​

🐍 Python 3.10+
Core language
πŸ”Œ websockets
Real-time communication
πŸ’Ύ JSON Database
Lightweight storage
🎴 Adaptive Cards
Interactive UI

πŸ“Έ Bot Interface Gallery​

Main Menu

🏠 Main Menu - Entry point with all bot functions

Main Menu
βœ“
Status View
Registration Form
Success Message
Broadcast Selection
Broadcast Message
Release Form
Help Command
Feedback

πŸš€ Getting Started​

1
Setup Bot
2
Configure Env
3
Install Deps
4
Deploy
5
Test

Prerequisites​

βœ…Requirements Checklist

Before starting, ensure you have:

  • Python 3.10+ installed and configured
  • Webex Teams account with bot creation privileges
  • Network access to Webex APIs (or proxy configuration)
  • Basic knowledge of Python and REST APIs

Optional but recommended:

  • Git for version control
  • Virtual environment (venv/conda)
  • Docker for containerized deployment

Step 1: Create Your Webex Bot​

Register via Webex Developer Portal:

  1. Visit developer.webex.com

  2. Sign in with your Webex credentials

  3. Navigate to My Apps β†’ Create a New App

  4. Select Create a Bot

  5. Fill in bot details:

Bot Name: Testbed Monitor Bot
Bot Username: testbed-monitor@webex.bot
Bot Icon: [Upload custom icon]
Description: Intelligent bot for tracking and managing testbed usage
  1. Click Add Bot and copy the Bot Access Token

βš οΈπŸ”’ Security Warning

Never commit your bot token to version control!

The bot access token is like a password. If exposed:

  • Anyone can impersonate your bot
  • Unauthorized access to conversations
  • Potential data breaches

Always store it in:

  • Environment variables
  • .env files (add to .gitignore)
  • Secret management systems (AWS Secrets Manager, Azure Key Vault)

Step 2: Environment Setup​

Windows Setup:

# Clone the repository
git clone https://github.com/ngtanthanh-qc/webexchatbot_sample.git
cd webexchatbot_sample

# Create virtual environment
python -m venv .venv

# Activate virtual environment
.venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

Step 3: Configuration​

Create .env file in project root:

.env
# Webex Bot Configuration
WEBEX_ACCESS_TOKEN=your_bot_access_token_here
BOT_NAME=Testbed Monitor Bot

# Database Configuration
TESTBED_DB_NAME=testbed_monitor.json

# Webex API Configuration
WEBEX_API_URL=https://webexapis.com/v1

# Approved Rooms (comma-separated room IDs)
# Find room ID: Open Webex web, go to room, copy ID from URL
APPROVED_ROOMS=Y2lzY29zcGFyazovL3VzL1JPT00vNTU4NGI4MjAtNTRkMi0xMWVkLTg0YWItYzMyYWU2ZGNhOGE4

# Proxy Configuration (if behind corporate firewall)
HTTPS_PROXY=http://proxy.company.com:80
WSS_PROXY=socks5://proxy.company.com:1080

πŸ†”πŸ” Finding Room IDs

How to get Webex Room ID:

  1. Open Webex Web App
  2. Navigate to the desired room/space
  3. Look at the browser URL: 
    https://web.webex.com/spaces/Y2lzY29zcGFyazovL3VzL1JPT00v...
                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                               This is your Room ID
  4. Copy the ID after /spaces/

Alternative method via API:

from webexpythonsdk import WebexAPI

api = WebexAPI(access_token='YOUR_TOKEN')
rooms = api.rooms.list()

for room in rooms:
    print(f"{room.title}: {room.id}")

Step 4: Database Initialization​

The bot uses JSON for lightweight data storage. Customize testbed_monitor.json:

testbed_monitor.json
{
"testbeds": [
  {
    "id": 1,
    "testbed_name": "Production-Mirror",
    "status": "available",
    "user_email": null,
    "user_name": null,
    "registered_time": null,
    "purpose": null,
    "expected_release_time": null
  },
  {
    "id": 2,
    "testbed_name": "Dev-Environment-1",
    "status": "available",
    "user_email": null,
    "user_name": null,
    "registered_time": null,
    "purpose": null,
    "expected_release_time": null
  },
  {
    "id": 3,
    "testbed_name": "IaC-Sandbox",
    "status": "in_use",
    "user_email": "engineer@company.com",
    "user_name": "John Doe",
    "registered_time": "2025-10-01T09:00:00Z",
    "purpose": "Testing CI/CD pipeline",
    "expected_release_time": "2025-10-01T17:00:00Z"
  }
]
}

Database Schema:

FieldTypeDescription
idIntegerUnique testbed identifier
testbed_nameStringTestbed display name
statusStringavailable or in_use
user_emailString/nullEmail of current user
user_nameString/nullName of current user
registered_timeISO8601/nullWhen testbed was booked
purposeString/nullUsage purpose/description
expected_release_timeISO8601/nullExpected availability time

Step 5: Main Bot Implementation​

example.py
import os
from webex_bot.commands.testbed_main import TestbedMainCommand
from webex_bot.commands.help_custom import CustomHelpCommand
from webex_bot.webex_bot import WebexBot
from config import Config

# Proxy configuration (optional)
proxies = {
  'https': 'http://proxy.company.com:80',
  'wss': 'socks5://proxy.company.com:1080'
}

# Validate configuration
try:
  Config.validate_config()
except ValueError as e:
  print(f"❌ Configuration error: {e}")
  exit(1)

# Create Bot instance
bot = WebexBot(
  teams_bot_token=os.getenv("WEBEX_ACCESS_TOKEN"),
  approved_rooms=Config.APPROVED_ROOMS,
  bot_name=Config.BOT_NAME,
  include_demo_commands=False,
  help_command=CustomHelpCommand(),
  proxies=proxies
)

# Register custom commands
bot.add_command(TestbedMainCommand())

# Start the bot (blocking call)
if __name__ == "__main__":
  print("πŸš€ Starting Testbed Monitor Bot...")
  print(f"πŸ“ Bot Name: {Config.BOT_NAME}")
  print(f"πŸ”§ Approved Rooms: {len(Config.APPROVED_ROOMS)}")
  bot.run()
  print("βœ… Bot is running! Press Ctrl+C to stop.")

🎨 Bot Features Deep Dive​

Interactive Command Demo​

Try the bot command simulator below:

πŸ’¬ Bot Command Simulator

Webex Bot v1.0.8
// Type a command below

Custom Adaptive Cards​

The bot uses Adaptive Cards for rich, interactive UI:

Main Menu Card Structure:

from webexpythonsdk.models.cards import AdaptiveCard, TextBlock, ActionSet
from webexpythonsdk.models.cards.actions import Submit

def create_main_menu():
    card = AdaptiveCard(
        body=[
            TextBlock(
                "πŸ€– Testbed Monitor Bot",
                size="Large",
                weight="Bolder",
                color="Accent"
            ),
            TextBlock(
                "Choose an action:",
                wrap=True
            )
        ],
        actions=[
            Submit(title="πŸ“Š Check Status", data={"action": "status"}),
            Submit(title="✍️ Register Testbed", data={"action": "register"}),
            Submit(title="πŸ”“ Release Testbed", data={"action": "release"}),
            Submit(title="πŸ“’ Broadcast", data={"action": "broadcast"}),
        ]
    )
    return card.to_dict()

Broadcasting System​

πŸ“‘πŸ“’ Multi-Room Broadcasting

The bot can send notifications to multiple Webex rooms simultaneously. Perfect for:

  • Team coordination - Notify all stakeholders
  • Resource alerts - Broadcast availability changes
  • Scheduled maintenance - Inform users of downtime
  • Usage reports - Share testbed statistics

Broadcast Configuration (broadcast_rooms.json):

{
  "broadcast_rooms": [
    {
      "name": "QA Team",
      "room_id": "Y2lzY29zcGFyazovL...",
      "description": "Quality assurance team"
    },
    {
      "name": "DevOps Team",
      "room_id": "Y2lzY29zcGFyazovL...",
      "description": "Infrastructure team"
    }
  ]
}

🚒 Deployment Options​

For Testing and Development:

# Start bot in foreground
python example.py

# Output:
πŸš€ Starting Testbed Monitor Bot...
πŸ“ Bot Name: Testbed Monitor Bot
πŸ”§ Approved Rooms: 1
βœ… Bot is running! Press Ctrl+C to stop.
⚑ WebSocket connected to Webex Cloud

πŸ’‘Development Tips

Best practices for local development:

  • Use .env.local for local-specific configuration
  • Enable debug logging: logging.basicConfig(level=logging.DEBUG)
  • Test in private Webex room first
  • Use ngrok if you need to test webhooks
  • Monitor testbed_monitor.json changes in real-time

πŸ”§ Advanced Configuration​

Proxy Support​

πŸ”’πŸŒ Corporate Proxy Configuration

Many corporate environments require proxy configuration:

HTTP/HTTPS Proxy:

proxies = {
    'https': 'http://proxy.company.com:80'
}

SOCKS5 Proxy (for WebSocket):

proxies = {
    'wss': 'socks5://proxy.company.com:1080'
}

Authenticated Proxy:

proxies = {
    'https': 'http://username:password@proxy.company.com:80'
}

In config.py:

@classmethod
def get_proxies(cls):
    proxies = {}
    if cls.HTTPS_PROXY:
        proxies['https'] = cls.HTTPS_PROXY
    if cls.WSS_PROXY:
        proxies['wss'] = cls.WSS_PROXY
    return proxies if proxies else None

Custom Logging​

logging_config.py
import logging
from colorlog import ColoredFormatter

# Create colored formatter
formatter = ColoredFormatter(
  "%(log_color)s%(asctime)s - %(name)s - %(levelname)s - %(message)s",
  datefmt='%Y-%m-%d %H:%M:%S',
  log_colors={
      'DEBUG': 'cyan',
      'INFO': 'green',
      'WARNING': 'yellow',
      'ERROR': 'red',
      'CRITICAL': 'red,bg_white',
  }
)

# Configure handlers
console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)

file_handler = logging.FileHandler('testbed_bot.log')
file_handler.setFormatter(logging.Formatter(
  '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
))

# Configure root logger
logging.basicConfig(
  level=logging.INFO,
  handlers=[console_handler, file_handler]
)

# Bot-specific logger
logger = logging.getLogger('testbed_bot')
logger.setLevel(logging.DEBUG)

Database Migration​

Current Implementation - Simple and Portable:

βœ… Advantages:

  • No external dependencies
  • Easy to read/edit manually
  • Simple backup (just copy file)
  • Works everywhere

❌ Limitations:

  • Not suitable for high concurrency
  • Limited query capabilities
  • No built-in transactions

πŸ› Troubleshooting​

πŸ”§Common Issues & Solutions

Bot Not Responding​

Symptoms:

  • Bot appears online but doesn't reply
  • Commands are ignored
  • No error messages

Solutions:

πŸ” Issue Troubleshooter

Debug Mode​

Enable detailed logging for troubleshooting:

debug_bot.py
import logging
import os
from webex_bot.webex_bot import WebexBot

# Enable DEBUG logging for all components
logging.basicConfig(
  level=logging.DEBUG,
  format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# Enable webex_bot specific debug logs
logging.getLogger('webex_bot').setLevel(logging.DEBUG)
logging.getLogger('webexpythonsdk').setLevel(logging.DEBUG)
logging.getLogger('websockets').setLevel(logging.DEBUG)

# Start bot with debug info
bot = WebexBot(
  teams_bot_token=os.getenv("WEBEX_ACCESS_TOKEN"),
  bot_name="Testbed Monitor (DEBUG)",
  include_demo_commands=True  # Include demo commands for testing
)

bot.run()

Health Check Endpoint​

Add health monitoring:

health_check.py
from datetime import datetime
import threading
from http.server import HTTPServer, BaseHTTPRequestHandler
import json

class HealthCheckHandler(BaseHTTPRequestHandler):
  bot_status = {
      'started_at': datetime.utcnow().isoformat(),
      'last_message': None,
      'websocket_connected': False,
      'messages_processed': 0
  }

  def do_GET(self):
      if self.path == '/health':
          self.send_response(200)
          self.send_header('Content-Type', 'application/json')
          self.end_headers()

          status = {
              'status': 'healthy' if self.bot_status['websocket_connected'] else 'unhealthy',
              'uptime': (datetime.utcnow() - datetime.fromisoformat(
                  self.bot_status['started_at']
              )).total_seconds(),
              **self.bot_status
          }

          self.wfile.write(json.dumps(status, indent=2).encode())
      else:
          self.send_response(404)
          self.end_headers()

  def log_message(self, format, *args):
      pass  # Suppress HTTP logs

def start_health_server(port=8080):
  server = HTTPServer(('0.0.0.0', port), HealthCheckHandler)
  thread = threading.Thread(target=server.serve_forever, daemon=True)
  thread.start()
  print(f"βœ… Health check server started on port {port}")
  return server

# In your main bot script:
# health_server = start_health_server(8080)
# bot.run()

Test health endpoint:

curl http://localhost:8080/health

πŸ“Š Monitoring & Analytics​

Usage Statistics​

Track bot usage with metrics:

πŸ“ˆ Bot Analytics Dashboard

πŸ’¬
1247
Total Commands
✍️
342
Registrations
πŸ”“
318
Releases
πŸ“’
87
Broadcasts
πŸ‘₯
45
Active Users
⚑
0.8s
Avg Response

πŸŽ“ Best Practices​

πŸ”’Security

Never commit sensitive data:

  • Use .env files
  • Add .env to .gitignore
  • Use secret management tools
  • Rotate tokens regularly
  • Implement rate limiting

πŸ›‘οΈError Handling

Robust error handling:

  • Try-except blocks everywhere
  • Log all errors with context
  • Graceful degradation
  • User-friendly error messages
  • Automatic retry logic

⚑Performance

Optimize for speed:

  • Cache frequently used data
  • Async operations where possible
  • Database indexing
  • Minimize card complexity
  • Connection pooling

πŸ“ŠMonitoring

Track everything:

  • Command usage metrics
  • Response times
  • Error rates
  • User engagement
  • Resource utilization

πŸš€ Next Steps & Enhancements​

Potential Enhancements:

  1. πŸ“… Calendar Integration

    • Sync with Google Calendar/Outlook
    • Automated scheduling
    • Conflict detection
    • Reminder notifications

  2. πŸ“§ Email Notifications

    • Release reminders
    • Overdue alerts
    • Weekly summary reports
    • Team digests

  3. πŸ€– AI/ML Features

    • Usage pattern analysis
    • Predictive availability
    • Smart recommendations
    • Anomaly detection

  4. πŸ“± Mobile Optimization

    • Responsive card designs
    • Push notifications
    • Mobile-first UI
    • Gesture support

  5. πŸ”— CI/CD Integration

    • Jenkins/GitHub Actions hooks
    • Automated testbed allocation
    • Pipeline status updates
    • Test result reporting

πŸ“š Resources & References​

πŸ”— Official Documentation​

πŸ“– Learning Resources​

πŸ› οΈ Tools & Utilities​

πŸŽ‰ Conclusion​

🎊

You're Ready to Build!

You now have everything needed to create a production-ready Webex chatbot for testbed monitoring. Start small, iterate quickly, and scale as needed.

Key Takeaways​

πŸ”Œ

WebSocket Magic

No webhooks, no public IP, works behind firewalls

🎴

Rich UI

Adaptive Cards provide interactive, beautiful interfaces

πŸ“Š

Real-time

Instant updates and bidirectional communication

πŸš€

Scalable

Start simple, scale to enterprise-grade deployments

πŸ”’

Secure

Built-in authentication and authorization

πŸ› οΈ

Extensible

Easy to add new features and integrations

Built with ❀️ using Webex, Python, and WebSockets

Questions? Issues? Visit the GitHub Issues page

Last updated: October 2025 | Version 1.0