def makeService(options):
"""
Make a new subscription manager ``IService``.
"""
# Boo global reactor
# https://twistedmatrix.com/trac/ticket/9063
from twisted.internet import reactor
parent = MultiService()
eliot_logging_service(
reactor,
options.get("destinations", []),
).setServiceParent(parent)
make_dirs(options["state-path"].path)
site = Site(make_resource(
options["state-path"],
options["domain"].decode("ascii"),
options["bucket-name"].decode("ascii"),
))
StreamServerEndpointService(
serverFromString(reactor, options["listen-address"]),
site,
).setServiceParent(parent)
return parent
def setUp(self):
super(TestSignupModule, self).setUp()
self.mockconfigdir = FilePath('./test_signup').child('TestSignupModule')
make_dirs(self.mockconfigdir.path)
self.SIGNUPSPATH = 'mock_signups.csv'
self.CONFIGFILEPATH = 'init_test_config.json'
self.EC2SECRETPATH = 'mock_ec2_secret'
self.S3SECRETPATH = 'mock_s3_secret'
self.MONITORPUBKEYPATH = 'MONITORKEYS.pub'
self.MEMAIL = 'MEMAIL'
self.MKEYINFO = 'MKEYINFO'
self.MCUSTOMER_ID = u'cus_x14Charactersx'
self.MSUBSCRIPTION_ID = u'sub_x14Characterx'
self.MPLAN_ID = 'XX_consumer_iteration_#_GREEKLETTER#_2XXX-XX-XX'
self.MENCODED_IDS = 'on2wex3yge2eg2dbojqwg5dfoj4a-mn2xgx3yge2eg2dbojqwg5dfojzxq'
FilePath(self.SIGNUPSPATH).setContent('')
FilePath(self.CONFIGFILEPATH).setContent(CONFIGFILEJSON)
FilePath(self.EC2SECRETPATH).setContent(MOCKEC2SECRETCONTENTS)
FilePath(self.S3SECRETPATH).setContent(MOCKS3SECRETCONTENTS)
FilePath(self.MONITORPUBKEYPATH).setContent(MONITORPUBKEY)
self.DEPLOYMENT_CONFIGURATION = model.DeploymentConfiguration(
domain=u"s4.example.com",
kubernetes_namespace=u"testing",
subscription_manager_endpoint=URL.fromText(u"http://localhost/"),
s3_access_key_id=ZEROPRODUCT["s3_access_key_id"],
s3_secret_key=MOCKS3SECRETCONTENTS,
introducer_image=u"tahoe-introducer",
storageserver_image=u"tahoe-storageserver",
)
self.SUBSCRIPTION = model.SubscriptionDetails(
bucketname="lae-" + self.MENCODED_IDS,
oldsecrets=old_secrets().example(),
customer_email=self.MEMAIL,
customer_pgpinfo=self.MKEYINFO,
product_id=u"filler",
customer_id=self.MCUSTOMER_ID,
subscription_id=self.MSUBSCRIPTION_ID,
introducer_port_number=12345,
storage_port_number=12346,
)
d.addCallback(lambda ign: activate_subscribed_service(customer_email, customer_pgpinfo,
customer_id, subscription_id,
plan_id,
signup_stdout, signup_stderr,
SSEC2_secretsfile, signup_log_fp.path)
)
d.addErrback(errhandler)
d.addBoth(lambda ign: signup_logfile.close())
if __name__ == '__main__':
defer.setDebugging(True)
stdin = sys.stdin
logDir = FilePath('../secrets/flappserver_logs')
if not logDir.isdir():
make_dirs(logDir.path)
flapp_stdout = logDir.child('stdout')
flapp_stderr = logDir.child('stderr')
d = defer.succeed(None)
d.addCallback(lambda ign: main(stdin, flapp_stdout, flapp_stderr))
def _print_except(f):
fh = flapp_stderr.open('a+')
f.print_stack(file=fh)
fh.close()
d.addErrback(_print_except)
d.addCallbacks(lambda ign: sys.exit(0), lambda ign: sys.exit(8))
try:
reactor.run()
except Exception:
def setUp(self):
self.mockconfigdir = FilePath('./test_signup').child('TestSignupModule')
make_dirs(self.mockconfigdir.path)
self.SIGNUPSPATH = 'mock_signups.csv'
self.CONFIGFILEPATH = 'init_test_config.json'
self.SERVERINFOPATH = 'mock_serverinfo.csv'
self.EC2SECRETPATH = 'mock_ec2_secret'
self.S3SECRETPATH = 'mock_s3_secret'
self.MONITORPUBKEYPATH = 'MONITORKEYS.pub'
self.MEMAIL = 'MEMAIL'
self.MKEYINFO = 'MKEYINFO'
self.MCUSTOMER_ID = 'cus_x14Charactersx'
self.MSUBSCRIPTION_ID = 'sub_x14Characterx'
self.MPLAN_ID = 'XX_consumer_iteration_#_GREEKLETTER#_2XXX-XX-XX'
self.MSECRETSFILE = 'MSECRETSFILE'
self.MENCODED_IDS = 'on2wex3yge2eg2dbojqwg5dfoj4a-mn2xgx3yge2eg2dbojqwg5dfojzxq'
FilePath(self.SIGNUPSPATH).setContent('')
FilePath(self.CONFIGFILEPATH).setContent(CONFIGFILEJSON)
FilePath(self.SERVERINFOPATH).setContent('')
FilePath(self.EC2SECRETPATH).setContent(MOCKEC2SECRETCONTENTS)
FilePath(self.S3SECRETPATH).setContent(MOCKS3SECRETCONTENTS)
FilePath(self.MONITORPUBKEYPATH).setContent(MONITORPUBKEY)
self.patch(signup, 'POLL_TIME', 0.1)
self.patch(signup, 'CC_VERIFICATION_TIME', 0.3)
self.patch(signup, 'ADDRESS_DELAY_TIME', 0.1)
self.patch(signup, 'ADDRESS_WAIT_TIME', 0.3)
self.patch(signup, 'LISTEN_POLL_TIME', 0.1)
self.patch(initialize, 'SET_TAGS_DELAY_TIME', 0.1)
from lae_automation.aws.queryapi import time
def call_time():
return 0
self.patch(time, 'time', call_time)
from lae_automation.aws import queryapi
def call_make_http_request(request_url):
self.failUnlessEqual(request_url, self.fakeURLs.pop(0))
return defer.succeed(self.mhr_return_values.pop(0))
self.patch(queryapi, 'make_http_request', call_make_http_request)
from lae_automation.aws.queryapi import EC2ConsoleClient
def call_EC2ConsoleClient_describe_console_output(EC2Instance, instance_id):
return defer.succeed(
EC2Instance.parser.describe_console_output(getconsoleoutputresponse) )
self.patch(EC2ConsoleClient, 'describe_console_output',
call_EC2ConsoleClient_describe_console_output)
# Because the S3 Client call to S3 is made through txaws, it circumvents make_http_request,
# and necessitates a separate patch to isolate the system from remote components.
# The patched function is the submit method of the query object in initialize.
# This attribute belongs to the Query class object imported by devpay_s3client.
from lae_automation.aws.devpay_s3client import Query as S3_Query
def call_s3_query_submit(QueryObject):
header_dict = QueryObject.get_headers()
self.failUnlessEqual(header_dict['Date'], 'Thu, 01 Jan 1970 00:00:00 GMT')
self.failUnlessEqual(header_dict['Content-Length'], 0)
self.failUnlessEqual(header_dict['Authorization'],
'AWS TESTS3S3S3S3S3S3S3S3:6k3/9M2RYfjOEcBm6o5p8f9oDMs=')
self.failUnlessEqual(header_dict['Content-MD5'], '1B2M2Y8AsgTpgAmY7PhCfg==')
return defer.succeed('Completed devpay bucket creation submission.')
self.patch(S3_Query, 'submit', call_s3_query_submit)
from lae_automation.initialize import EC2Client
def call_run_instances(EC2ClientObject, ami_image_id, mininstancecount, maxinstancecount,
secgroups, keypair_name, instance_type):
self.failUnlessEqual(ami_image_id, 'ami-deadbeef')
self.failUnlessEqual(mininstancecount, 1)
self.failUnlessEqual(maxinstancecount, 1)
self.failUnlessEqual(secgroups, ['CustomerDefault'])
self.failUnlessEqual(keypair_name, 'ADMINKEYS')
class MockEC2Instance:
def __init__(self):
self.launch_time = "blah"
self.instance_id = 'i-MOCKEC2INSTANCEID'
return defer.succeed([MockEC2Instance()])
self.patch(EC2Client, 'run_instances', call_run_instances)
def call_describe_instances(EC2ClientObject, *instance_ids):
self.failUnlessEqual(instance_ids, ('i-MOCKEC2INSTANCEID',))
return defer.succeed( [('0.0.0.0', '0.0.0.1')] )
self.patch(EC2Client, 'describe_instances', call_describe_instances)
def call_get_and_store_pubkeyfp_from_keyscan(targetIP, stdout):
return (MOCKSERVERSSHFP, MOCKHASHEDPUBKEY)
self.patch(initialize, 'get_and_store_pubkeyfp_from_keyscan',
call_get_and_store_pubkeyfp_from_keyscan)
from lae_automation.server import NotListeningError
self.first = True
def call_install_server(publichost, admin_privkey_path, monitor_pubkey, monitor_privkey_path,
stdout, stderr):
self.failUnlessEqual(publichost, '0.0.0.0')
self.failUnlessEqual(admin_privkey_path, 'ADMINKEYS.pem')
if self.first:
self.first = False
raise NotListeningError()
self.patch(signup, 'install_server', call_install_server)
def call_bounce_server(publichost, admin_privkey_path, privatehost, s3_access_key_id,
s3_secretkey, user_token, product_token, bucket_name, oldsecrets,
stdout, stderr, secretsfile):
self.failUnlessEqual(publichost, '0.0.0.0')
self.failUnlessEqual(admin_privkey_path, 'ADMINKEYS.pem')
self.failUnlessEqual(privatehost, '0.0.0.1')
self.failUnlessEqual(s3_access_key_id, 'TEST'+'S3'*8)
self.failUnlessEqual(s3_secretkey, 'S3'*20)
self.failUnlessEqual(bucket_name, "lae-" + self.MENCODED_IDS)
self.failUnlessEqual(oldsecrets, None)
self.failUnless(secretsfile.name.endswith('secrets/XX_consumer_iteration_#_GREEKLETTER#_2XXX-XX-XX/1970-01-01T000000Z-%s/SSEC2' % (self.MENCODED_IDS,)), secretsfile.name)
self.patch(signup, 'bounce_server', call_bounce_server)
def call_send_signup_confirmation(publichost, customer_email, furl, customer_keyinfo, stdout,
stderr):
self.failUnlessEqual(publichost, '0.0.0.0')
self.failUnlessEqual(customer_email, 'MEMAIL')
self.failUnlessEqual(furl, None)
self.failUnlessEqual(customer_keyinfo, 'MKEYINFO')
return defer.succeed("Tested send confirmation email call!")
self.patch(signup, 'send_signup_confirmation', call_send_signup_confirmation)
def call_send_notify_failure(f, customer_email, logfilename, stdout, stderr):
self.failUnless(isinstance(f, Failure), f)
self.failUnlessEqual(customer_email, 'MEMAIL')
self.failUnless(logfilename.endswith('secrets/XX_consumer_iteration_#_GREEKLETTER#_2XXX-XX-XX/1970-01-01T000000Z-%s/signup_logs' % (self.MENCODED_IDS,)), logfilename)
return f
self.patch(signup, 'send_notify_failure', call_send_notify_failure)
from txaws.ec2.client import Query as EC2_Query
def call_ec2_query_submit(QueryObject):
return defer.succeed(createtagsresponse)
self.patch(EC2_Query, 'submit', call_ec2_query_submit)
