Python utils.render函数代码示例

def disk_setup(swift_user):
    # Setup a loopdevice to act as disk for swift
    sudo('mkdir -p /srv')
    sudo('truncate -s 1GB /srv/swift-disk')
    sudo('mkfs.xfs /srv/swift-disk')
    fabric.contrib.files.append(
        filename='/etc/fstab',
        text='/srv/swift-disk /mnt/sdb1 xfs loop,noatime 0 0',
        use_sudo=True
    )

    sudo('mkdir /mnt/sdb1')
    sudo('mount /mnt/sdb1')

    # Prepare directory structure for 4 swift nodes, with two "partitions" each
    node_mkdir = 'mkdir -p /mnt/sdb1/{0:d}/node/sdb{1:d}'
    num_nodes = 4
    for i in range(1, num_nodes + 1):
        sudo(node_mkdir.format(i, i))
        sudo(node_mkdir.format(i, i + num_nodes))
        sudo('ln -s /mnt/sdb1/{0:d} /srv/{1:d}'.format(i, i))
        sudo('mkdir /var/cache/swift{0:d}'.format(i))

    sudo('chown -R {0:s}: /mnt/sdb1'.format(swift_user))
    sudo('mkdir /var/run/swift')
    sudo('chown {0:s}: /var/run/swift /var/cache/swift*'.format(swift_user))
    render(
        directory='assets/saio/phase1/etc',
        filenames=['rc.local'],
        local_path_prefix='assets/saio/phase1',
        content={'user': swift_user},
    )
    sudo('chmod 755 /etc/rc.local')
    sudo('chown root: /etc/rc.local')

 def generateEnum(self,key,content):
     """"""
     render('enum',
            {'name':key,'enumlist':getList(content['VALUES'],True)},
            'definedtypes',
            append=True,
           )     

def home(request):
    """ Home view to render the index.html page.
        If user not authenticated, a login page is shown.
        Permissions used in template as {% if perms.product.add_product %}
    """
    try:
        product = get_active_product(request)
    except:
        # if superuser and first time, create groups for PO and SM
        if request.user.is_superuser:
            init_super_groups(request.user)
        return render(request, 'index', {})

    data = {'product':product, 'myproducts':get_my_products(request.user)}

    # get active sprint
    sprint = get_active_sprint(product)
    if sprint:
        data['sprint'] = sprint
    
    # get list of sprints, return top 3 if more
    data['sprints'] = product.sprint_set.get_query_set().filter(start__lt=datetime.now())[:3]
#    logger.debug('views.home: sprint=%s, sprints=%s'%(sprint,data['sprints']))
    
    # get my tasks
    mytasks = get_my_tasks(request.user, product)
    if mytasks:
        data['tasks'] = mytasks
    
    data['is_master'] = product.owner_or_master(request.user)
    
    return render(request, 'index', data)

 def generateSelect(self,key,content):
     """generate select type
     """
     render('select',
            {'name':key, 'selectlist':','.join(content['VALUES'])},
           key 
           )

 def delete(self):
     post = db.get(self.request.get('post_id'))
     if post:
         post.delete()
         context = {} 
         render(self, 'post_del.html', context)
     else:
         self.error(404)

 def get(self, *args, **kwargs):
     post = db.Query(Post).filter('slug =', args[2]).get()
     context = {
         'post': post
     }
     admin = users.is_current_user_admin()
     if admin:
         context['is_admin'] = admin
     render(self, 'post_item.html', context)

 def generateIndexes(self):
     """"""
     code=''
     for entity in modules:
         code+=getImport(entity)
     render('initimport',
            {'imports':code},
            '__init__'
           )

    def generateModelFile(self,ids,to):
        """"""
        code=''
        for i in ids:
            line=self.lines[i]
            code+='#%d=%s(%s);\n'%(i,line[0],line[1])

        render('temp.ifc',
               {'schema':','.join(self.header.fileSchema.schemaIdentifiers),'data':code},
              to)

def scality_storage_policy(swift_user, sproxyd_endpoint):
    """
    Install a storage policy backed by Scality RING.

    :param swift_user: the user swift is running as
    :type swift_user: string
    :param sproxyd_endpoint: the sproxyd endpoint backing the storage policy
    :type sproxyd_endpoint: string
    """
    # Validate sproxyd endpoint connectivity.
    curl_cmd = run('curl --fail --connect-timeout 15 {0:s}/.conf'.format(
                   sproxyd_endpoint), warn_only=True)

    if curl_cmd.failed:
        raise Exception("Unable to establish a connection to sproxyd at "
                        "'{0:s}.'".format(sproxyd_endpoint))

    # Install dependencies.
    saio.install_scality_swift()

    # Add scality RING storage policy.
    content = {
        'sproxyd_endpoint': sproxyd_endpoint,
        'user': swift_user,
    }
    for path, _, filenames in os.walk('assets/saio/phase2/etc/swift'):
        utils.render(path, filenames, 'assets/saio/phase2', content)
    sudo('chown -R {0:s} /etc/swift'.format(swift_user))

    # Setup an additional object ring.
    sudo('mkdir -p /srv/scality/placeholder')
    sudo('chown -R {0:s}: /srv/scality'.format(swift_user))
    sudo('mkdir -p /var/cache/scality')
    sudo('chown {0:s}: /var/cache/scality'.format(swift_user))

    utils.render(
        directory='assets/saio/phase2/etc',
        filenames=['rc.local'],
        local_path_prefix='assets/saio/phase2',
        content={'user': swift_user},
    )
    sudo('chmod 755 /etc/rc.local')
    sudo('chown root: /etc/rc.local')

    utils.build_object_ring(
        swift_user=swift_user,
        name='object-1.builder',
        devices=[
            'r1z1-127.0.0.1:6050/placeholder',
        ],
        replicas=1,
    )

    saio.stop(swift_user)
    saio.start(swift_user)

