コード例 #1
0
def scp(from_path, to_path, is_local=True, is_receive=False, use_env_host=True):
    if is_receive:
        target = CONF._remote_tmp_dir + from_path
        target_dir = target.rsplit('/', 1)[0]
        run('mkdir -p {0}'.format(target_dir))
        cmd = 'scp -P {0} -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null" {1}@{2}:{3} {4}'.format(
            api.env.port, api.env.user, api.env.host, target, to_path)

        if CONF.user and CONF.password:
            result = expect(
                cmd,
                [['* password:'******'{0}\\n'.format(CONF.password)]],
                is_local=is_local)

        else:
            result = local(cmd)

        return result

    else:
        cmd = 'scp -P {0} -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null" {1} {2}@'.format(
            api.env.port, from_path, api.env.user)
        if use_env_host:
            cmd += '{0}:'.format(api.env.host)

        if is_local:
            tmp_target = CONF._remote_tmp_dir + to_path
            tmp_target_dir = tmp_target.rsplit('/', 1)[0]

            run('mkdir -p {0}'.format(tmp_target_dir))
            cmd += tmp_target

            if CONF.user and CONF.password:
                result = expect(
                    cmd,
                    [['* password:'******'{0}\\n'.format(CONF.password)]],
                    is_local=is_local)

            else:
                result = local(cmd)

            sudo('cp {0} {1}'.format(tmp_target, to_path))
            return result

        else:
            cmd += to_path
            return run(cmd)
コード例 #2
0
ファイル: transfer.py プロジェクト: fabrickit/fabkit
def scp(from_path,
        to_path,
        is_local=True,
        is_receive=False,
        use_env_host=True):
    if is_receive:
        cmd = 'scp -P {0} -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null" {1}@{2}:{3} {4}'.format(
            api.env.port, api.env.user, api.env.host, from_path, to_path)

        if CONF.user and CONF.password:
            result = expect(cmd,
                            [['* password:'******'{0}\\n'.format(CONF.password)]],
                            is_local=is_local)

        else:
            result = local(cmd)

        return result

    else:
        cmd = 'scp -P {0} -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null" {1} {2}@'.format(
            api.env.port, from_path, api.env.user)
        if use_env_host:
            cmd += '{0}:'.format(api.env.host)

        if is_local:
            tmp_target = CONF._remote_tmp_dir + to_path
            tmp_target_dir = tmp_target.rsplit('/', 1)[0]

            run('mkdir -p {0}'.format(tmp_target_dir))
            cmd += tmp_target
            result = api.put(from_path, tmp_target)

            sudo('cp {0} {1}'.format(tmp_target, to_path))
            return result

        else:
            cmd += to_path
            return run(cmd)
コード例 #3
0
ファイル: zetsu.py プロジェクト: kaushik-rishi/Zetsu
import base
tab=base.IdentifierTable()
import sys
argumentList = sys.argv 
if len(argumentList)>1:
    fext= argumentList[1].split('.')
    if len(fext)>1 and fext[1]=='zs':
        f = open(argumentList[1], "r")
        res,err=base.run(f.read(),tab)
        if err: print(err.asString())
    else:
        print('File format Not supported')
else:
    while True:
        code=input("ZETSU >>>")
        res,err=base.run(code,tab)
        if err: print(err.asString())
コード例 #4
0
import os
import base
import importlib

if __name__ == "__main__":
    my_dir_name = os.path.dirname(os.path.realpath(__file__))
    base.config.load_from_yaml(my_dir_name + f'/config.singleservice.yaml')

    importlib.import_module('users.api.users')
    importlib.import_module('lookup.user_permissions')
    importlib.import_module('contacts.api.contacts')

    base.run(debug=True)
