1. Ansible project - create_repo uses service-helloworld-ansible as a template 2. Puppet project - create_repo uses service-helloworld-puppet as a template """ import os import yaml import click import shutil import logger_utils import service_utils from abc import ABCMeta, abstractmethod from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.create_repo') class Repo(object): """ ABC for creating repos of type Ansible, Puppet, Project, EmptyProject """ __metaclass__ = ABCMeta def builder(rtype, gsrvr, path, name, username, interactive): """ Static method Instantiates Concreate classes of type Repo. """ slab_logger.log(15, 'Setting up repo method') if rtype is "Ansible": repo = Ansible(gsrvr, path, name, username, interactive)
""" Git check utilities """ import os import re import shlex import subprocess from subprocess import PIPE import logger_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.gitcheck') # Global vars class Gitcheckutils(object): """ Git check utilities class """ debugmod = False watchInterval = 0 srch_dir = None ignoreBranch = r'^$' # empty string # Search all local repositories from current directory @staticmethod def search_repositories(srch_dir): """ searches repositories
import os import boto3 import flask_security from flask import Flask from flask_bootstrap import Bootstrap from flask_mongoengine import MongoEngine from flask_security import Security, MongoEngineUserDatastore from logger_utils import setup_logger from models.security_model import User, Role from services.gallery_service import GalleryService setup_logger() app = Flask(__name__) Bootstrap(app) app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024 # MongoDB Config app.config['MONGODB_DB'] = 'wedding' app.config['MONGODB_SETTINGS'] = { 'db': 'wedding', 'host': os.environ['MONGO_URI'] } # security app.secret_key = os.environ['APP_SECRET'] app.config['SECURITY_PASSWORD_HASH'] = 'bcrypt' app.config['SECURITY_PASSWORD_SALT'] = os.environ['APP_SECRET']
""" Set of utility functions for Jenkins server """ import sys import time import requests from bs4 import BeautifulSoup from jenkinsapi.jenkins import Jenkins from requests.auth import HTTPBasicAuth import logger_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.jenkins') START_LOG = "-------- Printing job log for build %s--------\n" END_LOG = "-------- End of job log for build --------" def get_server_instance(jenkins_server, jenkinsuser, jenkinspass): """ For the given Jenkins servre, User Name and Password get the Jenkins instance. """ requests.packages.urllib3.disable_warnings() server = '' try: server = Jenkins(jenkins_server, username=jenkinsuser, password=jenkinspass)
""" import os from subprocess import CalledProcessError import vagrant import virtualbox from fabric.api import env, task from fabric.contrib.files import sed import yaml_utils import service_utils import vagrantfile_utils import logger_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.vagrant') class Connect_to_vagrant(object): """Vagrant class for booting, provisioning and managing a virtual machine.""" def __init__( self, vm_name, path, provider="virtualbox", default_vbox="Cisco/rhel-7", default_vbox_url='http://cis-kickstart.cisco.com/ccs-rhel-7.box'): """ Constructor for Vagrant Class Assigns member variables to constructor parameters.
import os import re import helper_utils import logger_utils import service_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.ruby') def setup_gems(path, ccsdata_repo=0): """ Set up gems in Gemfile to be used by bundler. Runs `bundle install` to setup gems in ccs-data if repo is present, and in home directory otherwise. Args: path (str): The path to your working .stack directory. Typically, this looks like ./servicelab/servicelab/.stack where "." is the path to the root of the servicelab repository. ccsdata_repo (int): set to 0 if ccs-data repo exists, 1 if it doesn't Returns: returncode (int): 0 -- Success 1 -- Failure, caused by failed bundle install Example Usage: >>> print setup_gems("/Users/aaltman/Git/servicelab/servicelab/.stack", 0)
import os import re import sys import yaml import socket import ipaddress import service_utils import logger_utils from servicelab import settings from servicelab.stack import Context slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.tc_vm_yaml_create') ctx = Context() def open_yaml(filename): """Opens yaml file into dictionary Args: filename {str}: File path and name to open Returns: {dict}: PyYaml extracted dict of data from the opened file Example Usage: file_data = open_yaml('/some/path/to/my/environment.yaml') """ try:
""" Help fuctions for public key encrytption and decryption. """ import service_utils import logger_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.encrypt') def public_key(fname): """Public Key Creation via SSL. Args: fname (str): Certificate file ssl uses to create public key. Returns: returncode (int): 0 -- Success 1 -- Failure, can't create key (possibly invalid certificate) cmd_info (str): stdout/stderr log of pubkey-creation command Example Usage: >>> print publickey(public_key_pem) (0, "") """ slab_logger.loc(15, 'Creating ssl public key') cmd = "openssl x509 -inform pem -in %s -pubkey -noout" % (fname) cmd_returncode, cmd_info = service_utils.run_this(cmd)
import os import re import shutil import fnmatch import getpass import yaml_utils import logger_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.helper') def find_all_yaml_recurs(full_path): """Find all yaml files in given directory structure recursively. Args: full_path (str): Ths is the full path that you want recursively explore for yaml files. Returns: Returncode (int): 0 -- Success 1 -- Failure matches (list): A list of files ending in yaml with their absolute paths. Example Usage: >>> print full_path /Users/aaltman/Git/servicelab/servicelab/.stack/services/ccs-data >>> print find_all_yaml_recurs(full_path)
import re import yaml import click import ccsdata_utils import yaml_utils import logger_utils from random import randint from fabric.api import run from servicelab import settings lab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.ccsdata_haproxy') def _search_env(path, env): slab_logger.debug('Searching for %s in ccs-data sites' % env) lst = [] ret_code, sites = ccsdata_utils.list_envs_or_sites(path) if ret_code > 0: return lst for site, envs in sites.iteritems(): if env in envs.keys(): lst.append((site, env)) return lst def generate_env_for_site(path, env): """ The generate_env_for_site is a generator iterating over all the environment in the path. It generates a tuple containing the {site, env} dictionary. It it does not find anything it raises
import logging import os import yaml from prettytable import PrettyTable import yaml_utils import ccsdata_utils import logger_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.ccsbuildtools') def gather_site_info(path, cont): """Gathers data from user for compiling site data into ccs-data. Example data gathered/required for building a site: --- bom: 4.2 secret: example_password ip_ranges: vlan2: 10.202.64.0/25 vlan4: 10.202.64.128/28 vlan65: 10.202.76.128/27 vlan68: 10.202.76.0/25 vlan82: 10.202.72.0/22 vlan83: 10.202.78.0/24 vlan84: 10.202.79.0/24 vlan67: 10.202.65.0/25
""" Set of utility functions for Jenkins server """ import requests import logger_utils from requests.auth import HTTPBasicAuth from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.artifact') def get_artifact_info(url, user, password): """ Get artifact info string """ slab_logger.debug('Extracting artifact information') requests.packages.urllib3.disable_warnings() try: res = requests.get(url, auth=HTTPBasicAuth(user, password)) except requests.ConnectionError as ex: slab_logger.error(ex) raise Exception("Cannot connect to artifactory : %s " % ex) return res.content def validate_artifact_ip_cb(ctx, param, value): """
import os import re import yaml import requests import operator from string import maketrans from prettytable import PrettyTable from bs4 import BeautifulSoup import service_utils import ccsbuildtools_utils import logger_utils from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.explain') def compile_man_page(path, user, password): """ Grabs data from confluence pages and servicelab docs and leverages sphinx to convert them into a single man page that will be queried for high level info. """ slab_logger.log(15, 'Building data for man pages') path_to_docs = os.path.split(path)[0] path_to_docs = os.path.split(path_to_docs)[0] path_to_docs = os.path.join(path_to_docs, 'docs') man_yaml = _load_slabmanyaml(path) # The man_contents.rst.inc file follows Sphinx syntax for enumerating the # files that will be included in the final man page
import re import yaml import logger_utils from collections import OrderedDict from servicelab import settings slab_logger = logger_utils.setup_logger(settings.verbosity, 'stack.utils.ordered_yaml') """ based on the stack overflow discussin http://stackoverflow.com/questions/5121931/\ in-python-how-can-you-load-yaml-mappings-as-ordereddicts """ def load(stream, Loader=yaml.Loader, object_pairs_hook=OrderedDict): slab_logger.log(15, 'Loading yaml file into ordered dictionary') class OrderedLoader(Loader): pass def construct_mapping(loader, node): loader.flatten_mapping(node) return object_pairs_hook(loader.construct_pairs(node)) OrderedLoader.add_constructor( yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, construct_mapping) return yaml.load(stream, OrderedLoader)