def comment_view(environ):
    context = Comment().errors
    if environ['REQUEST_METHOD'] == 'POST':
        comment = Comment()
        comment.import_post_form(environ)
        if comment.is_valid():
            comment.save()
            return render('success.html')
        else:
            context = comment.errors
    return render('form.html', context)

def toGraph(model,basename):
    """"""
    pattern=re.compile(r'#(\d+)')
    code=''
    for key,value in model.lines.items():
        #print key,value
        refs=pattern.findall(value[1])
        for ref in refs:
            code+='    %d->%s;\n'%(key,ref)
    title=model.header.fileName.name
    render('temp.dot',
           {'name':title,'content':code},
           basename+'.dot')

def install(swift_user):
    sudo('pip install '
         'git+https://github.com/openstack/[email protected]')
    sudo('pip install git+https://github.com/openstack/[email protected]')

    content = {
        'user': swift_user,
        'group': swift_user,
    }
    for path, _, filenames in os.walk('assets/saio/phase1/etc/swift'):
        render(path, filenames, 'assets/saio/phase1', content)

    sudo('chown -R {0:s}: /etc/swift'.format(swift_user))

 def get(self, key):
     '''check if the given key is valid'''
     query = Subscription.all().filter('validation_key =', key)
     if not query.count():
         logging.debug('Subscription failed with key %s' % key)
         resp = render('abo_subscribe_wrong_key.html')
     else:
         subscription = query.get()
         subscription.active = True
         subscription.put()
         logging.info('New subscription: %s' % subscription.email)
         resp = render('abo_subscribe_complete.html')
     self.response.out.write(resp)

def setup_rsync(swift_user):
    render(
        directory='assets/saio/phase1/etc',
        filenames=['rsyncd.conf'],
        local_path_prefix='assets/saio/phase1',
        content={'user': swift_user, 'group': swift_user},
    )
    fabric.contrib.files.sed(
        filename='/etc/default/rsync',
        before='RSYNC_ENABLE=false',
        after='RSYNC_ENABLE=true',
        use_sudo=True,
    )

    sudo('sudo service rsync restart')

def get_obstask_render(task_key, reload=False):
    obstask = get_task(task_key)
    obslist = []
    area_name = 'unknown'
    debugstr = ''
    if obstask is not None:
        area = obstask.aoi.get()
        if area != None:
            area_name = area.name.encode('utf-8')
            resultstr = "Observation Task for {0!s} to check area {1!s} <br>".format(obstask.assigned_owner.string_id(), area_name)
            resultstr += "{0!s} Task assigned to: <i>{1!s}</i><br>".format(obstask.shared_str(), obstask.assigned_owner.string_id())
            resultstr += "Status <em>{0!s}</em>. ".format(obstask.status)
            if obstask.priority != None:
                resultstr += "Priority <em>{0:d}.</em> ".format(obstask.priority)

            #debugstr = resultstr + " task: " + str(obstask.key) + " has " + str(len(obstask.observations)) + " observations"
            debugstr = resultstr + "Task has " + str(len(obstask.observations)) + " observations"
            for obs_key in obstask.observations:
                obs = obs_key.get()
                if obs is not None:
                    obslist.append(obs.Observation2Dictionary()) # includes a list of precomputed overlays
                else:
                    logging.error("Missing Observation from cache")
        else:
            resultstr = 'Observation Task for deleted area! area key: {0:s} <br>'.format(obstask.aoi)
            debugstr = resultstr
            logging.error(resultstr)
            data = utils.render('obstask-render.html', {
                        'obstask': obstask,
                        'obslist': obslist,
                        'resultstr': resultstr,
                        'area' :  'Deleted',
                        'created_date' : obstask.created_date.strftime("%Y-%m-%d"),
                        'obstask_url': obstask.taskurl()
                        } )
    else:
        logging.error('get_obstask_render(): No obstask')
        return None

    data = utils.render('obstask-render.html', {
        'obstask': obstask,
        'obslist': obslist,
        'resultstr': debugstr,
        'area' :  area_name,
        'created_date' : obstask.created_date.strftime("%Y-%m-%d"),
        'obstask_url': obstask.taskurl()
        } )
    return data