def main(): c = client.create_client() for line in fileinput.input(): try: delete_file(c, line.strip()) except Exception, e: print >> sys.stderr, e
def GetInstances(self, request: GetInstancesRequest,
context: ServicerContext,
claims: TokenClaims) -> GetInstancesResponse:
session = DBSession()
user = get_user_from_claims(session, claims)
instances = user.instances
session.close()
# find the instances
client = create_client()
resp = GetInstancesResponse()
for db_server in instances:
server = client.connection.get_server_by_id(db_server.id)
flavor = client.connection.get_flavor_by_id(server.flavor["id"])
i = Instance()
i.id = server.id
i.name = server.name
i.imageName = db_server.image_name
i.flavor.name = flavor.name
i.flavor.cpu = flavor.vcpus
i.flavor.memory = flavor.ram
i.flavor.rootDisk = flavor.disk
i.status = server.status
i.vmState = server.vm_state
i.powerState = str(server.power_state)
if server.task_state is not None:
i.taskState = server.task_state
i.ip = server.public_v4
i.createTime = server.created_at
resp.instances.append(i)
return resp
def test_is_instanciented_correctly(self):
""":: it should create a instance of Client if input is valid"""
client = create_client(self.VALID_NAME, self.VALID_NUMBER)
self.assertIsInstance(client, Client)
self.assertEqual(client.name, self.VALID_NAME)
self.assertEqual(client.purchase_amount, self.VALID_NUMBER)
def main(): c = client.create_client() for line in fileinput.input(): try: restore_file(c, line.strip()) except Exception: # retry one time restore_file(c, line.strip())
def main():
c = client.create_client()
for line in fileinput.input():
try:
restore_file(c, line.strip())
except Exception:
# retry one time
restore_file(c, line.strip())
def main():
parser = OptionParser()
parser.add_option('-d', '--dirs', action='store_true', dest='dirs_only', default=False)
parser.add_option('--date', dest='date', default=None)
(options, args) = parser.parse_args()
search_root = args[0]
c = client.create_client()
filter_func = lambda files: filter_by_date(files, options.dirs_only, options.date)
files = client.find_files(c, search_root, False, filter_func)
def register():
args = request.get_json()
email = args.get('email')
password = args.get('password')
name = args.get('name', '')
client = create_client(email=email, password=password, name=name)
return jsonify(create_token(client))
def DeleteProject(self, request, context):
client = create_client()
session = DBSession()
for user in session.query(ProjectUser).filter_by(
project_id=request.projectId):
delete_db_user(user, client)
session.delete(user)
session.commit()
return DeleteProjectResponse()
def main():
search_root = sys.argv[1]
if len(sys.argv) > 2:
date = sys.argv[2]
# print 'Filtering by date:', date
else:
date = None
c = client.create_client()
filter_func = lambda files: filter_deleted_by_date(files, date)
deleted_files = client.find_files(c, search_root, True, filter_func)
def DeleteUser(self, request: DeleteUserRequest,
context) -> DeleteUserResponse:
client = create_client()
session = DBSession()
for user in session.query(ProjectUser).filter_by(
user_id=request.userId):
delete_db_user(user, client)
session.delete(user)
session.commit()
return DeleteUserResponse()
def main(): search_root = sys.argv[1] if len(sys.argv) > 2: date = sys.argv[2] # print 'Filtering by date:', date else: date = None c = client.create_client() filter_func = lambda files: filter_deleted_by_date(files, date) deleted_files = client.find_files(c, search_root, True, filter_func)
def GetImages(self, request: GetImagesRequest,
context) -> GetImagesResponse:
client = create_client()
images = client.connection.list_images()
resp = GetImagesResponse()
for image in images:
i = Image()
i.id = image.id
i.name = image.name
i.minDisk = image.min_disk
resp.images.append(i)
return resp
def RemoveUserFromProject(self, request: RemoveUserFromProjectRequest,
context) -> RemoveUserFromProjectResponse:
client = create_client()
session = DBSession()
user = get_user(session, request.userId, request.projectId)
# delete instances and volumes from server
delete_db_user(user, client)
# delete user from db
# db instances and volumes will be cascade deleted.
session.delete(user)
session.commit()
return RemoveUserFromProjectResponse()
def start():
print("Hello, welcome to the network.")
print("1. Create new server")
print("2. Connect as a client")
print("3. exit.")
choice = input(">")
if choice.isdigit():
choice = int(choice)
if choice == 1:
server_main()
elif choice == 2:
print("To what ip would you like to connect?")
ip = input(">")
create_client(ip)
elif choice == 3:
exit()
else:
print("Choose one of the presented options please.")
start()
else:
print("Incorrect input, please try again")
start()
def main():
parser = OptionParser()
parser.add_option('-d',
'--dirs',
action='store_true',
dest='dirs_only',
default=False)
parser.add_option('--date', dest='date', default=None)
(options, args) = parser.parse_args()
search_root = args[0]
c = client.create_client()
filter_func = lambda files: filter_by_date(files, options.dirs_only,
options.date)
files = client.find_files(c, search_root, False, filter_func)
def GetFlavors(self, request: GetFlavorsRequest,
context) -> GetFlavorsResponse:
client = create_client()
flavors = client.connection.list_flavors()
resp = GetFlavorsResponse()
for flavor in flavors:
f = Flavor()
f.name = flavor.name
f.cpu = flavor.vcpus
f.memory = flavor.ram
f.rootDisk = flavor.disk
resp.flavors.append(f)
return resp
def test_ten_results_returned(delete_previous_db_record):
"""
I'm assuming the fictional gateway schema only
returns ten results and has an API endpoint called getResults
which accepts a search string
"""
request = create_client().gateway.getResults(
search="some string").response()
# Assert sucessful request
assert_that(request.result.status, equal_to('200'))
"""
I'm assuming the json object uses a list to contain
the results
"""
assert_that(len(request.result.results, equal_to(10)))
def CreateInstance(self, request: CreateInstanceRequest, context,
claims: TokenClaims) -> CreateInstanceResponse:
session = DBSession()
user = get_user_from_claims(session, claims)
client = create_client()
client.connection.list_flavors()
# Creating the instance directly will not return the volume it also creates,
# so the volume must be manually created
volume = client.connection.create_volume(size=request.volume,
image=request.imageName,
bootable=True)
os_instance = client.connection.create_server(
request.name,
image=request.imageName,
flavor=request.flavorName,
boot_volume=volume.id,
)
# manually get the flavor
flavor = client.connection.get_flavor_by_id(os_instance.flavor["id"])
resp = CreateInstanceResponse()
resp.flavor.name = flavor.name
resp.flavor.cpu = flavor.vcpus
resp.flavor.memory = flavor.ram
resp.flavor.rootDisk = flavor.disk
resp.instanceId = os_instance.id
db_volume = models.Volume(id=volume.id,
size=request.volume,
owner_id=user.id,
instance_id=os_instance.id)
db_instance = models.Instance(id=os_instance.id,
image_name=request.imageName,
owner_id=user.id)
session.add(db_instance)
session.add(db_volume)
session.commit()
return resp
def handle_app_home_event(team_id, user_id):
from main import mongo
existing_team = mongo.db.teams.find_one({"team_id": team_id})
if not existing_team:
bot_token = existing_team.get("bot_token")
user_token = existing_team.get("user_token")
bot_client, _ = create_client(bot_token, user_token)
formatted_msg = f"""Hello <@{user_id}>,
I am folly. I'm a simple bot whose main aim is to grab members of this workspace who react to any message shared in the workspace.
To make use of `folly`, mention @folly followed by the reaction you want to grab reactors for and the bot sends you a DM.
> @folly :100:
"""
send_message(formatted_msg, user_id, bot_client)
return existing_team
def GetVolumes(self, request, context, claims: TokenClaims):
client = create_client()
session = DBSession()
user = get_user_from_claims(session, claims)
db_volumes = user.volumes
session.close()
resp = GetVolumesResponse()
for db_volume in db_volumes:
volume = client.connection.get_volume_by_id(db_volume.id)
v = Volume()
v.size = volume.size
v.id = volume.id
v.createTime = volume.created_at
attachment = volume.attachments[0]
v.attachedToInstanceId = attachment.server_id
v.attachedToInstanceName = client.connection.get_server_by_id(
attachment.server_id).name
v.attachedToDevice = attachment.device
resp.volumes.append(v)
return resp
def DeleteInstance(self, request, context):
client = create_client()
# Get the server
server = client.connection.get_server_by_id(id=request.instanceId)
# Get the volume
# volume = server.volumes[0]
# Get the flavor
flavor = client.connection.get_flavor_by_id(server.flavor["id"])
resp = DeleteInstanceResponse()
resp.flavor.name = flavor.name
resp.flavor.cpu = flavor.vcpus
resp.flavor.memory = flavor.ram
resp.flavor.rootDisk = flavor.disk
# Delete the server
client.connection.delete_server(name_or_id=request.instanceId,
wait=True,
delete_ips=True)
# Get the server from db
session = DBSession()
instance = session.query(
models.Instance).filter_by(id=request.instanceId).one()
# Delete the volume.
volume = instance.volumes[0]
resp.volume = volume.size
client.connection.delete_volume(name_or_id=volume.id, force=True)
# Delete the instance from db
session.delete(instance)
session.commit()
return resp
def test_invalid_input(self):
""" :: it should raises if data is invalid """
with self.assertRaises(ValueError):
create_client(self._INVALID_NAME_, self._INVALID_NUMBER_)
def RebootInstance(self, request, context):
client = create_client()
compute = client.connection.compute
compute.reboot_server(request.instanceId,
reboot_type="HARD" if request.hard else "SOFT")
return RebootInstanceResponse()
def StopInstance(self, request, context):
client = create_client()
compute = client.connection.compute
compute.stop_server(request.instanceId)
return StopInstanceResponse()
finally:
db.close()
return False
if __name__ == '__main__':
from user import add_user, get_user, delete_user
from client import create_client, get_client, delete_client, client_exists
from models import AccessToken, RefreshToken
add_user('jim', 'password')
user = get_user('jim')
if not client_exists('bobby fiet3'):
client = create_client('bob',
'bobby fiet3',
'iamcool',
'http://whaever.com')
else:
client = get_client('bobby fiet3')
access_token = AccessToken(client, user)
refresh_token = RefreshToken(access_token, client, user)
db = DB()
try:
db.put(access_token.code, access_token)
db.put(refresh_token.code, refresh_token)
db.commit()
finally:
db.close()
try:
associate_client_with_user(user, client, refresh_token.code)
except:
def bot():
try:
request_type = request.data.get("type")
if request_type == "url_verification":
challenge = request.data.get("challenge")
return challenge
event = request.data.get("event")
event_type = event.get("type")
team_id = request.data.get("team_id")
if event_type == "app_home_opened":
user_id = event.get("user")
if user_id and team_id:
args = (team_id, user_id)
x = Thread(target=handle_app_home_event, args=args)
x.start()
return "", 200
if event_type != "app_mention":
return "", 200
current_user = event.get("user")
edited = event.get("edited")
thread_ts = event.get("thread_ts")
channel = event.get("channel")
reaction_text = event.get("text").strip()
if edited:
return "", 200
team_query = {"team_id": team_id}
team_details = mongo.db.teams.find_one(team_query)
bot_token = team_details.get("bot_token")
user_token = team_details.get("user_token")
bot_client, user_client = create_client(bot_token, user_token)
if not thread_ts:
msg = "Folly can't be used outside a thread. \n"
msg += help_message
send_ephemeral_message(msg, thread_ts, channel, current_user,
bot_client)
return "", 200
if re.search(HELP_REGEX, reaction_text):
send_ephemeral_message(help_message, thread_ts, channel,
current_user, bot_client)
return "", 200
reactions = re.findall(REACTION_REGEX, reaction_text)
if not reactions:
msg = "No reaction in text.\n"
msg += help_message
send_ephemeral_message(msg, thread_ts, channel, current_user,
bot_client)
return "", 200
reaction_list = get_reactions(channel, thread_ts, user_client)
reaction_details = get_reaction_details(reaction_list, reactions[0])
if not reaction_details:
msg = "Reaction doesn't exist on post! Kindly supply a reaction that is used on the initial message."
send_ephemeral_message(msg, thread_ts, channel, current_user,
bot_client)
return "", 200
permalink_response = get_message_permalink(thread_ts, channel,
user_client)
permalink = permalink_response.get("permalink")
response = generate_user_response(reaction_details, current_user,
permalink, bot_client)
return "", 200
except Exception as e:
app.logger.exception(e)
return "", 400
import sys, json import client if __name__ == "__main__": json_data = open(sys.argv[1]) options = json.load(json_data) client.create_client(options) json_data.close()
import os
import sys
import time
from client import create_client
from notifier import notify
PROJECT_ID = os.environ.get('PROJECT_ID')
INSTANCES = os.environ.get('INSTANCES')
if PROJECT_ID is None or INSTANCES is None:
print(
'Please provide a PROJECT_ID and a comma-separated list of INSTANCES')
sys.exit(1)
notify('run')
client = create_client()
for instance in INSTANCES.split(','):
client.post('/cloud/project/%s/instance/%s/snapshot' %
(PROJECT_ID, instance),
snapshotName=instance + '-' + time.strftime('%Y%m%d-%H%M%S'))
print('Scheduled snapshot of instance %s' % instance)
notify('complete')
print('Finished scheduling the snapshots creation')
