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)
