Subnetting, Bandwidth Control, and Network Use Cases: A Practical Guide

def calculate_subnet_info(network_address, cidr):
    """Calculate subnet information from network address and CIDR."""
    
    # Convert CIDR to subnet mask
    subnet_mask = (0xFFFFFFFF << (32 - cidr)) & 0xFFFFFFFF
    
    # Calculate network address
    network_binary = int(network_address.replace('.', ''), 16)
    network_addr = network_binary & subnet_mask
    
    # Calculate broadcast address
    broadcast_addr = network_addr | (0xFFFFFFFF >> cidr)
    
    # Calculate usable host range
    first_host = network_addr + 1
    last_host = broadcast_addr - 1
    
    # Calculate number of hosts
    num_hosts = 2**(32 - cidr) - 2
    
    return {
        'network_address': network_address,
        'subnet_mask': '.'.join([str((subnet_mask >> i) & 0xFF) for i in (24, 16, 8, 0)]),
        'broadcast_address': '.'.join([str((broadcast_addr >> i) & 0xFF) for i in (24, 16, 8, 0)]),
        'first_host': '.'.join([str((first_host >> i) & 0xFF) for i in (24, 16, 8, 0)]),
        'last_host': '.'.join([str((last_host >> i) & 0xFF) for i in (24, 16, 8, 0)]),
        'num_hosts': num_hosts
    }

# Example usage
network_info = calculate_subnet_info('192.168.1.0', 24)
print("Subnet Information:")
for key, value in network_info.items():
    print(f"{key}: {value}")

import psutil
import time
import matplotlib.pyplot as plt
from collections import deque

class BandwidthMonitor:
    def __init__(self, max_points=100):
        self.max_points = max_points
        self.times = deque(maxlen=max_points)
        self.bytes_sent = deque(maxlen=max_points)
        self.bytes_recv = deque(maxlen=max_points)
        
    def get_network_stats(self):
        """Get current network statistics."""
        net_io = psutil.net_io_counters()
        return net_io.bytes_sent, net_io.bytes_recv
    
    def monitor_bandwidth(self, duration=60, interval=1):
        """Monitor bandwidth usage for specified duration."""
        start_time = time.time()
        last_sent, last_recv = self.get_network_stats()
        
        while time.time() - start_time < duration:
            time.sleep(interval)
            current_time = time.time()
            current_sent, current_recv = self.get_network_stats()
            
            # Calculate bandwidth
            sent_bps = (current_sent - last_sent) / interval
            recv_bps = (current_recv - last_recv) / interval
            
            # Store data
            self.times.append(current_time - start_time)
            self.bytes_sent.append(sent_bps / 1024 / 1024)  # MB/s
            self.bytes_recv.append(recv_bps / 1024 / 1024)  # MB/s
            
            last_sent, last_recv = current_sent, current_recv
            
            print(f"Time: {current_time - start_time:.1f}s | "
                  f"Upload: {sent_bps/1024/1024:.2f} MB/s | "
                  f"Download: {recv_bps/1024/1024:.2f} MB/s")
    
    def plot_bandwidth(self):
        """Plot bandwidth usage over time."""
        plt.figure(figsize=(12, 6))
        plt.plot(list(self.times), list(self.bytes_sent), label='Upload', color='red')
        plt.plot(list(self.times), list(self.bytes_recv), label='Download', color='blue')
        plt.xlabel('Time (seconds)')
        plt.ylabel('Bandwidth (MB/s)')
        plt.title('Network Bandwidth Usage')
        plt.legend()
        plt.grid(True, alpha=0.3)
        plt.show()

# Usage example
monitor = BandwidthMonitor()
monitor.monitor_bandwidth(duration=30, interval=1)
monitor.plot_bandwidth()

import nmap
import ipaddress
import json

class NetworkScanner:
    def __init__(self, network_range):
        self.network_range = network_range
        self.nm = nmap.PortScanner()
    
    def scan_network(self):
        """Scan network for active hosts."""
        print(f"Scanning network: {self.network_range}")
        
        # Perform network scan
        self.nm.scan(hosts=self.network_range, arguments='-sn')
        
        active_hosts = []
        for host in self.nm.all_hosts():
            if self.nm[host].state() == 'up':
                host_info = {
                    'ip': host,
                    'hostname': self.nm[host].hostname(),
                    'mac': self.nm[host]['addresses'].get('mac', 'Unknown'),
                    'vendor': self.nm[host]['vendor'].get(self.nm[host]['addresses'].get('mac', ''), 'Unknown')
                }
                active_hosts.append(host_info)
        
        return active_hosts
    
    def analyze_subnet_usage(self, active_hosts):
        """Analyze subnet usage and provide recommendations."""
        network = ipaddress.IPv4Network(self.network_range, strict=False)
        total_addresses = network.num_addresses
        used_addresses = len(active_hosts)
        utilization = (used_addresses / total_addresses) * 100
        
        print(f"\nSubnet Analysis for {self.network_range}:")
        print(f"Total addresses: {total_addresses}")
        print(f"Used addresses: {used_addresses}")
        print(f"Utilization: {utilization:.1f}%")
        
        if utilization > 80:
            print("⚠️  High utilization - consider subnetting or expanding")
        elif utilization < 20:
            print("ℹ️  Low utilization - consider smaller subnet")
        else:
            print("✅ Optimal utilization")
        
        return {
            'total_addresses': total_addresses,
            'used_addresses': used_addresses,
            'utilization': utilization
        }

# Usage example
scanner = NetworkScanner('192.168.1.0/24')
active_hosts = scanner.scan_network()
scanner.analyze_subnet_usage(active_hosts)

