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 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_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 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'