コード例 #5
0
        """
        import os
        import string
        for root, dirs, files in os.walk(
                os.path.realpath(__file__ + '/../../../')):
            upperfiles = [
                os.path.join(root, f) for f in files
                if f.lower() != f and f.endswith('.py')
            ]
            self.assertTrue(
                len(upperfiles) == 0,
                "Python files with upper-case letters detected" +
                str(upperfiles))
            dashfiles = [
                os.path.join(root, f) for f in files
                if '-' in f and f.endswith('.py')
            ]
            self.assertTrue(
                len(dashfiles) == 0,
                "Python files with dashes detected" + str(dashfiles))


def suite():
    suite = unittest.TestSuite()
    suite.addTest(TestPyFilenames())
    return suite


if __name__ == "__main__":
    base.run(suite())
コード例 #6
0
import base


class FifoScheduler(base.Scheduler):
    def interrupt(self, time, process):
        if process is not None:
            self.ready_processes.append(process)

        if self.currently_running is not None:
            if time == self.currently_running.end_time:
                self._add_to_history(self.currently_running,
                                     self.currently_running.start_time,
                                     self.currently_running.end_time)
                self.currently_running = None

        if self.currently_running is None:
            if len(self.ready_processes):
                self.currently_running = self.ready_processes[0]
                self.currently_running.start_time = time
                self.currently_running.end_time = (
                    time + self.currently_running.burst_time)
                del self.ready_processes[0]

        if self.currently_running is None:
            return None
        else:
            return self.currently_running.end_time

base.run(FifoScheduler)
コード例 #7
0
ファイル: one_centos_dev.py プロジェクト: shit0u/AmbariKave
        ambari, iid = self.deploy_dev()
        stdout = ambari.run("echo Hello world from $HOSTNAME")
        self.assertTrue("ambari" in stdout.lower() or "test-" in stdout.lower(),
                        "Unable to contact " + ' '.join(ambari.sshcmd()) + "\n" + stdout)
        self.pull(ambari)
        self.wait_for_ambari(ambari)
        # test other features of ambari.run
        stdout = ambari.run("ls -l '/opt'")
        stdout = ambari.run('ls -l "/opt"')
        self.assertTrue("lost+found" in stdout, "No /opt directory :$ see " + ' '.join(ambari.sshcmd()))
        ma = lD.multiremotes(["ssh:root@" + ambari.host], access_key=ambari.access_key)
        stdout = ma.run("ls -l '/opt'")
        self.assertTrue("lost+found" in stdout, "No /opt directory :$ see " + ' '.join(ambari.sshcmd()))
        stdout = lD.run_quiet(deploy_dir + "/aws/add_ebsvol_to_instance.py --not-strict " + iid +
                              ' \'{"Mount": "/tmp/testdir1", "Size": 1, "Attach": "/dev/sdg"}\'')


def suite(verbose=False):
    suite = unittest.TestSuite()
    test = DepCentos()
    test.debug = verbose
    suite.addTest(test)
    return suite


if __name__ == "__main__":
    verbose = False
    if "--verbose" in sys.argv:
        verbose = True
    base.run(suite(verbose))
コード例 #8
0
ファイル: clusters.py プロジェクト: Kobus-Smit/AmbariKave
    if "--verbose" in sys.argv:
        verbose = True
        sys.argv = [s for s in sys.argv if s != "--verbose"]
    branch = "__local__"
    if "--branch" in sys.argv:
        branch = "__service__"
        sys.argv = [s for s in sys.argv if s != "--branch"]
    if "--this-branch" in sys.argv:
        branch = "__local__"
        sys.argv = [s for s in sys.argv if s != "--this-branch"]
    if "--prod" in sys.argv:
        clustername = 'prod'
        sys.argv = [s for s in sys.argv if s != "--prod"]
    if len(sys.argv) < 2:
        raise KeyError("You must specify which blueprint/cluster to test")
    service = sys.argv[1]
    test = TestCluster()
    if service == "FREEIPA":
        test = TestFreeIPACluster()
    test.service = service
    test.debug = verbose
    test.clustername = clustername
    test.branch = branch
    test.branchtype = branch
    test.checklist = []
    if len(sys.argv) > 2:
        test.checklist = sys.argv[2:]
    suite = unittest.TestSuite()
    suite.addTest(test)
    base.run(suite)
コード例 #9
0
ファイル: bukkit.py プロジェクト: BukGet/generator
def run():
    '''Parser Runtime Function
    Here is where we will be actually running all fo the code below.  This is 
    considered to be boilerplate and should be in every parser.
    '''
    base.run(Parser())
コード例 #10
0
ファイル: patagonia.py プロジェクト: wwchen/tidbits
                    title = strip_non_ascii(product.xpath('.//*/h4/text()')[0])
                    price = product.xpath('.//*/span[@class="value"]/@content')
                    price = price[-1] if price else "N/A"
                    opt_text = product.xpath('.//div[@data-color]/@data-color')
                    opt_links = product.xpath('.//div[@data-color]/a/@href')
                    href_prefix = 'https://www.patagonia.com'
                    links = [{
                        'href': href_prefix + href,
                        'text': text
                    } for href, text in zip(opt_links, opt_text)]
                    data.append({
                        "title": title,
                        "links": links,
                        "price": price
                    })
                logging.debug("fetched {} for {}".format(len(title), url))
            except IndexError as e:
                logging.error(e)
                write_html('patagonia-error.html', page)
                post_to_slack('error encountered for patagonia', cfg.slack)
                sys.exit(1)
            if not product_elements:
                break
    return data


if __name__ == "__main__":
    while True:
        run(CRAWLER, scrape_patagonia)
        time.sleep(CHECK_INTERVAL_SECS)
コード例 #11
0
from lxml import html
import time


CRAWLER = 'icebreaker-mens'
CHECK_INTERVAL_SECS = 1200


def scrape_icebreaker(cfg):
    data = []
    page = requests.get(cfg.url)
    tree = html.fromstring(page.content)
    product_elements = tree.xpath('//*/div[contains(@class, "product-tile")]')
    try:
        for product in product_elements:
            title = strip_non_ascii(product.xpath('.//div[@class="name"]/a/text()')[0])
            link = product.xpath('.//div[@class="name"]/a/@href')[0]
            price = product.xpath('.//div[@class="product-price"]//span/text()')
            price = price[-1].strip() if price else "N/A"
            data.append({"title": title, "link": link, "price": price})
    except IndexError as e:
        logging.error(e)
        write_html('icebreaker-error.html', page)
    return data


if __name__ == "__main__":
    while True:
        run(CRAWLER, scrape_icebreaker)
        time.sleep(CHECK_INTERVAL_SECS)
コード例 #12
0

class SjfScheduler(base.Scheduler):
    def interrupt(self, time, process):
        if process is not None:
            self.ready_processes.append(process)
            self.ready_processes.sort(key=lambda x: x.burst_time)

        if self.currently_running is not None:
            if time == self.currently_running.end_time:
                self._add_to_history(self.currently_running,
                                     self.currently_running.start_time,
                                     self.currently_running.end_time)
                self.currently_running = None

        if self.currently_running is None:
            if len(self.ready_processes):
                self.currently_running = self.ready_processes[0]
                self.currently_running.start_time = time
                self.currently_running.end_time = (
                    time + self.currently_running.burst_time)
                del self.ready_processes[0]

        if self.currently_running is None:
            return None
        else:
            return self.currently_running.end_time


base.run(SjfScheduler)
コード例 #13
0
import base


class PriorityNonPreemptiveScheduler(base.Scheduler):
    def interrupt(self, time, process):
        if process is not None:
            self.ready_processes.append(process)
            self.ready_processes.sort(key=lambda x: x.priority)

        if self.currently_running is not None:
            if time == self.currently_running.end_time:
                self._add_to_history(self.currently_running,
                                     self.currently_running.start_time,
                                     self.currently_running.end_time)
                self.currently_running = None

        if self.currently_running is None:
            if len(self.ready_processes):
                self.currently_running = self.ready_processes[0]
                self.currently_running.start_time = time
                self.currently_running.end_time = (
                    time + self.currently_running.burst_time)
                del self.ready_processes[0]

        if self.currently_running is None:
            return None
        else:
            return self.currently_running.end_time

base.run(PriorityNonPreemptiveScheduler)
コード例 #14
0
    def interrupt(self, time, process):
        TIME_SLICE = 1
        if process is not None:
            process.remaining_time = process.burst_time
            self.ready_processes.append(process)

        if self.currently_running is not None:
            self.currently_running.remaining_time -= (
                time - self.currently_running.start_time)
            self._add_to_history(self.currently_running,
                                 self.currently_running.start_time, time)
            if self.currently_running.remaining_time == 0:
                self.ready_processes.remove(self.currently_running)
                self.last_run -= 1

        self.currently_running = None
        if len(self.ready_processes):
            self.last_run = (self.last_run + 1) % len(self.ready_processes)
            self.currently_running = self.ready_processes[self.last_run]
            self.currently_running.start_time = time
            self.currently_running.end_time = (time + TIME_SLICE)

        if self.currently_running is None:
            return None
        else:
            return self.currently_running.end_time


base.run(RoundRobinScheduler)
コード例 #15
0
ファイル: multipart.py プロジェクト: dahefanteng/yig

def delete_multipart_uploaded_objects(name, client):
    ans = client.delete_objects(
        Bucket=name+'hehe',
        Delete={
            'Objects': [
                {
                    'Key': name+'s3'
                },
                {
                    'Key': name+'custom'
                }
            ]
        }
    )
    print 'Delete multiple objects:', ans

# =====================================================

TESTS = [
    sanity.create_bucket,
    sse_s3_multipart,
    sse_custom_multipart,
    delete_multipart_uploaded_objects,
    sanity.delete_bucket,
]

if __name__ == '__main__':
    base.run(TESTS)
コード例 #16
0
ファイル: verifyxml.py プロジェクト: KaveIO/AmbariKave
                                    for start in range(len(defaultvs)):
                                        if len(this_default) < start:
                                            start = 0
                                            break
                                        if defaultvs[start] != this_default[start]:
                                            start = max(start - 10, 0)
                                            break
                                    failingpyfiles[f + '/' + configname + '/' + defaultp
                                                   ] = ('( ... '
                                                        + this_default[start:start + 80]
                                                        + '... )'
                                                        )

        self.assertEqual(len(failingpyfiles), 0,
                         "Found " + str(len(failingpyfiles))
                         + " python params file missing defaults {file/service/property: missing_str_approx }"
                         + " \n" + str(failingpyfiles).replace("',", "',\n")
                         )


def suite():
    suite = unittest.TestSuite()
    suite.addTest(TestXMLCompleteness())
    suite.addTest(TestXMLContent())
    suite.addTest(TestMatchRequiredOrDefault())
    return suite


if __name__ == "__main__":
    base.run(suite())
コード例 #17
0
            "ambari" in stdout or "test-" in stdout.lower(),
            "Unable to contact " + ' '.join(ambari.sshcmd()) + "\n" + stdout)
        # Test adding more space with add_new_ebs_volume
        stdout = lD.run_quiet(
            deploy_dir + "/aws/add_ebsvol_to_instance.py --not-strict " + iid +
            ' \'{"Mount": "/tmp/testdir1", "Size": 1, "Attach": "/dev/sdf"}\'')
        stdout = ambari.run("ls -l /tmp/testdir1")
        self.assertFalse(
            "No such file or directory" in stdout,
            "Unable to crate/mount /dev/sdf " + ' '.join(ambari.sshcmd()) +
            "\n" + stdout)


def suite(verbose=False, ostype="Centos7"):
    suite = unittest.TestSuite()
    test = DepKnown()
    test.debug = verbose
    test.ostype = ostype
    suite.addTest(test)
    return suite


if __name__ == "__main__":
    verbose = False
    if "--verbose" in sys.argv:
        verbose = True
    ostype = "Centos7"
    if len(sys.argv) > 1:
        ostype = sys.argv[1]
    base.run(suite(verbose, ostype=ostype))
コード例 #18
0
#     raise Exception('For geons dataset you must choose a subset '
#                     'using the --subset flag.')

if args.forcemodels: args.force = True

kwargs = {
    'exp': args.exp,
    'task': args.task,
    'func': args.func,
    'subset': args.subset,
    'model_name': args.model,
    'model_path': args.model_path,
    'layers': layers,
    'mode': args.mode,
    'savedata': not args.dry,
    'force': args.force,
    'forcemodels': args.forcemodels,
    'filter': args.filter,
    'savefig': args.savefig,
    'report': False,
    'bootstrap': args.bootstrap,
    'html': None,
    'dissim': args.dissim
}

if args.exp in global_tasks:
    kwargs['task'] = args.exp
    base.run(**kwargs)
else:
    base.run(**kwargs)
コード例 #19
0
class SrtfScheduler(base.Scheduler):
    def interrupt(self, time, process):
        if process is not None:
            process.remaining_time = process.burst_time
            self.ready_processes.append(process)

        if self.currently_running is not None:
            self.currently_running.remaining_time -= (
                time - self.currently_running.start_time)
            self._add_to_history(self.currently_running,
                                 self.currently_running.start_time, time)
            if self.currently_running.remaining_time == 0:
                self.ready_processes.remove(self.currently_running)

        self.ready_processes.sort(key=lambda x: x.remaining_time)
        self.currently_running = None
        if len(self.ready_processes):
            self.currently_running = self.ready_processes[0]
            self.currently_running.start_time = time
            self.currently_running.end_time = (
                time + self.currently_running.remaining_time)

        if self.currently_running is None:
            return None
        else:
            return self.currently_running.end_time


base.run(SrtfScheduler)
コード例 #20
0
class HrrnScheduler(base.Scheduler):
    def interrupt(self, time, process):
        sort_key = lambda x: (time - x.arrival_time) / x.burst_time
        if process is not None:
            process.arrival_time = time
            self.ready_processes.append(process)

        if self.currently_running is not None:
            if time == self.currently_running.end_time:
                self._add_to_history(self.currently_running,
                                     self.currently_running.start_time,
                                     self.currently_running.end_time)
                self.currently_running = None

        if self.currently_running is None:
            if len(self.ready_processes):
                self.ready_processes.sort(key=sort_key, reverse=True)
                self.currently_running = self.ready_processes[0]
                self.currently_running.start_time = time
                self.currently_running.end_time = (
                    time + self.currently_running.burst_time)
                del self.ready_processes[0]

        if self.currently_running is None:
            return None
        else:
            return self.currently_running.end_time


base.run(HrrnScheduler)
コード例 #21
0
"Test the root API endpoint."

import http.client

import base


class Root(base.Base):
    "Test the root API endpoint."

    def test_root_data(self):
        "Get API root JSON."
        url = f"{base.SETTINGS['ROOT_URL']}"
        response = self.GET(url)
        self.check_schema(response)


if __name__ == '__main__':
    base.run()
コード例 #22
0
ファイル: micro_cluster.py プロジェクト: shit0u/AmbariKave
        # Check multiremote functionality
        allremotes, iids = self.multiremote_from_cluster_stdout(cstdout)
        allremotes.cp(deploy_dir + '/remotescripts/add_incoming_port.py',
                      'testtest.py')
        self.assertTrue("testtest.py" in ahost.run("ls -l"),
                        "pdcp failed to work properly")


def suite(verbose=False, branch="__local__"):
    suite = unittest.TestSuite()
    test = MicroCluster()
    test.debug = verbose
    test.branch = branch
    test.branchtype = branch
    suite.addTest(test)
    return suite


if __name__ == "__main__":
    verbose = False
    if "--verbose" in sys.argv:
        verbose = True
    branch = "__local__"
    if "--branch" in sys.argv:
        branch = "__service__"
        sys.argv = [s for s in sys.argv if s != "--branch"]
    if "--this-branch" in sys.argv:
        branch = "__local__"
        sys.argv = [s for s in sys.argv if s != "--this-branch"]
    base.run(suite(verbose, branch))
コード例 #23
0
#!/usr/bin/env python
import os
import base

if __name__ == '__main__':

    current_file_folder = os.path.dirname(os.path.realpath(__file__))
    base.config.load_from_yaml(
        f'{current_file_folder}/config/config.{os.getenv("ENVIRONMENT", "local")}.yaml'
    )

    # config.init_logging()

    with open(f'{current_file_folder}/keys/users.key.pem') as pubkey:
        base.store.set('users_service_public_key', pubkey.read())

    base.config.load_private_key(f'{current_file_folder}/keys/users.key')

    base.run(print_app_info=True, print_routes=True)
コード例 #24
0
ファイル: clusters.py プロジェクト: shit0u/AmbariKave
    if "--verbose" in sys.argv:
        verbose = True
        sys.argv = [s for s in sys.argv if s != "--verbose"]
    branch = "__local__"
    if "--branch" in sys.argv:
        branch = "__service__"
        sys.argv = [s for s in sys.argv if s != "--branch"]
    if "--this-branch" in sys.argv:
        branch = "__local__"
        sys.argv = [s for s in sys.argv if s != "--this-branch"]
    if "--prod" in sys.argv:
        clustername = 'prod'
        sys.argv = [s for s in sys.argv if s != "--prod"]
    if len(sys.argv) < 2:
        raise KeyError("You must specify which blueprint/cluster to test")
    service = sys.argv[1]
    test = TestCluster()
    if service.startswith("FREEIPA"):
        test = TestFreeIPACluster()
    test.service = service
    test.debug = verbose
    test.clustername = clustername
    test.branch = branch
    test.branchtype = branch
    test.checklist = []
    if len(sys.argv) > 2:
        test.checklist = sys.argv[2:]
    suite = unittest.TestSuite()
    suite.addTest(test)
    base.run(suite)
コード例 #25
0
ファイル: post-policy.py プロジェクト: zxpbit/yig
            ['eq', '$content-type', 'text/plain'],
            ['eq', '$success_action_redirect', 'http://github.com']
        ]
    )
    print ans
    fields = ans['fields']
    html = HTML[name]
    html = html.replace('{URL}', ans['url']).replace('{POLICY}', fields['policy'])
    if 'v4' in name:
        html = html.replace('{CREDENTIAL}', fields['x-amz-credential'])\
               .replace('{DATE}', fields['x-amz-date'])\
               .replace('{SIGNATURE}', fields['x-amz-signature'])
    else:
        html = html.replace('{ACCESS_KEY}', fields['AWSAccessKeyId'])\
               .replace('{SIGNATURE}', fields['signature'])
    f = open('post-policy-' + name + '.html', 'w')
    f.write(html)
    f.close()
    print '>>> Now open', 'post-policy-' + name + '.html', 'and test in browser.'

# =====================================================

TESTS = [
    sanity.create_bucket,
    put_bucket_cors,
    generate_post_policy,
]

if __name__ == '__main__':
    base.run(TESTS)
コード例 #26
0
        priv_ip = lA.priv_ip(iid)
        stdout = ahost.run("host " + priv_ip)
        self.assertTrue("domain name pointer" in stdout,
                        "Reverse lookup broken on testing-001.kave.io! ("
                        + ' '.join(ahost.sshcmd()) + ")")


def suite(verbose=False, branch="__local__"):
    suite = unittest.TestSuite()
    test = MicroCluster()
    test.debug = verbose
    test.branch = branch
    test.branchtype = branch
    suite.addTest(test)
    return suite


if __name__ == "__main__":
    verbose = False
    if "--verbose" in sys.argv:
        verbose = True
    branch = "__local__"
    if "--branch" in sys.argv:
        branch = "__service__"
        sys.argv = [s for s in sys.argv if s != "--branch"]
    if "--this-branch" in sys.argv:
        branch = "__local__"
        sys.argv = [s for s in sys.argv if s != "--this-branch"]
    base.run(suite(verbose, branch))
コード例 #27
0
import base

while True:
    text = input('Malieca > ')
    result, error = base.run('<stdin>', text)

    if error: print(error.as_string())
    elif result: print(repr(result))