import dash
from dash import dcc, html
from dash.dependencies import Input, Output
import plotly.graph_objs as go
import psutil
import threading
import time

class BandwidthDashboard:
    def __init__(self):
        self.app = dash.Dash(__name__)
        self.bandwidth_data = {'times': [], 'upload': [], 'download': []}
        self.setup_layout()
        self.setup_callbacks()
        
    def setup_layout(self):
        self.app.layout = html.Div([
            html.H1('Network Bandwidth Monitor'),
            
            dcc.Graph(id='bandwidth-graph'),
            
            dcc.Interval(
                id='interval-component',
                interval=1*1000,  # Update every second
                n_intervals=0
            ),
            
            html.Div([
                html.H3('Current Usage'),
                html.Div(id='current-usage')
            ])
        ])
    
    def setup_callbacks(self):
        @self.app.callback(
            Output('bandwidth-graph', 'figure'),
            Input('interval-component', 'n_intervals')
        )
        def update_graph(n):
            # Get current bandwidth
            net_io = psutil.net_io_counters()
            current_time = time.time()
            
            if len(self.bandwidth_data['times']) > 0:
                last_upload = self.bandwidth_data['upload'][-1]
                last_download = self.bandwidth_data['download'][-1]
                
                upload_bps = (net_io.bytes_sent - last_upload) / 1
                download_bps = (net_io.bytes_recv - last_download) / 1
            else:
                upload_bps = download_bps = 0
            
            self.bandwidth_data['times'].append(current_time)
            self.bandwidth_data['upload'].append(upload_bps / 1024 / 1024)  # MB/s
            self.bandwidth_data['download'].append(download_bps / 1024 / 1024)  # MB/s
            
            # Keep only last 60 data points
            if len(self.bandwidth_data['times']) > 60:
                self.bandwidth_data['times'] = self.bandwidth_data['times'][-60:]
                self.bandwidth_data['upload'] = self.bandwidth_data['upload'][-60:]
                self.bandwidth_data['download'] = self.bandwidth_data['download'][-60:]
            
            figure = {
                'data': [
                    go.Scatter(
                        x=self.bandwidth_data['times'],
                        y=self.bandwidth_data['upload'],
                        name='Upload',
                        line=dict(color='red')
                    ),
                    go.Scatter(
                        x=self.bandwidth_data['times'],
                        y=self.bandwidth_data['download'],
                        name='Download',
                        line=dict(color='blue')
                    )
                ],
                'layout': go.Layout(
                    title='Real-time Bandwidth Usage',
                    xaxis={'title': 'Time'},
                    yaxis={'title': 'Bandwidth (MB/s)'}
                )
            }
            
            return figure
    
    def run(self, debug=True, port=8050):
        self.app.run_server(debug=debug, port=port)

# Run dashboard
if __name__ == '__main__':
    dashboard = BandwidthDashboard()
    dashboard.run()

def calculate_optimal_subnet(required_hosts, growth_factor=1.2):
    """Calculate optimal subnet size for required hosts."""
    # Account for growth
    adjusted_hosts = int(required_hosts * growth_factor)
    
    # Add 2 for network and broadcast addresses
    total_needed = adjusted_hosts + 2
    
    # Find smallest power of 2 that can accommodate
    for i in range(32):
        if 2**i >= total_needed:
            cidr = 32 - i
            return cidr
    
    return 32

# Example usage
departments = {
    'Sales': 50,
    'Marketing': 30,
    'IT': 20,
    'HR': 10
}

print("Optimal Subnet Sizes:")
for dept, hosts in departments.items():
    cidr = calculate_optimal_subnet(hosts)
    print(f"{dept}: /{cidr} ({2**(32-cidr)-2} usable hosts)")

import yaml

class NetworkDocumentation:
    def __init__(self):
        self.network_config = {
            'network_name': 'Corporate Network',
            'vlan_config': {},
            'subnet_config': {},
            'qos_config': {},
            'security_config': {}
        }
    
    def add_subnet(self, name, network, cidr, purpose, vlan=None):
        """Add subnet to documentation."""
        self.network_config['subnet_config'][name] = {
            'network': network,
            'cidr': cidr,
            'purpose': purpose,
            'vlan': vlan,
            'gateway': self.calculate_gateway(network),
            'broadcast': self.calculate_broadcast(network, cidr),
            'usable_hosts': 2**(32-cidr) - 2
        }
    
    def calculate_gateway(self, network):
        """Calculate gateway address (first usable host)."""
        # Implementation here
        pass
    
    def calculate_broadcast(self, network, cidr):
        """Calculate broadcast address."""
        # Implementation here
        pass
    
    def export_yaml(self, filename):
        """Export network configuration to YAML."""
        with open(filename, 'w') as f:
            yaml.dump(self.network_config, f, default_flow_style=False)
    
    def generate_report(self):
        """Generate network documentation report."""
        report = f"""
# Network Documentation Report

## Network Overview
- Name: {self.network_config['network_name']}
- Total Subnets: {len(self.network_config['subnet_config'])}

## Subnet Configuration
"""
        for name, config in self.network_config['subnet_config'].items():
            report += f"""
### {name}
- Network: {config['network']}/{config['cidr']}
- Purpose: {config['purpose']}
- Gateway: {config['gateway']}
- Broadcast: {config['broadcast']}
- Usable Hosts: {config['usable_hosts']}
"""
        return report

# Usage
doc = NetworkDocumentation()
doc.add_subnet('Sales', '192.168.10.0', 26, 'Sales department', vlan=10)
doc.add_subnet('IT', '192.168.20.0', 27, 'IT department', vlan=20)
doc.export_yaml('network_config.yaml')
print(doc.generate_report())