def test_custom_adjectives_nouns(self):
haikunator = Haikunator()
haikunator.adjectives = ['red']
haikunator.nouns = ['reindeer']
self.assertRegexp(haikunator.haikunate(),
'(red)(-)(reindeer)(-)(\\d{4})$')
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id,
app_secret)
#self.location = configData['location'] # comment out during preview
self.location = 'westus'
# create resource names
h = Haikunator()
self.rgname = h.haikunate()
self.container_name = h.haikunate(delimiter='')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id,
app_secret)
self.location = configData['location']
# generate resource group name
self.h = Haikunator()
self.rgname = self.h.haikunate()
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# generate vnet name
self.vnet = self.h.haikunate(delimiter='')
# generate public ip address names
self.ipname = self.vnet + 'ip'
self.lbipname = self.vnet + 'lbip'
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate resource group name
self.rgname = Haikunator.haikunate()
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# generate vnet name
self.vnet = Haikunator.haikunate(delimiter='')
# generate public ip address names
self.ipname = self.vnet + 'ip'
self.lbipname = self.vnet + 'lbip'
def test_general_functionality(self):
tests = [
[{}, '[a-z]+-[a-z]+-[0-9]{4}$'],
[{
'token_hex': True
}, '[a-z]+-[a-z]+-[0-f]{4}$'],
[{
'token_length': 9
}, '[a-z]+-[a-z]+-[0-9]{9}$'],
[{
'token_length': 9,
'token_hex': True
}, '[a-z]+-[a-z]+-[0-f]{9}$'],
[{
'token_length': 0
}, '[a-z]+-[a-z]+$'],
[{
'delimiter': '.'
}, '[a-z]+.[a-z]+.[0-9]{4}$'],
[{
'token_length': 0,
'delimiter': ' '
}, '[a-z]+ [a-z]+'],
[{
'token_length': 0,
'delimiter': ''
}, '[a-z]+$'],
[{
'token_chars': 'xyz'
}, '[a-z]+-[a-z]+-[x-z]{4}$'],
]
haikunator = Haikunator()
for test in tests:
self.assertRegexp(haikunator.haikunate(**test[0]), test[1])
def create_room(request):
new_room = None
while not new_room:
with transaction.atomic():
label = Haikunator().haikunate()
nickname = request.GET.get('nickname')
if nickname:
name = nickname
else:
name = Haikunator().haikunate(token_length=0, delimiter=' ')
if Room.objects.filter(label=label).exists():
continue
new_room = Room.objects.create(label=label, name=name)
if request.user.is_authenticated():
new_room.owner = request.user
new_room.save()
token = request.GET.get('token')
if token:
try:
widget = Widget.objects.as_token(token)
except Widget.DoesNotExist:
return new_room
new_room.widget = widget
new_room.save()
logger.debug('created room with label=%s from widget_token=%s',
new_room.label, widget.token)
context = {'email': widget.owner.email}
NewRoomNotifyMailer(request).send(context)
return new_room
def new_post(request, pk):
board = get_object_or_404(Board, pk=pk)
if request.method == 'POST':
form = NewPostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.board = board
post.original_poster = request.user
new_room = None
while not new_room:
with transaction.atomic():
haikunator = Haikunator()
label = haikunator.haikunate()
if Room.objects.filter(label=label).exists():
continue
new_room = Room.objects.create(
name=form.cleaned_data.get('title'),
poster=request.user,
label=label)
post.room = new_room
post.save()
return redirect(chat_room, label=label)
else:
form = NewPostForm()
return render(request, 'new_post.html', {'board': board, 'form': form})
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# create resource names
h = Haikunator()
self.rgname = h.haikunate()
self.service_name = h.haikunate(delimiter='')
self.agent_dns = h.haikunate(delimiter='')
self.master_dns = h.haikunate(delimiter='')
# generate RSA Key for container service
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
def test_empty_adjectives_nouns(self):
haikunator = Haikunator()
haikunator.adjectives = []
haikunator.nouns = []
haiku = haikunator.haikunate(token_chars='')
self.assertEqual(haiku, '')
def test_empty_adjectives_nouns(self):
haikunator = Haikunator()
haikunator.adjectives = []
haikunator.nouns = []
haiku = haikunator.haikunate(token_chars='')
self.assertEqual(haiku, '')
def new_game(request):
context = {}
context['searchForm'] = SearchUser()
user = request.user
# edit here
if request.method == 'GET':
return render(request, 'new_game.html', context)
else:
# new a game
# validate input ???
entry_funds = request.POST['entry_funds']
no_players = request.POST['no_players']
haikunator = Haikunator()
game_no = haikunator.haikunate()
new_game = Game(creator=request.user,
player_num=no_players,
entry_funds=entry_funds,
game_no=game_no)
new_game.save()
# new socket here?
return render(
request, 'game_init_success.html', {
"game_no": game_no,
"entry_funds": entry_funds,
"players": no_players,
"email_form": EmailPassword(),
"searchForm": SearchUser()
})
def create_league(user, name=None, users=None, notify=True):
if name is None:
haikunator = Haikunator()
name = haikunator.haikunate(token_length=0)
new_league = League(id=str(ObjectId()),
created=datetime.utcnow(),
name=name,
owner_id=user.id,
status=LeagueStatus.CREATED)
new_league.owner = user
insert_league(new_league)
members = [user]
if users is not None:
members = list(set(members + users))
for member in members:
insert_membership(new_league, member)
if notify and member.id != user.id:
user_added_to_league_notification(member, new_league)
return new_league
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id,
app_secret)
self.location = configData['location']
# create resource names
self.rgname = Haikunator.haikunate()
self.service_name = Haikunator.haikunate(delimiter='')
self.agent_dns = Haikunator.haikunate(delimiter='')
self.master_dns = Haikunator.haikunate(delimiter='')
# generate RSA Key for container service
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
def new_game(request):
game = Game.objects.filter(in_game='1')[:1]
if game.exists(): # non-empty
# need to check id as well
for i in range(1):
label = game[i].label
print("new_game_guess", label)
in_game = 1
return redirect(guess, label=label, in_game=in_game)
# if every game is full, create a new game
# the first person who go into the game
print("draw")
new_game = None
while not new_game:
with transaction.atomic():
h = Haikunator()
label = h.haikunate(delimiter='_')
if Game.objects.filter(label=label).exists():
continue
new_game = Game.objects.create(label=label, in_game='1')
target_list = [
"box", "house", "star", "rocket", "glasses", "tree", "boat",
"flower", "bee", "rabbit", "car", "airplane", "lamp", "bonbon",
"cat", "bird", "eye", "cloud", "guitar", "castle", "mushroom",
"bottle", "bed", "chair", "key", "gun", "phone", "shoe",
"book", "train", "pen", "ice cream", "dog", "sun", "moon",
"fish", "cheese", "money", "hat", "computer", "squirrel"
]
new_game.target_word = random.choice(target_list)
new_game.save()
print(new_game.target_word)
in_game = 1
return redirect(draw, label=label, in_game=in_game)
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as config_file:
config_data = json.load(config_file)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = config_data['tenantId']
app_id = config_data['appId']
app_secret = config_data['appSecret']
self.subscription_id = config_data['subscriptionId']
self.access_token = azurerm.get_access_token(
tenant_id, app_id, app_secret)
# self.location = config_data['location'] # comment out during preview
self.location = 'westus'
# create resource names
haik = Haikunator()
self.rgname = haik.haikunate()
self.container_name = haik.haikunate(delimiter='')
self.container_name2 = haik.haikunate(delimiter='')
self.container_group_name = haik.haikunate(delimiter='')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id,
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
def test_empty_adjectives_nouns(self):
haikunator = Haikunator(adjectives=[],
nouns=[],
qualities=[],
persons=[])
self.assertEqual(haikunator.haikunate(token_chars=''), '')
def test_empty_adjectives_nouns(self):
haikunator = Haikunator(
adjectives=[],
nouns=[]
)
self.assertEqual(haikunator.haikunate(token_chars=''), '')
def test_custom_adjectives_nouns(self):
haikunator = Haikunator(
adjectives=['adjective'],
nouns=['noun']
)
self.assertRegexp(haikunator.haikunate(), 'adjective-noun-\d{4}$')
def test_return_same_with_seed(self):
seed = 'definitively random seed'
h1 = Haikunator(seed=seed)
h2 = Haikunator(seed=seed)
self.assertEqual(h1.haikunate(), h2.haikunate())
self.assertEqual(h1.haikunate(), h2.haikunate())
def set_unique_ballot_code(self):
haikunator = Haikunator()
code = haikunator.haikunate(token_length=0)
while Judge.objects.filter(ballot_code=code).first():
code = haikunator.haikunate(token_length=0)
self.ballot_code = code
def __init__(self):
self.config = KeyVaultSampleConfig()
self.credentials = None
self.keyvault_data_client = None
self.keyvault_mgmt_client = None
self.resource_mgmt_client = None
self._setup_complete = False
self._haikunator = Haikunator()
def generate_id():
haikunator = Haikunator()
ids = get_cluster_ids_in_authorized_keys()
while True:
cluster_id = haikunator.haikunate(token_length=6, token_hex=True)
if cluster_id not in ids:
break
return cluster_id
def save(self, *args, **kwargs):
if self.pk is None:
haikunator = Haikunator()
self.username = haikunator.haikunate(token_length=0, delimiter='')
while User.objects.filter(username=self.username).exists():
self.username = haikunator.haikunate(token_length=0,
delimiter='')
super().save(*args, **kwargs)
def init_trips(trips):
from haikunator import Haikunator
h = Haikunator()
origin_cities = [
'San Francisco, USA', 'New York City, USA', 'Chicago, USA'
]
dest_cities = [
'San José - Juan Santamaría', 'San José - Tobías Bolaños',
'Limón International', 'Liberia - Daniel Oduber Quirós'
]
for i in range(trips):
# create user
user_id = uuid4()
password = '******'
username = h.haikunate()
salt = crypto.salt()
user = {
'user_id': user_id.__str__(),
'user': username,
'email': '*****@*****.**',
'salt': salt,
'hash': crypto.hash(password, username, salt)
}
db['users'].insert(user)
user = db['users'].find_one(user_id=user_id.__str__())
departure_date = datetime.datetime(2017, random.choice(range(3,7)), random.choice(range(1,30)), \
random.choice(range(1,24)), random.choice(range(1,60)),1 )
incremented_day = departure_date.day + 1
arrival_date = datetime.datetime(departure_date.year,
departure_date.month, incremented_day,
random.choice(range(1, 24)),
random.choice(range(1, 60)), 1)
# create trip
db['trips'].insert({
'origin':
random.choice(origin_cities),
'traveller_id':
user['id'],
'destination':
random.choice(dest_cities),
'departure_date':
departure_date,
'arrival_date':
arrival_date,
'flight_number':
'FA-{}'.format(random.choice(range(100, 300))),
'size':
random.choice(['small', 'medium', 'large']),
'created_at':
datetime.datetime.now()
})
def get_or_create_guest_account(self, user, request):
custom_user, username = LazyUser.objects.create_lazy_user()
haikunator = Haikunator()
usernames = [user.username for user in CustomUser.objects.all()]
guest_name = haikunator.haikunate(token_length=0)
while guest_name in usernames:
guest_name = haikunator.haikunate(token_length=0)
custom_user.nickname = guest_name
custom_user.save()
new_lazy_user = LazyUser.objects.get(user__username=username)
return new_lazy_user
def createhex(resources, nums, row, col):
resource = resources.pop(randrange(0, len(resources)))
num = 7
if resource != 'desert': num = nums.pop(randrange(0, len(nums)))
h = Hex.objects.create(game=self,
resource=resource,
number=num,
row=row,
col=col)
h.full_clean()
h.save()
def save(self, *args, **kwargs):
# Generate a random ballot code for judges that don't have one
if not self.ballot_code:
haikunator = Haikunator()
code = haikunator.haikunate(token_length=0)
while Judge.objects.filter(ballot_code=code).first():
code = haikunator.haikunate(token_length=0)
self.ballot_code = code
super(Judge, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
# Generate a random ballot code for judges that don't have one
if not self.ballot_code:
haikunator = Haikunator()
code = haikunator.haikunate(token_length=0)
while Judge.objects.filter(ballot_code=code).first():
code = haikunator.haikunate(token_length=0)
self.ballot_code = code
super(Judge, self).save(*args, **kwargs)
def save_starbucks(request):
client_id = "pOK1vfqW3iwmGmewUghS"
client_secret = "kBsI_gIGhC"
text = u"스타벅스"
encode_text = text.encode('utf-8')
base_url = "https://openapi.naver.com/v1/search/local.json"
start = 1
count = 0
result_list = []
while True:
try:
url = base_url + '?' + urllib.urlencode({
'query': encode_text,
'display': 99,
'start': start,
})
request = urllib2.Request(url)
request.add_header('Content-Type', 'application/json')
request.add_header("X-Naver-Client-Id", client_id)
request.add_header("X-Naver-Client-Secret", client_secret)
response = urllib2.urlopen(request).read()
except Exception as e:
raise Exception(e)
else:
result = json.loads(response)
result_list += (result['items'])
start += 99
count += 99
if result['total'] <= count or start > 1000:
break
haikunator = Haikunator(nouns=['starbucks'])
for result in result_list:
if result['title'].startswith(u'<b>스타벅스</b> '):
name = result['title'].replace(u'<b>스타벅스</b>', u'스타벅스')
new_room = None
if CafeRoom.objects.filter(name=name).exists():
continue
while not new_room:
with transaction.atomic():
label = haikunator.haikunate()
if CafeRoom.objects.filter(label=label).exists():
continue
new_room, created = CafeRoom.objects.get_or_create(
name=name,
label=label,
mapx=result['mapx'],
mapy=result['mapy'])
return redirect(about)
def new_room(request):
"""
Randomly create a new room, and redirect to it.
"""
new_room = None
while not new_room:
with transaction.atomic():
haikunator = Haikunator()
label = haikunator.haikunate()
if Room.objects.filter(label=label).exists():
continue
new_room = Room.objects.create(label=label)
return redirect(chat_room, label=label)
def new_room(request):
"""
Randomly create a new room, and redirect to it.
"""
haikunator = Haikunator()
new_room = None
while not new_room:
with transaction.atomic():
label = haikunator.haikunate()
if Room.objects.filter(label=label).exists():
continue
new_room = Room.objects.create(label=label)
return redirect('chat:chat_room', label=label)
def __init__(self, subscription_id, resource_group):
self.subscription_id = subscription_id
self.resource_group = resource_group
self.name_generator = Haikunator()
self.name = self.name_generator.haikunate()
credentials = ClientSecretCredential(
client_id=os.environ['AZURE_CLIENT_ID'],
client_secret=os.environ['AZURE_CLIENT_SECRET'],
tenant_id=os.environ['AZURE_TENANT_ID']
)
self.client = ResourceManagementClient(credentials, subscription_id)
def new_room(request):
"""
Randomly create a new room, and redirect to it.
"""
new_room = None
while not new_room:
with transaction.atomic():
haikunator = Haikunator()
label = haikunator.haikunate()
if Room.objects.filter(label=label).exists():
continue
new_room = Room.objects.create(label=label, poster=request.user)
return JsonResponse({'label': label})
def __init__(self, guitar_id):
faker = Faker()
haikunator = Haikunator()
self.guitar_id = guitar_id
self.manufacturer_name = self.guitar_comp_list[random.randint(0, len(self.guitar_comp_list) - 1)]
self.guitar_name = haikunator.haikunate(token_length=0, delimiter=' ').title()
if self.manufacturer_name == "Gibson":
self.guitar_model = self.gibson_guitar_list[random.randint(0, len(self.gibson_guitar_list) - 1)]
elif self.manufacturer_name == "Gretsch":
self.guitar_model = self.gretsch_guitar_list[random.randint(0, len(self.gretsch_guitar_list) - 1)]
elif self.manufacturer_name == "Fender":
self.guitar_model = self.fender_guitar_list[random.randint(0, len(self.fender_guitar_list) - 1)]
elif self.manufacturer_name == "G&L":
self.guitar_model = self.gl_guitar_list[random.randint(0, len(self.gl_guitar_list) - 1)]
elif self.manufacturer_name == "Ibanez":
self.guitar_model = self.ibanez_guitar_list[random.randint(0, len(self.ibanez_guitar_list) - 1)]
elif self.manufacturer_name == "Friedman":
self.guitar_model = self.friedman_guitar_list[random.randint(0, len(self.friedman_guitar_list) - 1)]
elif self.manufacturer_name == "Paul Reed Smith":
self.guitar_model = self.prs_guitar_list[random.randint(0, len(self.prs_guitar_list) - 1)]
elif self.manufacturer_name == "Squier":
self.guitar_model = self.squier_guitar_list[random.randint(0, len(self.squier_guitar_list) - 1)]
elif self.manufacturer_name == "Epiphone":
self.guitar_model = self.epiphone_guitar_list[random.randint(0, len(self.epiphone_guitar_list) - 1)]
elif self.manufacturer_name == "ESP":
self.guitar_model = self.esp_guitar_list[random.randint(0, len(self.esp_guitar_list) - 1)]
elif self.manufacturer_name == "Taylor":
self.guitar_model = self.taylor_guitar_list[random.randint(0, len(self.taylor_guitar_list) - 1)]
elif self.manufacturer_name == "Washburn":
self.guitar_model = self.washburn_guitar_list[random.randint(0, len(self.washburn_guitar_list) - 1)]
elif self.manufacturer_name == "Martin":
self.guitar_model = self.martin_guitar_list[random.randint(0, len(self.martin_guitar_list) - 1)]
elif self.manufacturer_name == "Rickenbacker":
self.guitar_model = self.rickenbacker_guitar_list[random.randint(0, len(self.rickenbacker_guitar_list) - 1)]
elif self.manufacturer_name == "Schecter":
self.guitar_model = self.schecter_guitar_list[random.randint(0, len(self.schecter_guitar_list) - 1)]
elif self.manufacturer_name == "Jackson":
self.guitar_model = self.jackson_guitar_list[random.randint(0, len(self.jackson_guitar_list) - 1)]
elif self.manufacturer_name == "B.C. Rich":
self.guitar_model = self.bc_rich_guitar_list[random.randint(0, len(self.bc_rich_guitar_list) - 1)]
elif self.manufacturer_name == "Carvin":
self.guitar_model = self.carvin_guitar_list[random.randint(0, len(self.carvin_guitar_list) - 1)]
elif self.manufacturer_name == "Charvel":
self.guitar_model = self.charvel_guitar_list[random.randint(0, len(self.charvel_guitar_list) - 1)]
elif self.manufacturer_name == "Scala":
self.guitar_model = self.scala_guitar_list[random.randint(0, len(self.scala_guitar_list) - 1)]
elif self.manufacturer_name == "Guild":
self.guitar_model = self.guild_guitar_list[random.randint(0, len(self.guild_guitar_list) - 1)]
self.serial_number = faker.ean(length=13)
def __init__(self):
self.package_dir = Path(__loader__.path).parent
self.deploy_dir = self.package_dir.parent
self.project_dir = self.deploy_dir.parent
with open(self.deploy_dir / 'config.yaml', 'r') as f:
config = yaml.load(f, Loader=yaml.SafeLoader)
self.name = config['name']
self.gcloud = utils.Struct()
self.gcloud.project = config['gcloud']['project']
self.gcloud.region = config['gcloud']['region']
self.gcloud.fq_zone = f"{config['gcloud']['region']}-{config['gcloud']['zone']}"
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = str(
self.deploy_dir / config['gcloud']['service_account_file'])
self.run_name = Haikunator.haikunate(0)
self.logging_level = getattr(logging, config['logging'].upper())
logging.basicConfig(level=self.logging_level)
self._scratch_dir = tempfile.TemporaryDirectory()
# this will be deleted when this classes deconstructor is
# called, which happens when the program exits.
self.scratch_dir = Path(self._scratch_dir.name)
self.cache_dir = Path(self.deploy_dir / 'cache')
def test_compute(self):
# create VM
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04.0-LTS'
version = 'latest'
os_uri = 'http://' + self.saname + '.blob.core.windows.net/vhds/osdisk.vhd'
username = '******'
password = Haikunator.haikunate(delimiter=',')
print('Creating VM: ' + self.vmname)
response = azurerm.create_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname, vm_size, publisher, offer, sku, version, self.saname, os_uri, \
self.nic_id, self.location, username=username, public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmname)
# create VMSS
capacity = 3
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, self.container_list, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmssname)
# get compute usage
print('Getting compute usage')
response = azurerm.get_compute_usage(self.access_token, self.subscription_id, self.location)
self.assertTrue(len(response['value']) > 0)
# get vm instance view
print('Getting VM instance view')
response = azurerm.get_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname, self.vmname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertEqual(response['statuses'][0]['displayStatus'], 'Creating')
# list vm instance views
print('Listing VM instance views')
response = azurerm.list_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# delete VM
print('Deleting VM: ' + self.vmname)
response = azurerm.delete_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname)
self.assertEqual(response.status_code, 202)
# delete VMSS
print('Deleting VMSS: ' + self.vmssname)
response = azurerm.delete_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname)
self.assertEqual(response.status_code, 202)
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
h = Haikunator()
self.rgname = h.haikunate()
def send_status(self):
payload = {
'hexes': [h.as_dict() for h in self.hex_set.all()],
'pieces': [p.as_dict() for p in self.piece_set.all()]
}
print 'sending status', payload
self.lobby.broadcast(payload)
def set_cookie(cookie_key):
cookie_val = Haikunator().haikunate()
rsp_text = 'Cookie "' + cookie_key + '" set to <b>' + cookie_val + '</b>'
rsp_text += get_endpoints_description(cookie_key)
response = app.make_response(rsp_text)
response.set_cookie(cookie_key, value=cookie_val)
return response
def test_general_functionality(self):
tests = [
[{}, '[a-z]+-[a-z]+-[0-9]{4}$'],
[{'token_hex': True}, '[a-z]+-[a-z]+-[0-f]{4}$'],
[{'token_length': 9}, '[a-z]+-[a-z]+-[0-9]{9}$'],
[{'token_length': 9, 'token_hex': True}, '[a-z]+-[a-z]+-[0-f]{9}$'],
[{'token_length': 0}, '[a-z]+-[a-z]+$'],
[{'delimiter': '.'}, '[a-z]+.[a-z]+.[0-9]{4}$'],
[{'token_length': 0, 'delimiter': ' '}, '[a-z]+ [a-z]+'],
[{'token_length': 0, 'delimiter': ''}, '[a-z]+$'],
[{'token_chars': 'xyz'}, '[a-z]+-[a-z]+-[x-z]{4}$'],
]
haikunator = Haikunator()
for test in tests:
self.assertRegexp(haikunator.haikunate(**test[0]), test[1])
def upload_file(bill_id):
"""
Upload File to S3 Bucket
"""
# First check if bill id attempted to be attached to exists and belongs to user
bill = BillModel.get_one_bill(bill_id)
if not bill:
return custom_response({'error': 'Bill Not Found'}, 404)
email_address_in_auth_header = request.authorization.username
user_object = UserModel.get_user_by_email(email_address_in_auth_header)
user_id = user_object.id
if (user_id != bill.owner_id):
return custom_response({'error': 'Unauthorized Access to Bill'}, 401)
bill_data = bill_schema.dump(bill) # bill exists and belongs to user attempting to post file
if 'file' not in request.files: # check if the post request has an attached file
custom_response({'error': 'No file part in the request'}, 400)
file = request.files['file']
if file.filename == '':
custom_response({'error': 'No file selected for uploading'}, 400)
if file and allowed_file(file.filename): # check if destination bill already exists in the file models
bill_in_question = FileModel.select_file_by_bill_id(bill_id) # since each bill can only have 1 attachment, don't proceed if bill already exists
if bill_in_question: # if bill in question exists, can't add another file attachment
return custom_response("bill already has file attached, please delete attachment!", 400)
s3_resource = boto3.resource('s3')
bucketname = ""
for bucket in s3_resource.buckets.all():
bucketname = bucket.name
content_type = request.mimetype
s3_client = boto3.client('s3',
region_name='us-east-2',
aws_access_key_id=os.environ['ACCESS_KEY'],
aws_secret_access_key=os.environ['SECRET_KEY'])
file_id = str(uuid.uuid4()) # bill does not contain an attachment so continue to build file metadata
filename = secure_filename(file.filename) # This is convenient to validate your filename, otherwise just use file.filename
s3_client.put_object(Body=file,
Bucket=bucketname,
Key=filename,
ContentType=content_type)
file_size = s3_client.head_object(Bucket=bucketname, Key=filename).get('ContentLength')
url = Haikunator().haikunate(delimiter = '.', token_hex = True, token_length = 6)
upload_date = str(s3_client.head_object(Bucket=bucketname, Key=filename).get('LastModified'))
hash_digest = s3_client.head_object(Bucket=bucketname, Key='filename').get('ETag')
file_dict = {'id': file_id, 'url': url, 'hash_digest': hash_digest, 'file_size': file_size, 'upload_date': upload_date, 'file_name': filename, 'file_owner': user_id, 'bill_attached_to': bill_id}
file_data = file_schema.load(file_dict)
file_object = FileModel(file_data) # save file object to postgresql file table
file_object.save()
file_http_response = file_schema.dump(file_object)
return custom_response(file_http_response, 201)
else:
return custom_response('Allowed file types are pdf, png, jpg, jpeg', 400)
def refresh_feed(self, serv):
"""Refresh Ampache played RSS feed"""
d = feedparser.parse("%s/rss.php?type=recently_played" %
(config.ampache_URL,))
for entry in d.entries:
if(self.last_seen is None or
entry.published_parsed > self.last_seen):
haikunator = Haikunator(entry.comments
.replace(config.ampache_URL, "")
.strip("/"))
name = haikunator.haikunate(token_length=0).replace("-", " ")
name = name.title()
serv.privmsg(config.channel,
"%c%02d%s (%s)" %
(3, 14, entry.title,
name))
self.last_seen = entry.published_parsed
def setUp(self):
# Load Azure app defaults
try:
with open("azurermconfig.json") as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData["tenantId"]
app_id = configData["appId"]
app_secret = configData["appSecret"]
self.subscription_id = configData["subscriptionId"]
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData["location"]
self.rgname = Haikunator.haikunate()
# create resource group
print("Creating resource group: " + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# storage account name
self.storage_account = Haikunator.haikunate(delimiter="")
def main():
'''Main routine.'''
# validate command line arguments
argparser = argparse.ArgumentParser()
argparser.add_argument('--uri', '-u', required=True,
action='store', help='Template URI')
argparser.add_argument('--params', '-f', required=True,
action='store', help='Parameters json file')
argparser.add_argument('--location', '-l', required=True,
action='store', help='Location, e.g. eastus')
argparser.add_argument('--rg', '-g', required=False,
action='store', help='Resource Group name')
argparser.add_argument('--sub', '-s', required=False,
action='store', help='Subscription ID')
argparser.add_argument('--genparams', '-p', required=False,
action='store', help='Comma separated list of parameters to generate strings for')
argparser.add_argument('--wait', '-w', required=False, action='store_true', default=False,
help='Wait for deployment to complete and time it')
argparser.add_argument('--debug', '-d', required=False, action='store_true', default=False,
help='Debug mode: print additional deployment')
args = argparser.parse_args()
template_uri = args.uri
params = args.params
rgname = args.rg
location = args.location
subscription_id = args.sub
# Load Azure app defaults
try:
with open('azurermconfig.json') as configfile:
configdata = json.load(configfile)
except FileNotFoundError:
sys.exit('Error: Expecting azurermconfig.json in current folder')
tenant_id = configdata['tenantId']
app_id = configdata['appId']
app_secret = configdata['appSecret']
if subscription_id is None:
subscription_id = configdata['subscriptionId']
# authenticate
access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
# load parameters file
try:
with open(params) as params_file:
param_data = json.load(params_file)
except FileNotFoundError:
sys.exit('Error: Expecting ' + params + ' in current folder')
# prep Haikunator
haikunator = Haikunator()
# if there is a genparams argument generate values and merge the list
if args.genparams is not None:
newdict = {}
genlist = args.genparams.split(',')
for param in genlist:
# generate a random prhase, include caps and puncs in case it's a passwd
newval = haikunator.haikunate(delimiter='-').title()
newdict[param] = {'value': newval}
params = {**param_data, **newdict}
else:
params = param_data
# create resource group if not specified
if rgname is None:
rgname = haikunator.haikunate()
ret = azurerm.create_resource_group(
access_token, subscription_id, rgname, location)
print('Creating resource group: ' + rgname +
', location:', location + ', return code:', ret)
deployment_name = haikunator.haikunate()
# measure time from beginning of deployment call (after creating resource group etc.)
start_time = time.time()
# deploy template and print response
deploy_return = azurerm.deploy_template_uri(
access_token, subscription_id, rgname, deployment_name, template_uri, params)
print('Deployment name: ' + deployment_name +
', return code:', deploy_return)
if 'Response [20' not in str(deploy_return):
print('Return from deployment: ', deploy_return.text)
sys.exit('Deployment failed. Exiting.. ')
if args.debug is True:
print(json.dumps(deploy_return.json(), sort_keys=False,
indent=2, separators=(',', ': ')))
# show deployment status
if args.debug is True:
print('Deployment status:')
deploy_return = azurerm.show_deployment(
access_token, subscription_id, rgname, deployment_name)
print(json.dumps(deploy_return, sort_keys=False,
indent=2, separators=(',', ': ')))
# wait for deployment to complete
if args.wait is True:
print('Waiting for provisioning to complete..')
provisioning_state = ''
try:
while True:
time.sleep(10)
deploy_return = azurerm.show_deployment(
access_token, subscription_id, rgname, deployment_name)
provisioning_state = deploy_return['properties']['provisioningState']
if provisioning_state != 'Running':
break
print('Provisioning state:', provisioning_state)
except KeyError:
print('Deployment failure:', deploy_return)
elapsed_time = time.time() - start_time
print('Elapsed time:', elapsed_time)
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate names for resources
self.rgname = Haikunator.haikunate()
self.vnet = Haikunator.haikunate(delimiter='')
self.vmssname = Haikunator.haikunate(delimiter='')
self.setting_name = Haikunator.haikunate(delimiter='')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create 5 storage accounts for vmssname
print('Creating storage accounts for scale set')
self.container_list = []
for count in range(5):
sa_name = ''.join(choice(ascii_lowercase) for i in range(10))
print(sa_name)
response = azurerm.create_storage_account(self.access_token, self.subscription_id, \
self.rgname, sa_name, self.location, storage_type='Standard_LRS')
self.assertEqual(response.status_code, 202)
container = 'https://' + sa_name + '.blob.core.windows.net/' + self.vmssname + 'vhd'
self.container_list.append(container)
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json()['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
capacity = 1
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04.0-LTS'
version = 'latest'
username = '******'
password = Haikunator.haikunate(delimiter=',')
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, self.container_list, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
password=password)
def test_wont_return_same(self):
haikunator = Haikunator()
self.assertNotEqual(haikunator.haikunate(), haikunator.haikunate())
def test_return_same_with_seed(self):
haikunator1 = Haikunator(1234)
haikunator2 = Haikunator(1234)
self.assertEqual(haikunator1.haikunate(), haikunator2.haikunate())
def test_custom_adjectives_nouns(self):
haikunator = Haikunator()
haikunator.adjectives = ['red']
haikunator.nouns = ['reindeer']
self.assertRegexp(haikunator.haikunate(), '(red)(-)(reindeer)(-)(\\d{4})$')
def get_rand_name():
h = Haikunator()
return h.haikunate()
import os
from azure.common.credentials import ServicePrincipalCredentials
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.storage import StorageManagementClient
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.compute import ComputeManagementClient
from haikunator import Haikunator
haikunator = Haikunator()
# Azure Datacenter
LOCATION = 'westus'
# Resource Group
GROUP_NAME = 'azure-sample-group-virtual-machines'
# Network
VNET_NAME = 'azure-sample-vnet'
SUBNET_NAME = 'azure-sample-subnet'
# VM
OS_DISK_NAME = 'azure-sample-osdisk'
STORAGE_ACCOUNT_NAME = haikunator.haikunate(delimiter='')
IP_CONFIG_NAME = 'azure-sample-ip-config'
NIC_NAME = 'azure-sample-nic'
USERNAME = '******'
PASSWORD = '******'
VM_NAME = 'VmName'
VM_REFERENCE = {
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate names used in tests
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate()
# self.saname = self.h.haikunate(delimiter='')
self.vmname = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.asname = self.h.haikunate()
# generate RSA Key for compute resources
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VM NIC
self.ipname = self.vnet + 'ip'
print('Creating VM NIC public ip address: ' + self.ipname)
dns_label = self.vnet
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname, dns_label, self.location)
self.assertEqual(response.status_code, 201)
self.ip_id = response.json()['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create NSG
nsg_name = self.vnet + 'nsg'
print('Creating NSG: ' + nsg_name)
response = azurerm.create_nsg(self.access_token, self.subscription_id, self.rgname, \
nsg_name, self.location)
self.assertEqual(response.status_code, 201)
# print(json.dumps(response.json()))
self.nsg_id = response.json()['id']
# create NSG rule
nsg_rule = 'ssh'
print('Creating NSG rule: ' + nsg_rule)
response = azurerm.create_nsg_rule(self.access_token, self.subscription_id, self.rgname, \
nsg_name, nsg_rule, description='ssh rule', destination_range='22')
self.assertEqual(response.status_code, 201)
# create nic for VM create
nic_name = self.vnet + 'nic'
print('Creating nic: ' + nic_name)
response = azurerm.create_nic(self.access_token, self.subscription_id, self.rgname, \
nic_name, self.ip_id, self.subnet_id, self.location)
self.assertEqual(response.status_code, 201)
self.nic_id = response.json()['id']
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json()['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json()['properties']['inboundNatPools'][0]['id']
class TestAzurermPy(unittest.TestCase):
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate names used in tests
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate()
# self.saname = self.h.haikunate(delimiter='')
self.vmname = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.asname = self.h.haikunate()
# generate RSA Key for compute resources
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VM NIC
self.ipname = self.vnet + 'ip'
print('Creating VM NIC public ip address: ' + self.ipname)
dns_label = self.vnet
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname, dns_label, self.location)
self.assertEqual(response.status_code, 201)
self.ip_id = response.json()['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create NSG
nsg_name = self.vnet + 'nsg'
print('Creating NSG: ' + nsg_name)
response = azurerm.create_nsg(self.access_token, self.subscription_id, self.rgname, \
nsg_name, self.location)
self.assertEqual(response.status_code, 201)
# print(json.dumps(response.json()))
self.nsg_id = response.json()['id']
# create NSG rule
nsg_rule = 'ssh'
print('Creating NSG rule: ' + nsg_rule)
response = azurerm.create_nsg_rule(self.access_token, self.subscription_id, self.rgname, \
nsg_name, nsg_rule, description='ssh rule', destination_range='22')
self.assertEqual(response.status_code, 201)
# create nic for VM create
nic_name = self.vnet + 'nic'
print('Creating nic: ' + nic_name)
response = azurerm.create_nic(self.access_token, self.subscription_id, self.rgname, \
nic_name, self.ip_id, self.subnet_id, self.location)
self.assertEqual(response.status_code, 201)
self.nic_id = response.json()['id']
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json()['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json()['properties']['inboundNatPools'][0]['id']
def tearDown(self):
# delete resource group - that deletes everything in the test
print('Deleting resource group: ' + self.rgname)
response = azurerm.delete_resource_group(self.access_token, self.subscription_id, \
self.rgname)
self.assertEqual(response.status_code, 202)
def test_compute(self):
# create availability set
print('Creating availability set: ' + self.asname + ', update domains = 5, fault domains = 3')
response = azurerm.create_as(self.access_token, self.subscription_id, self.rgname,
self.asname, 5, 3, self.location)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['name'], self.asname)
# create VM
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = self.h.haikunate(',')
print('Creating VM: ' + self.vmname)
response = azurerm.create_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname, vm_size, publisher, offer, sku, version, \
self.nic_id, self.location, username=username, public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmname)
# create VMSS
capacity = 3
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmssname)
# get compute usage
print('Getting compute usage')
response = azurerm.get_compute_usage(self.access_token, self.subscription_id, self.location)
self.assertTrue(len(response['value']) > 0)
# get vm instance view
print('Getting VM instance view')
response = azurerm.get_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname, self.vmname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertEqual(response['statuses'][0]['displayStatus'], 'Creating')
# get availability set details
print('Getting availability set details')
response = azurerm.get_as(self.access_token, self.subscription_id, self.rgname, self.asname)
self.assertEqual(response['name'], self.asname)
# list vm instance views
print('Listing VM instance views')
response = azurerm.list_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# list VMSS skus
print('Listing VMSS skus')
response = azurerm.list_vmss_skus(self.access_token, self.subscription_id, \
self.rgname, self.vmssname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# list VMSS nics
print('Getting VMSS NICs')
response = azurerm.get_vmss_nics(self.access_token, self.subscription_id, \
self.rgname, self.vmssname)
#print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# delete VM
print('Deleting VM: ' + self.vmname)
response = azurerm.delete_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname)
self.assertEqual(response.status_code, 202)
# delete VMSS
print('Deleting VMSS: ' + self.vmssname)
response = azurerm.delete_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname)
self.assertEqual(response.status_code, 202)
# delete Availability Set
print('Deleting Availability Set: ' + self.asname)
response = azurerm.delete_as(self.access_token, self.subscription_id, self.rgname, \
self.asname)
self.assertEqual(response.status_code, 200)
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate names for resources
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.setting_name = self.h.haikunate(delimiter='')
# generate RSA Key for compute resources
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json()['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
capacity = 1
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = self.h.haikunate(delimiter=',')
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
dns_label = name + 'ip'
print('Creating public IP address: ' + public_ip_name)
rmreturn = azurerm.create_public_ip(access_token, subscription_id, name, public_ip_name, dns_label, location)
print(rmreturn)
ip_id = rmreturn.json()['id']
print('ip_id = ' + ip_id)
# create NIC
nic_name = name + 'nic'
print('Creating NIC: ' + nic_name)
rmreturn = azurerm.create_nic(access_token, subscription_id, name, nic_name, ip_id, subnet_id, location)
print(rmreturn)
nic_id = rmreturn.json()['id']
# create VM
vm_name = name
vm_size = 'Standard_DS1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04.0-LTS'
version = 'latest'
os_uri = 'http://' + name + '.blob.core.windows.net/vhds/osdisk.vhd'
username = '******'
password = Haikunator.haikunate(delimiter=',') # creates random password
print('Creating VM: ' + vm_name)
rmreturn = azurerm.create_vm(access_token, subscription_id, name, vm_name, vm_size, publisher, offer, sku,
version, name, os_uri, nic_id, location, username=username, password=password)
print(rmreturn)
print(json.dumps(rmreturn.json(), sort_keys=False, indent=2, separators=(',', ': ')))
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
subscription_id = configData['subscriptionId']
# authenticate
access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
location = 'eastus'
# create resource group
rgname = Haikunator.haikunate()
print('Creating resource group: ' + rgname)
response = azurerm.create_resource_group(access_token, subscription_id, rgname, location)
if response.status_code != 201:
print(json.dumps(response.json(), sort_keys=False, indent=2, separators=(',', ': ')))
sys.exit('Expecting return code 201 from create_resource_group(): ')
# create Container Service name and DNS values
service_name = Haikunator.haikunate(delimiter='')
agent_dns = Haikunator.haikunate(delimiter='')
master_dns = Haikunator.haikunate(delimiter='')
# generate RSA Key for container service
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
class TestAzurermPy(unittest.TestCase):
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate names for resources
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.setting_name = self.h.haikunate(delimiter='')
# generate RSA Key for compute resources
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json()['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
capacity = 1
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = self.h.haikunate(delimiter=',')
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
def tearDown(self):
# delete resource group - that deletes everything in the test
print('Deleting resource group: ' + self.rgname)
response = azurerm.delete_resource_group(self.access_token, self.subscription_id, \
self.rgname)
self.assertEqual(response.status_code, 202)
def test_insights(self):
# create autoscale rule
print('Creating autoscale rules')
metric_name = 'Percentage CPU'
operator = 'GreaterThan'
threshold = 60
direction = 'Increase'
change_count = 1
rule1 = azurerm.create_autoscale_rule(self.subscription_id, self.rgname, self.vmssname, \
metric_name, operator, threshold, direction, change_count)
operator = 'LessThan'
direction = 'Decrease'
rule2 = azurerm.create_autoscale_rule(self.subscription_id, self.rgname, self.vmssname, \
metric_name, operator, threshold, direction, change_count)
rules = [rule1, rule2]
# print(json.dumps(rules, sort_keys=False, indent=2, separators=(',', ': ')))
# create autoscale setting
print('Creating autoscale setting: ' + self.setting_name)
min = 1
max = 10
default = 3
response = azurerm.create_autoscale_setting(self.access_token, self.subscription_id, \
self.rgname, self.setting_name, self.vmssname, self.location, min, max, default, \
rules)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.setting_name)
# get audit log events
print('Getting audit log events')
# start_timestamp = '2017-05-01T00:00:00.0000000Z'
start_timestamp = str(datetime.datetime.now() - datetime.timedelta(days=1))
response = azurerm.get_events_for_subscription(self.access_token, self.subscription_id, \
start_timestamp)
self.assertTrue(len(response['value']) > 0)
import os from azure.common.credentials import ServicePrincipalCredentials from azure.mgmt.resource import ResourceManagementClient from azure.mgmt.storage import StorageManagementClient from azure.mgmt.network import NetworkManagementClient from azure.mgmt.compute import ComputeManagementClient from haikunator import Haikunator haikunator = Haikunator() # Azure Datacenter LOCATION = 'westus' # Resource Group GROUP_NAME = 'azure-sample-group-loadbalancer' # Network VNET_NAME = 'azure-sample-vnet' SUBNET_NAME = 'azure-sample-subnet' DOMAIN_LABEL_NAME = 'testdns'+haikunator.haikunate() PUBLIC_IP_NAME = 'azure-sample-publicip' # Load balancer LB_NAME = 'azure-sample-loadbalancer' FIP_NAME = 'azure-sample-frontendipname' ADDRESS_POOL_NAME = 'azure-sample-addr-pool' PROBE_NAME = 'azure-sample-probe' LB_RULE_NAME = 'azure-sample-lb-rule' NETRULE_NAME_1 = 'azure-sample-netrule1' NETRULE_NAME_2 = 'azure-sample-netrule2'
