#Here we use the wrapper to get the current state (cpu intensive)
def _determine_bgp_status(self) -> str:
"""Get current BGP state by querying BGP neighbors and return UP or DOWN"""
try:
    output = self.run_command('sudo /usr/bin/wrapper_show_bgp_neighbors')
    
    if output:
        # Parse BGP state from the output
        # Look for the line "BGP state = <state>"
        bgp_state_match = re.search(r'BGP\s+state\s+=\s+(?P<bgp_state>\w+)', output)
        if bgp_state_match:
            bgp_state = bgp_state_match.group('bgp_state')
            logging.info(f"Found BGP state: {bgp_state}")
            
            # Determine if BGP is UP or DOWN based on the state
            # Established state means BGP is UP
            if bgp_state == 'Established':
                return 'UP'
            else:
                # All other states (Idle, Connect, Active, OpenSent, OpenConfirm) are considered DOWN
                return 'DOWN'
        else:
            logging.warning("Could not find BGP state in wrapper_show_bgp_neighbors output")
            return 'DOWN'
    else:
        logging.warning("No output received from wrapper_show_bgp_neighbors command")
        return 'DOWN'
        
except Exception as e:
    logging.error(f"Failed to execute wrapper_show_bgp_neighbors command: {e}")
    return 'DOWN'

import subprocess

class CommandRunner:
    def run_command(self, command):
        command_process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, text=True)
        output = command_process.communicate()[0].strip()
        return_code = command_process.returncode
        return output, return_code

def main():
    # Create instance of CommandRunner
    runner = CommandRunner()
    
    # Define the command
    command = 'ping -c 4 localhost'
    
    try:
        # Run the command and get output and return code
        output, return_code = runner.run_command(command)
        
        # Print the output and return code
        print(f"Command output:\n{output}")
        print(f"Return code: {return_code}")
        
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    main()

/**
 * Analyzes code using the Ollama API and returns a description and suggestions.
 * If the analysis is valid JSON, it is inserted into the AiDescriptions table.
 * @param code The code snippet to analyze.
 * @param language The programming language of the code.
 * @param postId (optional) The ID of the post being analyzed.
 * @returns An object containing description and suggestions.
 */
async function analyzeCodeWithOllama(
  code: string,
  language: string,
  postId?: string
): Promise<CodeAnalysisResponse> {
  if (!code || !language) {
    throw new Error('Code and language are required');
  }
  try {
    const prompt = createPrompt(code, language);
    const response: AxiosResponse = await axios.post(OLLAMA_API_URL, {
      model: MODEL_NAME,
      prompt,
      stream: false,
      think: false,
    });
    console.log('Raw Ollama response:', JSON.stringify(response.data, null, 2));
    let analysis: CodeAnalysisResponse;
    try {
      const responseText = typeof response.data === 'string' ? response.data : response.data.response || JSON.stringify(response.data);
      const jsonMatch = responseText.match(/{[\s\S]*}/);
      if (jsonMatch) {
        analysis = JSON.parse(jsonMatch[0]);
        // If valid JSON and postId is provided, insert into DB
        if (postId && analysis.description) {
          try {
            await insertAiDescription(postId, analysis.description, analysis.suggestions, new Date().toISOString());
          } catch (dbErr: any) {
            console.error(`Failed to insert AI description for post ${postId}:`, dbErr.message);
          }
        }
      } else {
        throw new Error('No valid JSON found in response');
      }
    } catch (parseError) {
      console.error('Error parsing Ollama response:', parseError, 'Response:', response.data);
      throw new Error('Failed to parse model response');
    }
    if (!analysis.description || !Array.isArray(analysis.suggestions)) {
      console.error('Invalid response format:', analysis);
      throw new Error('Invalid response format from model');
    }
    return analysis;
  } catch (error: any) {
    console.error('Error communicating with Ollama:', error.message);
    throw new Error('Failed to analyze code: ' + error.message);
  }
}

import subprocess
import re

def parse_bgp_route(prefix="[IP_ADDRESS]"):
    try:
        # Construct and execute vtysh command
        vtysh_command = f'show ip bgp {prefix}'
        process = subprocess.Popen(['vtysh', '-c', vtysh_command],
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE,
                                 text=True)
        output, error = process.communicate()
        
        if process.returncode != 0:
            return f"Error: {error}"

        # Initialize dictionary for BGP attributes
        bgp_info = {
            'next_hop': None,
            'as_path': [],
            'local_pref': None,
            'weight': None
        }

        # Parse the output using regex patterns
        lines = output.split('\n')
        for line in lines:
            # Get next hop IP
            if 'from' in line:
                next_hop_match = re.search(r'(\d+\.\d+\.\d+\.\d+) from', line)
                if next_hop_match:
                    bgp_info['next_hop'] = next_hop_match.group(1)

            # Get local pref, weight, and AS path
            if 'localpref' in line:
                # Extract local preference
                local_pref_match = re.search(r'localpref (\d+)', line)
                if local_pref_match:
                    bgp_info['local_pref'] = int(local_pref_match.group(1))

                # Extract weight
                weight_match = re.search(r'weight (\d+)', line)
                if weight_match:
                    bgp_info['weight'] = int(weight_match.group(1))

                # AS path would be empty for local routes
                # For routes with AS path, you would see numbers between the 'from' and 'Origin'
                as_path_match = re.search(r'from.*?(\d+[\s\d+]*)?Origin', line)
                if as_path_match and as_path_match.group(1):
                    bgp_info['as_path'] = [int(asn) for asn in as_path_match.group(1).split()]

        return bgp_info

    except Exception as e:
        return f"Error executing command: {str(e)}"

# Example usage
if __name__ == "__main__":
    result = parse_bgp_route()
    print("BGP Route Information:")
    print(f"Next Hop: {result['next_hop']}")
    print(f"AS Path: {result['as_path']}")
    print(f"Local Preference: {result['local_pref']}")
    print(f"Weight: {result['weight']}")

from datetime import datetime

def to_epoch(date_string):
    # Parse the date string in the format YYYY/MM/DD HH:MM:SS
    dt = datetime.strptime(date_string, '%Y/%m/%d %H:%M:%S')
    # Convert to epoch (seconds since Jan 1, 1970)
    epoch = int(dt.timestamp())
    return epoch

# Example usage
date_str = "2021/07/08 04:04:46"
result = to_epoch(date_str)
print(result)

import re
_proposal_regex = r'(?:(?:(IKE|ESP):)?[\w/]+(?:/NO_EXT_SEQ)?(?:, ?(IKE|ESP):[\w/]+(?:/NO_EXT_SEQ)?)*)?'
_proposals_re = rf'(?P<proposals>{_proposal_regex}|)'
pattern = rf'received proposals: {_proposals_re}'
match = re.match(pattern, 'received proposals: ')
print(match.group('proposals') if match else "No match")  # Prints "No match"