filename
stringlengths
4
198
content
stringlengths
25
939k
environment
list
variablearg
list
constarg
list
variableargjson
stringclasses
1 value
constargjson
stringlengths
2
3.9k
lang
stringclasses
3 values
constargcount
float64
0
129
variableargcount
float64
0
0
sentence
stringclasses
1 value
cmd/main.go
package main import ( "context" "database/sql" "log" "net" "net/http" "os" "github.com/Asymmetriq/url_shortener/internal/service" "github.com/Asymmetriq/url_shortener/internal/storage" "github.com/Asymmetriq/url_shortener/pkg/api" gw "github.com/Asymmetriq/url_shortener/pkg/pb/api" "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" _ "github.com/lib/pq" "google.golang.org/grpc" ) func main() { dsn := os.Getenv("DATABASE_URL") db, err := sql.Open("postgres", dsn) if err != nil { log.Fatal(err) } storageDB := &storage.StorageDB{DB: db} // server srv := &service.Service{ Storage: storageDB, } // GRPC listener, err := net.Listen("tcp", ":5000") if err != nil { log.Fatal(err) } grpcOpts := []grpc.ServerOption{} grpcServer := grpc.NewServer(grpcOpts...) api.RegisterServiceServer(grpcServer, srv) log.Println("gRPC server listening on :5000") go grpcServer.Serve(listener) // HTTP ctx := context.Background() ctx, cancel := context.WithCancel(ctx) defer cancel() // Register gRPC server endpoint // Note: Make sure the gRPC server is running properly and accessible gwmux := runtime.NewServeMux() err = gw.RegisterServiceHandlerServer(ctx, gwmux, srv) if err != nil { log.Fatal(err) } // Create a gRPC Gateway server httpServer := &http.Server{ Addr: ":8000", Handler: gwmux, } log.Println("gRPC server listening on :8000") httpServer.ListenAndServe() }
[ "\"DATABASE_URL\"" ]
[]
[ "DATABASE_URL" ]
[]
["DATABASE_URL"]
go
1
0
editregions/admin/forms.py
# -*- coding: utf-8 -*- import logging from django.core.exceptions import ObjectDoesNotExist from django.db.models import F from django.forms import Form, Media try: from django.forms.utils import ErrorList except ImportError: # < Django 1.7 ... pragma: no cover from django.forms.util import ErrorList from django.forms.fields import IntegerField, CharField try: from django.utils.encoding import force_text except ImportError: # pragma: no cover ... < Django 1.5 from django.utils.encoding import force_unicode as force_text from editregions.utils.data import attach_configuration, get_configuration from editregions.models import EditRegionChunk, EditRegionConfiguration from editregions.admin.utils import shared_media from editregions.utils.regions import validate_region_name logger = logging.getLogger(__name__) class EditRegionInlineForm(object): """ Used by EditRegionInlineFormSet """ media = Media() class EditRegionInlineFormSet(object): """ A minimal representation of a FormSet as called by the Django inline admin code. The most importand bit is our media definition, everything else is literally just to appear correct. """ initial_forms = [] extra_forms = [] media = shared_media empty_form = EditRegionInlineForm() errors = {} # used for constructing change messages new_objects = [] changed_objects = [] deleted_objects = [] @classmethod def get_default_prefix(cls): return 'edit_region_chunk_formset' def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs def get_queryset(self, *args, **kwargs): return self.kwargs['queryset'] def is_valid(self, *args, **kwargs): return True def save(self, *args, **kwargs): return True def non_form_errors(self): return ErrorList() class MovementForm(Form): """ Move a chunk from one place to another. """ pk = IntegerField(min_value=1) position = IntegerField(min_value=0) #: if region is set, then we're probably in an inline'd changelist, and #: we may be wanting to move region ... region = CharField(required=False, validators=[validate_region_name]) def __init__(self, *args, **kwargs): super(MovementForm, self).__init__(*args, **kwargs) self.fields['pk'].max_value = self.get_model().objects.all().count() def get_model(self): return EditRegionChunk def clean(self): cd = super(MovementForm, self).clean() pk = cd.get('pk', None) model = self.get_model() try: if pk is None: raise model.DoesNotExist("Don't even bother querying") cd['pk'] = model.objects.get(pk=pk) except model.DoesNotExist as e: cd['pk'] = None name = force_text(self.get_model()._meta.verbose_name) msg = '{0} does not exist'.format(name) self._errors['pk'] = msg # rather than raise an error for an invalid region, just set it # back to whatever the region says it should be. Trust no-one. if 'region' in cd and cd['pk'] is not None: attach_configuration(cd['pk'].content_object, EditRegionConfiguration) erc = get_configuration(cd['pk'].content_object) if cd['region'] not in erc.config: msg = '{0} is not a valid region'.format(cd['region']) self._errors['region'] = msg return cd def save(self): """ Updates the current object, and all other objects in the same region. """ obj = self.cleaned_data['pk'] old_position = obj.position old_region = obj.region new_position = max(self.cleaned_data['position'], 0) new_region = self.cleaned_data.get('region', old_region) return self.get_model().objects.move( obj=obj, from_position=old_position, to_position=new_position, from_region=old_region, to_region=new_region) def change_message(self): obj = self.cleaned_data['pk'] msg = 'Moved to position {obj.position} in region "{obj.region}"'.format(obj=obj) logger.info(msg) return obj, msg def parent_change_message(self): obj = self.cleaned_data['pk'] msg = 'Moved {vname} (pk: {obj.pk}) to position {obj.position} in ' \ 'region "{obj.region}"'.format(vname=force_text(obj._meta.verbose_name), obj=obj) logger.info(msg) return obj.content_object, msg
[]
[]
[]
[]
[]
python
null
null
null
py38-win/Scripts/waf3-2.0.22-fee054444594956e012048d7248f6b4b/waflib/Utils.py
#! /usr/bin/env python # encoding: utf-8 # WARNING! Do not edit! https://waf.io/book/index.html#_obtaining_the_waf_file from __future__ import with_statement import atexit,os,sys,errno,inspect,re,datetime,platform,base64,signal,functools,time,shlex try: import cPickle except ImportError: import pickle as cPickle if os.name=='posix'and sys.version_info[0]<3: try: import subprocess32 as subprocess except ImportError: import subprocess else: import subprocess try: TimeoutExpired=subprocess.TimeoutExpired except AttributeError: class TimeoutExpired(Exception): pass from collections import deque,defaultdict try: import _winreg as winreg except ImportError: try: import winreg except ImportError: winreg=None from waflib import Errors try: from hashlib import md5 except ImportError: try: from hashlib import sha1 as md5 except ImportError: pass else: try: md5().digest() except ValueError: from hashlib import sha1 as md5 try: import threading except ImportError: if not'JOBS'in os.environ: os.environ['JOBS']='1' class threading(object): pass class Lock(object): def acquire(self): pass def release(self): pass threading.Lock=threading.Thread=Lock SIG_NIL='SIG_NIL_SIG_NIL_'.encode() O644=420 O755=493 rot_chr=['\\','|','/','-'] rot_idx=0 class ordered_iter_dict(dict): def __init__(self,*k,**kw): self.lst=deque() dict.__init__(self,*k,**kw) def clear(self): dict.clear(self) self.lst=deque() def __setitem__(self,key,value): if key in dict.keys(self): self.lst.remove(key) dict.__setitem__(self,key,value) self.lst.append(key) def __delitem__(self,key): dict.__delitem__(self,key) try: self.lst.remove(key) except ValueError: pass def __iter__(self): return reversed(self.lst) def keys(self): return reversed(self.lst) class lru_node(object): __slots__=('next','prev','key','val') def __init__(self): self.next=self self.prev=self self.key=None self.val=None class lru_cache(object): __slots__=('maxlen','table','head') def __init__(self,maxlen=100): self.maxlen=maxlen self.table={} self.head=lru_node() self.head.next=self.head self.head.prev=self.head def __getitem__(self,key): node=self.table[key] if node is self.head: return node.val node.prev.next=node.next node.next.prev=node.prev node.next=self.head.next node.prev=self.head self.head=node.next.prev=node.prev.next=node return node.val def __setitem__(self,key,val): if key in self.table: node=self.table[key] node.val=val self.__getitem__(key) else: if len(self.table)<self.maxlen: node=lru_node() node.prev=self.head node.next=self.head.next node.prev.next=node.next.prev=node else: node=self.head=self.head.next try: del self.table[node.key] except KeyError: pass node.key=key node.val=val self.table[key]=node class lazy_generator(object): def __init__(self,fun,params): self.fun=fun self.params=params def __iter__(self): return self def __next__(self): try: it=self.it except AttributeError: it=self.it=self.fun(*self.params) return next(it) next=__next__ is_win32=os.sep=='\\'or sys.platform=='win32'or os.name=='nt' def readf(fname,m='r',encoding='latin-1'): if sys.hexversion>0x3000000 and not'b'in m: m+='b' with open(fname,m)as f: txt=f.read() if encoding: txt=txt.decode(encoding) else: txt=txt.decode() else: with open(fname,m)as f: txt=f.read() return txt def writef(fname,data,m='w',encoding='latin-1'): if sys.hexversion>0x3000000 and not'b'in m: data=data.encode(encoding) m+='b' with open(fname,m)as f: f.write(data) def h_file(fname): m=md5() with open(fname,'rb')as f: while fname: fname=f.read(200000) m.update(fname) return m.digest() def readf_win32(f,m='r',encoding='latin-1'): flags=os.O_NOINHERIT|os.O_RDONLY if'b'in m: flags|=os.O_BINARY if'+'in m: flags|=os.O_RDWR try: fd=os.open(f,flags) except OSError: raise IOError('Cannot read from %r'%f) if sys.hexversion>0x3000000 and not'b'in m: m+='b' with os.fdopen(fd,m)as f: txt=f.read() if encoding: txt=txt.decode(encoding) else: txt=txt.decode() else: with os.fdopen(fd,m)as f: txt=f.read() return txt def writef_win32(f,data,m='w',encoding='latin-1'): if sys.hexversion>0x3000000 and not'b'in m: data=data.encode(encoding) m+='b' flags=os.O_CREAT|os.O_TRUNC|os.O_WRONLY|os.O_NOINHERIT if'b'in m: flags|=os.O_BINARY if'+'in m: flags|=os.O_RDWR try: fd=os.open(f,flags) except OSError: raise OSError('Cannot write to %r'%f) with os.fdopen(fd,m)as f: f.write(data) def h_file_win32(fname): try: fd=os.open(fname,os.O_BINARY|os.O_RDONLY|os.O_NOINHERIT) except OSError: raise OSError('Cannot read from %r'%fname) m=md5() with os.fdopen(fd,'rb')as f: while fname: fname=f.read(200000) m.update(fname) return m.digest() readf_unix=readf writef_unix=writef h_file_unix=h_file if hasattr(os,'O_NOINHERIT')and sys.hexversion<0x3040000: readf=readf_win32 writef=writef_win32 h_file=h_file_win32 try: x=''.encode('hex') except LookupError: import binascii def to_hex(s): ret=binascii.hexlify(s) if not isinstance(ret,str): ret=ret.decode('utf-8') return ret else: def to_hex(s): return s.encode('hex') to_hex.__doc__=""" Return the hexadecimal representation of a string :param s: string to convert :type s: string """ def listdir_win32(s): if not s: try: import ctypes except ImportError: return[x+':\\'for x in'ABCDEFGHIJKLMNOPQRSTUVWXYZ'] else: dlen=4 maxdrives=26 buf=ctypes.create_string_buffer(maxdrives*dlen) ndrives=ctypes.windll.kernel32.GetLogicalDriveStringsA(maxdrives*dlen,ctypes.byref(buf)) return[str(buf.raw[4*i:4*i+2].decode('ascii'))for i in range(int(ndrives/dlen))] if len(s)==2 and s[1]==":": s+=os.sep if not os.path.isdir(s): e=OSError('%s is not a directory'%s) e.errno=errno.ENOENT raise e return os.listdir(s) listdir=os.listdir if is_win32: listdir=listdir_win32 def num2ver(ver): if isinstance(ver,str): ver=tuple(ver.split('.')) if isinstance(ver,tuple): ret=0 for i in range(4): if i<len(ver): ret+=256**(3-i)*int(ver[i]) return ret return ver def to_list(val): if isinstance(val,str): return val.split() else: return val def console_encoding(): try: import ctypes except ImportError: pass else: try: codepage=ctypes.windll.kernel32.GetConsoleCP() except AttributeError: pass else: if codepage: return'cp%d'%codepage return sys.stdout.encoding or('cp1252'if is_win32 else'latin-1') def split_path_unix(path): return path.split('/') def split_path_cygwin(path): if path.startswith('//'): ret=path.split('/')[2:] ret[0]='/'+ret[0] return ret return path.split('/') re_sp=re.compile('[/\\\\]+') def split_path_win32(path): if path.startswith('\\\\'): ret=re_sp.split(path)[1:] ret[0]='\\\\'+ret[0] if ret[0]=='\\\\?': return ret[1:] return ret return re_sp.split(path) msysroot=None def split_path_msys(path): if path.startswith(('/','\\'))and not path.startswith(('//','\\\\')): global msysroot if not msysroot: msysroot=subprocess.check_output(['cygpath','-w','/']).decode(sys.stdout.encoding or'latin-1') msysroot=msysroot.strip() path=os.path.normpath(msysroot+os.sep+path) return split_path_win32(path) if sys.platform=='cygwin': split_path=split_path_cygwin elif is_win32: if os.environ.get('MSYSTEM')and sys.executable.startswith('/'): split_path=split_path_msys else: split_path=split_path_win32 else: split_path=split_path_unix split_path.__doc__=""" Splits a path by / or \\; do not confuse this function with with ``os.path.split`` :type path: string :param path: path to split :return: list of string """ def check_dir(path): if not os.path.isdir(path): try: os.makedirs(path) except OSError as e: if not os.path.isdir(path): raise Errors.WafError('Cannot create the folder %r'%path,ex=e) def check_exe(name,env=None): if not name: raise ValueError('Cannot execute an empty string!') def is_exe(fpath): return os.path.isfile(fpath)and os.access(fpath,os.X_OK) fpath,fname=os.path.split(name) if fpath and is_exe(name): return os.path.abspath(name) else: env=env or os.environ for path in env['PATH'].split(os.pathsep): path=path.strip('"') exe_file=os.path.join(path,name) if is_exe(exe_file): return os.path.abspath(exe_file) return None def def_attrs(cls,**kw): for k,v in kw.items(): if not hasattr(cls,k): setattr(cls,k,v) def quote_define_name(s): fu=re.sub('[^a-zA-Z0-9]','_',s) fu=re.sub('_+','_',fu) fu=fu.upper() return fu try: shell_quote=shlex.quote except AttributeError: import pipes shell_quote=pipes.quote def shell_escape(cmd): if isinstance(cmd,str): return cmd return' '.join(shell_quote(x)for x in cmd) def h_list(lst): return md5(repr(lst).encode()).digest() if sys.hexversion<0x3000000: def h_list_python2(lst): return md5(repr(lst)).digest() h_list_python2.__doc__=h_list.__doc__ h_list=h_list_python2 def h_fun(fun): try: return fun.code except AttributeError: if isinstance(fun,functools.partial): code=list(fun.args) code.extend(sorted(fun.keywords.items())) code.append(h_fun(fun.func)) fun.code=h_list(code) return fun.code try: h=inspect.getsource(fun) except EnvironmentError: h='nocode' try: fun.code=h except AttributeError: pass return h def h_cmd(ins): if isinstance(ins,str): ret=ins elif isinstance(ins,list)or isinstance(ins,tuple): ret=str([h_cmd(x)for x in ins]) else: ret=str(h_fun(ins)) if sys.hexversion>0x3000000: ret=ret.encode('latin-1','xmlcharrefreplace') return ret reg_subst=re.compile(r"(\\\\)|(\$\$)|\$\{([^}]+)\}") def subst_vars(expr,params): def repl_var(m): if m.group(1): return'\\' if m.group(2): return'$' try: return params.get_flat(m.group(3)) except AttributeError: return params[m.group(3)] return reg_subst.sub(repl_var,expr) def destos_to_binfmt(key): if key=='darwin': return'mac-o' elif key in('win32','cygwin','uwin','msys'): return'pe' return'elf' def unversioned_sys_platform(): s=sys.platform if s.startswith('java'): from java.lang import System s=System.getProperty('os.name') if s=='Mac OS X': return'darwin' elif s.startswith('Windows '): return'win32' elif s=='OS/2': return'os2' elif s=='HP-UX': return'hp-ux' elif s in('SunOS','Solaris'): return'sunos' else:s=s.lower() if s=='powerpc': return'darwin' if s=='win32'or s=='os2': return s if s=='cli'and os.name=='nt': return'win32' return re.split(r'\d+$',s)[0] def nada(*k,**kw): pass class Timer(object): def __init__(self): self.start_time=self.now() def __str__(self): delta=self.now()-self.start_time if not isinstance(delta,datetime.timedelta): delta=datetime.timedelta(seconds=delta) days=delta.days hours,rem=divmod(delta.seconds,3600) minutes,seconds=divmod(rem,60) seconds+=delta.microseconds*1e-6 result='' if days: result+='%dd'%days if days or hours: result+='%dh'%hours if days or hours or minutes: result+='%dm'%minutes return'%s%.3fs'%(result,seconds) def now(self): return datetime.datetime.utcnow() if hasattr(time,'perf_counter'): def now(self): return time.perf_counter() def read_la_file(path): sp=re.compile(r'^([^=]+)=\'(.*)\'$') dc={} for line in readf(path).splitlines(): try: _,left,right,_=sp.split(line.strip()) dc[left]=right except ValueError: pass return dc def run_once(fun): cache={} def wrap(*k): try: return cache[k] except KeyError: ret=fun(*k) cache[k]=ret return ret wrap.__cache__=cache wrap.__name__=fun.__name__ return wrap def get_registry_app_path(key,filename): if not winreg: return None try: result=winreg.QueryValue(key,"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\%s.exe"%filename[0]) except OSError: pass else: if os.path.isfile(result): return result def lib64(): if os.sep=='/': if platform.architecture()[0]=='64bit': if os.path.exists('/usr/lib64')and not os.path.exists('/usr/lib32'): return'64' return'' def sane_path(p): return os.path.abspath(os.path.expanduser(p)) process_pool=[] def get_process(): try: return process_pool.pop() except IndexError: filepath=os.path.dirname(os.path.abspath(__file__))+os.sep+'processor.py' cmd=[sys.executable,'-c',readf(filepath)] return subprocess.Popen(cmd,stdout=subprocess.PIPE,stdin=subprocess.PIPE,bufsize=0,close_fds=not is_win32) def run_prefork_process(cmd,kwargs,cargs): if not kwargs.get('env'): kwargs['env']=dict(os.environ) try: obj=base64.b64encode(cPickle.dumps([cmd,kwargs,cargs])) except(TypeError,AttributeError): return run_regular_process(cmd,kwargs,cargs) proc=get_process() if not proc: return run_regular_process(cmd,kwargs,cargs) proc.stdin.write(obj) proc.stdin.write('\n'.encode()) proc.stdin.flush() obj=proc.stdout.readline() if not obj: raise OSError('Preforked sub-process %r died'%proc.pid) process_pool.append(proc) lst=cPickle.loads(base64.b64decode(obj)) assert len(lst)==5 ret,out,err,ex,trace=lst if ex: if ex=='OSError': raise OSError(trace) elif ex=='ValueError': raise ValueError(trace) elif ex=='TimeoutExpired': exc=TimeoutExpired(cmd,timeout=cargs['timeout'],output=out) exc.stderr=err raise exc else: raise Exception(trace) return ret,out,err def lchown(path,user=-1,group=-1): if isinstance(user,str): import pwd entry=pwd.getpwnam(user) if not entry: raise OSError('Unknown user %r'%user) user=entry[2] if isinstance(group,str): import grp entry=grp.getgrnam(group) if not entry: raise OSError('Unknown group %r'%group) group=entry[2] return os.lchown(path,user,group) def run_regular_process(cmd,kwargs,cargs={}): proc=subprocess.Popen(cmd,**kwargs) if kwargs.get('stdout')or kwargs.get('stderr'): try: out,err=proc.communicate(**cargs) except TimeoutExpired: if kwargs.get('start_new_session')and hasattr(os,'killpg'): os.killpg(proc.pid,signal.SIGKILL) else: proc.kill() out,err=proc.communicate() exc=TimeoutExpired(proc.args,timeout=cargs['timeout'],output=out) exc.stderr=err raise exc status=proc.returncode else: out,err=(None,None) try: status=proc.wait(**cargs) except TimeoutExpired as e: if kwargs.get('start_new_session')and hasattr(os,'killpg'): os.killpg(proc.pid,signal.SIGKILL) else: proc.kill() proc.wait() raise e return status,out,err def run_process(cmd,kwargs,cargs={}): if kwargs.get('stdout')and kwargs.get('stderr'): return run_prefork_process(cmd,kwargs,cargs) else: return run_regular_process(cmd,kwargs,cargs) def alloc_process_pool(n,force=False): global run_process,get_process,alloc_process_pool if not force: n=max(n-len(process_pool),0) try: lst=[get_process()for x in range(n)] except OSError: run_process=run_regular_process get_process=alloc_process_pool=nada else: for x in lst: process_pool.append(x) def atexit_pool(): for k in process_pool: try: os.kill(k.pid,9) except OSError: pass else: k.wait() if(sys.hexversion<0x207000f and not is_win32)or sys.hexversion>=0x306000f: atexit.register(atexit_pool) if os.environ.get('WAF_NO_PREFORK')or sys.platform=='cli'or not sys.executable: run_process=run_regular_process get_process=alloc_process_pool=nada
[]
[]
[ "MSYSTEM", "WAF_NO_PREFORK", "JOBS" ]
[]
["MSYSTEM", "WAF_NO_PREFORK", "JOBS"]
python
3
0
jira/examples/issue-type-screen-schemes/create/create.go
package main import ( "context" "github.com/ctreminiom/go-atlassian/jira" "log" "os" ) func main() { /* ----------- Set an environment variable in git bash ----------- export HOST="https://ctreminiom.atlassian.net/" export MAIL="MAIL_ADDRESS" export TOKEN="TOKEN_API" Docs: https://stackoverflow.com/questions/34169721/set-an-environment-variable-in-git-bash */ var ( host = os.Getenv("HOST") mail = os.Getenv("MAIL") token = os.Getenv("TOKEN") ) atlassian, err := jira.New(nil, host) if err != nil { log.Fatal(err) } atlassian.Auth.SetBasicAuth(mail, token) payload := jira.IssueTypeScreenSchemePayloadScheme{ Name: "FX 2 Issue Type Screen Scheme", IssueTypeMappings: []*jira.IssueTypeScreenSchemeMappingPayloadScheme{ { IssueTypeID: "default", ScreenSchemeID: "10000", }, { IssueTypeID: "10004", // Bug ScreenSchemeID: "10002", }, }, } issueTypeScreenSchemeID, response, err := atlassian.Issue.Type.ScreenScheme.Create(context.Background(), &payload) if err != nil { if response != nil { log.Println("Response HTTP Response", string(response.BodyAsBytes)) } log.Fatal(err) } log.Println("Response HTTP Code", response.StatusCode) log.Println("HTTP Endpoint Used", response.Endpoint) log.Println(issueTypeScreenSchemeID) }
[ "\"HOST\"", "\"MAIL\"", "\"TOKEN\"" ]
[]
[ "MAIL", "HOST", "TOKEN" ]
[]
["MAIL", "HOST", "TOKEN"]
go
3
0
source/api/controlplane/profile/infrastructure/lambda/WorkflowErrorHandler/lambda_function.py
# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 ############################################################################## # # PURPOSE: # Handle exceptions caught by the AWS Step Function workflow # and optionally update the execution status of the Classifier plugin # ############################################################################## import os import json import traceback import boto3 from MediaReplayEngineWorkflowHelper import ControlPlane from MediaReplayEnginePluginHelper import MREExecutionError eb_client = boto3.client("events") def lambda_handler(event, context): print("Lambda got the following event:\n", event) program = event["Event"]["Program"] p_event = event["Event"]["Name"] key = event["Input"]["Media"]["S3Key"] filename = os.path.split(key)[-1] classifier_plugin_name = event["Profile"]["Classifier"]["Name"] try: print(f"Checking the execution status of '{classifier_plugin_name}' plugin in the current workflow execution for program '{program}' and event '{p_event}'") controlplane = ControlPlane() status = controlplane.get_plugin_execution_status(p_event, program, filename, classifier_plugin_name) if not status or status in ["Waiting", "In Progress"]: print(f"Updating the execution status of '{classifier_plugin_name}' from '{status}' to 'Error' to unblock upcoming workflow executions") controlplane.put_plugin_execution_status(p_event, program, filename, classifier_plugin_name, "Error") else: print(f"No update is needed as the execution status of '{classifier_plugin_name}' is already '{status}'") print(f"Notifying the workflow failure to MRE Event Bus with the caught exception message") detail = { "State": "WORKFLOW_FAILED", "Payload": event } eb_client.put_events( Entries=[ { "Source": "awsmre", "DetailType": "Workflow Status", "Detail": json.dumps(detail), "EventBusName": os.environ["EB_EVENT_BUS_NAME"] } ] ) print("Raising an exception back to the Step Function with the caught exception message to mark it as failed") raise MREExecutionError(event["Error"]) except MREExecutionError: raise except Exception as e: print(traceback.format_exc()) raise
[]
[]
[ "EB_EVENT_BUS_NAME" ]
[]
["EB_EVENT_BUS_NAME"]
python
1
0
cmd/controller-manager/main.go
/* * Copyright 2018-2019, EnMasse authors. * License: Apache License 2.0 (see the file LICENSE or http://apache.org/licenses/LICENSE-2.0.html). */ package main import ( "context" "flag" "fmt" "strings" "time" "github.com/enmasseproject/enmasse/pkg/monitoring" "os" "runtime" "github.com/enmasseproject/enmasse/pkg/util" // Import all Kubernetes client auth plugins (e.g. Azure, GCP, OIDC, etc.) "github.com/enmasseproject/enmasse/pkg/cache" "github.com/enmasseproject/enmasse/pkg/controller" "github.com/enmasseproject/enmasse/version" "github.com/operator-framework/operator-sdk/pkg/k8sutil" kubemetrics "github.com/operator-framework/operator-sdk/pkg/kube-metrics" "github.com/operator-framework/operator-sdk/pkg/leader" "github.com/operator-framework/operator-sdk/pkg/log/zap" "github.com/operator-framework/operator-sdk/pkg/metrics" sdkVersion "github.com/operator-framework/operator-sdk/version" "github.com/spf13/pflag" v1 "k8s.io/api/core/v1" kerrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/util/intstr" _ "k8s.io/client-go/plugin/pkg/client/auth" "k8s.io/client-go/rest" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/config" logf "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/manager" "sigs.k8s.io/controller-runtime/pkg/manager/signals" monitoringv1 "github.com/coreos/prometheus-operator/pkg/apis/monitoring/v1" "github.com/openshift/api" enmassescheme "github.com/enmasseproject/enmasse/pkg/client/clientset/versioned/scheme" "k8s.io/apimachinery/pkg/runtime/schema" ) // Change below variables to serve metrics on different host or port. var ( metricsHost = "0.0.0.0" metricsPort int32 = 8383 operatorMetricsPort int32 = 8686 ) var log = logf.Log.WithName("cmd") func printVersion() { log.Info(fmt.Sprintf("Operator Version: %s", version.Version)) log.Info(fmt.Sprintf("Go Version: %s", runtime.Version())) log.Info(fmt.Sprintf("Go OS/Arch: %s/%s", runtime.GOOS, runtime.GOARCH)) log.Info(fmt.Sprintf("Version of operator-sdk: %v", sdkVersion.Version)) } func main() { // Add the zap logger flag set to the CLI. The flag set must // be added before calling pflag.Parse(). pflag.CommandLine.AddFlagSet(zap.FlagSet()) // Add flags registered by imported packages (e.g. glog and // controller-runtime) pflag.CommandLine.AddGoFlagSet(flag.CommandLine) pflag.Parse() // Use a zap logr.Logger implementation. If none of the zap // flags are configured (or if the zap flag set is not being // used), this defaults to a production zap logger. // // The logger instantiated here can be changed to any logger // implementing the logr.Logger interface. This logger will // be propagated through the whole operator, generating // uniform and structured logs. logf.SetLogger(zap.Logger()) printVersion() namespace := os.Getenv("NAMESPACE") log.Info("Watching on namespace", "namespace", namespace) // Get a config to talk to the apiserver cfg, err := config.GetConfig() if err != nil { log.Error(err, "Failed to get configuration") os.Exit(1) } ctx := context.TODO() // Become the leader before proceeding err = leader.Become(ctx, "enmasse-lock") if err != nil { log.Error(err, "") os.Exit(1) } // prime cache with isOpenShift information log.Info("Running on OpenShift", "result", util.IsOpenshift()) log.Info("Running on OpenShift 4", "result", util.IsOpenshift4()) monitoringEnabled := monitoring.IsEnabled() // Install monitoring resources if monitoringEnabled { // Attempt to install the monitoring resources when the operator starts, and every 5 minutes thereafter go func() { ticker := time.NewTicker(5 * time.Minute) for ; true; <-ticker.C { serverClient, err := client.New(cfg, client.Options{}) if err != nil { log.Info(fmt.Sprintf("Failed to install monitoring resources: %s", err)) } else { err = installMonitoring(ctx, serverClient) if err != nil { log.Info(fmt.Sprintf("Failed to install monitoring resources: %s", err)) } else { log.Info("Successfully installed monitoring resources") ticker.Stop() } } } }() } globalGvks := make([]schema.GroupVersionKind, 0) // IoTInfrastructure is only processed in the namespace of the operator // FIXME: this may change in the future /* if util.IsModuleEnabled("IOT_CONFIG") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "iot.enmasse.io", Version: "v1", Kind: "IoTInfrastructure", }, schema.GroupVersionKind{ Group: "iot.enmasse.io", Version: "v1", Kind: "IoTInfrastructureList", }) } */ if util.IsModuleEnabled("IOT_TENANT") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "iot.enmasse.io", Version: "v1", Kind: "IoTTenant", }, schema.GroupVersionKind{ Group: "iot.enmasse.io", Version: "v1", Kind: "IoTTenantList", }) } if util.IsModuleEnabled("MESSAGING_INFRASTRUCTURE") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingInfrastructure", }, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingInfrastructureList", }, ) } if util.IsModuleEnabled("MESSAGING_PROJECT") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingProject", }, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingProjectList", }, ) } if util.IsModuleEnabled("MESSAGING_ADDRESS") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingAddress", }, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingAddressList", }, ) } if util.IsModuleEnabled("MESSAGING_ENDPOINT") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingEndpoint", }, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingEndpointList", }, ) } if util.IsModuleEnabled("MESSAGING_PLAN") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingPlan", }, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingPlanList", }, ) } if util.IsModuleEnabled("MESSAGING_ADDRESS_PLAN") { globalGvks = append(globalGvks, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingAddressPlan", }, schema.GroupVersionKind{ Group: "enmasse.io", Version: "v1", Kind: "MessagingAddressPlanList", }, ) } // Create a new Cmd to provide shared dependencies and start components mgr, err := manager.New(cfg, manager.Options{ Namespace: namespace, MetricsBindAddress: fmt.Sprintf("%s:%d", metricsHost, metricsPort), NewCache: cache.NewDelegateCacheBuilder(namespace, globalGvks...), }) if err != nil { log.Error(err, "Failed to create manager") os.Exit(1) } log.Info("Registering components...") // register APIs if err := api.Install(mgr.GetScheme()); err != nil { log.Error(err, "Failed to register OpenShift schema") os.Exit(1) } if err := enmassescheme.AddToScheme(mgr.GetScheme()); err != nil { log.Error(err, "Failed to register EnMasse schema") os.Exit(1) } if err := monitoringv1.AddToScheme(mgr.GetScheme()); err != nil { log.Error(err, "Failed to register monitoring schema") os.Exit(1) } if err := controller.CheckUpgrade(mgr); err != nil { log.Error(err, "Failed to upgrade") os.Exit(1) } // register controller if err := controller.AddToManager(mgr); err != nil { log.Error(err, "Failed to register controller") os.Exit(1) } // Add the Metrics Service if monitoringEnabled { monitoring.StartIoTMetrics(mgr) addMetrics(ctx, cfg, namespace) } log.Info("Starting the operator") // Start the Cmd if err := mgr.Start(signals.SetupSignalHandler()); err != nil { log.Error(err, "manager exited non-zero") os.Exit(1) } } // the Prometheus operator func addMetrics(ctx context.Context, cfg *rest.Config, namespace string) { if err := serveCRMetrics(cfg); err != nil { log.Info("Could not generate and serve custom resource metrics", "error", err.Error()) } // Add to the below struct any other metrics ports you want to expose. servicePorts := []v1.ServicePort{ {Port: metricsPort, Name: metrics.OperatorPortName, Protocol: v1.ProtocolTCP, TargetPort: intstr.IntOrString{Type: intstr.Int, IntVal: metricsPort}}, {Port: operatorMetricsPort, Name: metrics.CRPortName, Protocol: v1.ProtocolTCP, TargetPort: intstr.IntOrString{Type: intstr.Int, IntVal: operatorMetricsPort}}, } // Create Service object to expose the metrics port(s). service, err := metrics.CreateMetricsService(ctx, cfg, servicePorts) if err != nil { log.Info("Could not create metrics Service", "error", err.Error()) } // Adding the monitoring-key:middleware to the operator service which will get propagated to the serviceMonitor err = addMonitoringKeyLabelToOperatorService(ctx, cfg, service) if err != nil { log.Error(err, "Could not add monitoring-key label to operator metrics Service") } // CreateServiceMonitors will automatically create the prometheus-operator ServiceMonitor resources // necessary to configure Prometheus to scrape metrics from this operator. services := []*v1.Service{service} _, err = metrics.CreateServiceMonitors(cfg, namespace, services, func(monitor *monitoringv1.ServiceMonitor) error { for i, _ := range monitor.Spec.Endpoints { monitor.Spec.Endpoints[i].MetricRelabelConfigs = []*monitoringv1.RelabelConfig{ &monitoringv1.RelabelConfig{ SourceLabels: []string{ "__name__", }, TargetLabel: "__name__", Replacement: "enmasse_${1}", }, } } return nil }) if err != nil { log.Info("Could not create ServiceMonitor object", "error", err.Error()) // If this operator is deployed to a cluster without the prometheus-operator running, it will return // ErrServiceMonitorNotPresent, which can be used to safely skip ServiceMonitor creation. if err == metrics.ErrServiceMonitorNotPresent { log.Info("Install prometheus-operator in your cluster to create ServiceMonitor objects", "error", err.Error()) } } } // serveCRMetrics gets the Operator/CustomResource GVKs and generates metrics based on those types. // It serves those metrics on "http://metricsHost:operatorMetricsPort". func serveCRMetrics(cfg *rest.Config) error { // Below function returns all GVKs for EnMasse. allGVK, err := k8sutil.GetGVKsFromAddToScheme(enmassescheme.AddToScheme) if err != nil { return err } filteredGVK := make([]schema.GroupVersionKind, 0) for _, gvk := range allGVK { if (!util.IsModuleEnabled("MESSAGING_INFRASTRUCTURE") && strings.HasPrefix(gvk.Kind, "MessagingInfrastructure")) || (!util.IsModuleEnabled("MESSAGING_PROJECT") && strings.HasPrefix(gvk.Kind, "MessagingProject")) || (!util.IsModuleEnabled("MESSAGING_ENDPOINT") && strings.HasPrefix(gvk.Kind, "MessagingEndpoint")) || (!util.IsModuleEnabled("MESSAGING_ADDRESS") && strings.HasPrefix(gvk.Kind, "MessagingAddress")) || (!util.IsModuleEnabled("MESSAGING_PLAN") && strings.HasPrefix(gvk.Kind, "MessagingPlan")) || (!util.IsModuleEnabled("MESSAGING_ADDRESS_PLAN") && strings.HasPrefix(gvk.Kind, "MessagingAddressPlan")) { log.Info("Skipping adding metric because module is not enabled", "gkv", gvk) } else { filteredGVK = append(filteredGVK, gvk) } } // Get the namespace the operator is currently deployed in. operatorNs, err := k8sutil.GetOperatorNamespace() if err != nil { return err } // To generate metrics in other namespaces, add the values below. ns := []string{operatorNs} // Generate and serve custom resource specific metrics. err = kubemetrics.GenerateAndServeCRMetrics(cfg, ns, filteredGVK, metricsHost, operatorMetricsPort) if err != nil { return err } return nil } func addMonitoringKeyLabelToOperatorService(ctx context.Context, cfg *rest.Config, service *v1.Service) error { if service == nil { return fmt.Errorf("service doesn't exist") } kclient, err := client.New(cfg, client.Options{}) if err != nil { return err } updatedLabels := map[string]string{"monitoring-key": "middleware"} for k, v := range service.ObjectMeta.Labels { updatedLabels[k] = v } service.ObjectMeta.Labels = updatedLabels err = kclient.Update(ctx, service) if err != nil { return err } return nil } func installMonitoring(ctx context.Context, client client.Client) error { log.Info("Installing monitoring resources") params := map[string]string{"Namespace": os.Getenv("NAMESPACE")} templateHelper := util.NewTemplateHelper(params) for _, template := range templateHelper.TemplateList { resource, err := templateHelper.CreateResource(template) if err != nil { return fmt.Errorf("createResource failed: %s", err) } err = client.Create(ctx, resource) if err != nil { if !kerrors.IsAlreadyExists(err) { return fmt.Errorf("error creating resource: %s", err) } } } return nil }
[ "\"NAMESPACE\"", "\"NAMESPACE\"" ]
[]
[ "NAMESPACE" ]
[]
["NAMESPACE"]
go
1
0
tests/test_multiplexer.py
# -*- coding: utf-8 -*- # ------------------------------------------------------------------------------ # # Copyright 2018-2019 Fetch.AI Limited # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # ------------------------------------------------------------------------------ """This module contains the tests for the Multiplexer.""" import asyncio import logging import os import shutil import sys import tempfile import time import unittest.mock from pathlib import Path from threading import Thread from unittest import mock from unittest.mock import MagicMock, Mock, call, patch import pytest from pexpect.exceptions import EOF # type: ignore import aea from aea.cli.core import cli from aea.configurations.constants import DEFAULT_LEDGER from aea.connections.base import ConnectionStates from aea.helpers.exception_policy import ExceptionPolicyEnum from aea.identity.base import Identity from aea.mail.base import AEAConnectionError, Envelope, EnvelopeContext from aea.multiplexer import AsyncMultiplexer, InBox, Multiplexer, OutBox from aea.test_tools.click_testing import CliRunner from packages.fetchai.connections.local.connection import LocalNode from packages.fetchai.connections.p2p_libp2p.connection import ( PUBLIC_ID as P2P_PUBLIC_ID, ) from packages.fetchai.connections.stub.connection import PUBLIC_ID as STUB_CONNECTION_ID from packages.fetchai.protocols.default.message import DefaultMessage from packages.fetchai.protocols.fipa.message import FipaMessage from .conftest import ( AUTHOR, CLI_LOG_OPTION, ROOT_DIR, UNKNOWN_CONNECTION_PUBLIC_ID, UNKNOWN_PROTOCOL_PUBLIC_ID, _make_dummy_connection, _make_local_connection, _make_stub_connection, logger, ) from tests.common.pexpect_popen import PexpectWrapper from tests.common.utils import wait_for_condition UnknownProtocolMock = Mock() UnknownProtocolMock.protocol_id = UNKNOWN_PROTOCOL_PUBLIC_ID UnknownProtocolMock.protocol_specification_id = UNKNOWN_PROTOCOL_PUBLIC_ID @pytest.mark.asyncio async def test_receiving_loop_terminated(): """Test that connecting twice the multiplexer behaves correctly.""" multiplexer = Multiplexer([_make_dummy_connection()]) multiplexer.connect() with unittest.mock.patch.object(multiplexer.logger, "debug") as mock_logger_debug: multiplexer.connection_status.set(ConnectionStates.disconnected) await multiplexer._receiving_loop() mock_logger_debug.assert_called_with("Receiving loop terminated.") multiplexer.connection_status.set(ConnectionStates.connected) multiplexer.disconnect() def test_connect_twice(): """Test that connecting twice the multiplexer behaves correctly.""" multiplexer = Multiplexer([_make_dummy_connection()]) assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.disconnect() def test_disconnect_twice(): """Test that connecting twice the multiplexer behaves correctly.""" multiplexer = Multiplexer([_make_dummy_connection()]) assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.disconnect() multiplexer.disconnect() def test_connect_twice_with_loop(): """Test that connecting twice the multiplexer behaves correctly.""" running_loop = asyncio.new_event_loop() thread_loop = Thread(target=running_loop.run_forever) thread_loop.start() try: multiplexer = Multiplexer([_make_dummy_connection()], loop=running_loop) with unittest.mock.patch.object( multiplexer.logger, "debug" ) as mock_logger_debug: assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected mock_logger_debug.assert_called_with("Multiplexer already connected.") multiplexer.disconnect() running_loop.call_soon_threadsafe(running_loop.stop) finally: thread_loop.join() @pytest.mark.asyncio async def test_connect_twice_a_single_connection(): """Test that connecting twice a single connection behaves correctly.""" connection = _make_dummy_connection() multiplexer = Multiplexer([connection]) assert not multiplexer.connection_status.is_connected await multiplexer._connect_one(connection.connection_id) with unittest.mock.patch.object(multiplexer.logger, "debug") as mock_logger_debug: await multiplexer._connect_one(connection.connection_id) mock_logger_debug.assert_called_with( "Connection fetchai/dummy:0.1.0 already established." ) await multiplexer._disconnect_one(connection.connection_id) @pytest.mark.asyncio async def test_run_bad_conneect(): """Test that connecting twice a single connection behaves correctly.""" connection = _make_dummy_connection() multiplexer = AsyncMultiplexer([connection]) f = asyncio.Future() f.set_result(None) with unittest.mock.patch.object(multiplexer, "connect", return_value=f): with pytest.raises(ValueError, match="Multiplexer is not connected properly."): await multiplexer.run() def test_multiplexer_connect_all_raises_error(): """Test the case when the multiplexer raises an exception while connecting.""" multiplexer = Multiplexer([_make_dummy_connection()]) with unittest.mock.patch.object(multiplexer, "_connect_all", side_effect=Exception): with pytest.raises( AEAConnectionError, match="Failed to connect the multiplexer." ): multiplexer.connect() multiplexer.disconnect() def test_multiplexer_connect_one_raises_error_many_connections(): """Test the case when the multiplexer raises an exception while attempting the connection of one connection.""" node = LocalNode() tmpdir = Path(tempfile.mkdtemp()) d = tmpdir / "test_stub" d.mkdir(parents=True) input_file_path = d / "input_file.csv" output_file_path = d / "input_file.csv" connection_1 = _make_local_connection("my_addr", node) connection_2 = _make_stub_connection(input_file_path, output_file_path) connection_3 = _make_dummy_connection() multiplexer = Multiplexer([connection_1, connection_2, connection_3]) assert not connection_1.is_connected assert not connection_2.is_connected assert not connection_3.is_connected with unittest.mock.patch.object(connection_3, "connect", side_effect=Exception): with pytest.raises( AEAConnectionError, match="Failed to connect the multiplexer." ): multiplexer.connect() assert not connection_1.is_connected assert not connection_2.is_connected assert not connection_3.is_connected multiplexer.disconnect() try: shutil.rmtree(tmpdir) except OSError as e: logger.warning("Couldn't delete {}".format(tmpdir)) logger.exception(e) @pytest.mark.asyncio async def test_disconnect_twice_a_single_connection(): """Test that connecting twice a single connection behaves correctly.""" connection = _make_dummy_connection() multiplexer = Multiplexer([_make_dummy_connection()]) assert not multiplexer.connection_status.is_connected with unittest.mock.patch.object(multiplexer.logger, "debug") as mock_logger_debug: await multiplexer._disconnect_one(connection.connection_id) mock_logger_debug.assert_called_with( "Connection fetchai/dummy:0.1.0 already disconnected." ) def test_multiplexer_disconnect_all_raises_error(): """Test the case when the multiplexer raises an exception while disconnecting.""" multiplexer = Multiplexer([_make_dummy_connection()]) multiplexer.connect() assert multiplexer.connection_status.is_connected with unittest.mock.patch.object( multiplexer, "_disconnect_all", side_effect=Exception ): with pytest.raises( AEAConnectionError, match="Failed to disconnect the multiplexer." ): multiplexer.disconnect() # # do the true disconnection - for clean the test up assert multiplexer.connection_status.is_disconnecting multiplexer.disconnect() assert multiplexer.connection_status.is_disconnected @pytest.mark.asyncio async def test_multiplexer_disconnect_one_raises_error_many_connections(): """Test the case when the multiplexer raises an exception while attempting the disconnection of one connection.""" with LocalNode() as node: tmpdir = Path(tempfile.mkdtemp()) d = tmpdir / "test_stub" d.mkdir(parents=True) input_file_path = d / "input_file.csv" output_file_path = d / "input_file.csv" connection_1 = _make_local_connection("my_addr", node) connection_2 = _make_stub_connection(input_file_path, output_file_path) connection_3 = _make_dummy_connection() multiplexer = Multiplexer([connection_1, connection_2, connection_3]) assert not connection_1.is_connected assert not connection_2.is_connected assert not connection_3.is_connected multiplexer.connect() assert connection_1.is_connected assert connection_2.is_connected assert connection_3.is_connected with unittest.mock.patch.object( connection_3, "disconnect", side_effect=Exception ): with pytest.raises( AEAConnectionError, match="Failed to disconnect the multiplexer." ): multiplexer.disconnect() assert not connection_1.is_connected assert not connection_2.is_connected assert connection_3.is_connected # clean the test up. await connection_3.disconnect() multiplexer.disconnect() try: shutil.rmtree(tmpdir) except OSError as e: logger.warning("Couldn't delete {}".format(tmpdir)) logger.exception(e) @pytest.mark.asyncio async def test_sending_loop_does_not_start_if_multiplexer_not_connected(): """Test that the sending loop is stopped does not start if the multiplexer is not connected.""" multiplexer = Multiplexer([_make_dummy_connection()]) with unittest.mock.patch.object(multiplexer.logger, "debug") as mock_logger_debug: await multiplexer._send_loop() mock_logger_debug.assert_called_with( "Sending loop not started. The multiplexer is not connected." ) @pytest.mark.asyncio async def test_sending_loop_cancelled(): """Test the case when the sending loop is cancelled.""" multiplexer = Multiplexer([_make_dummy_connection()]) multiplexer.connect() await asyncio.sleep(0.1) with unittest.mock.patch.object(multiplexer.logger, "debug") as mock_logger_debug: multiplexer.disconnect() mock_logger_debug.assert_any_call("Sending loop cancelled.") @pytest.mark.asyncio async def test_receiving_loop_raises_exception(): """Test the case when an error occurs when a receive is started.""" connection = _make_dummy_connection() multiplexer = Multiplexer([connection]) with unittest.mock.patch("asyncio.wait", side_effect=Exception("a weird error.")): with unittest.mock.patch.object( multiplexer.logger, "error" ) as mock_logger_error: multiplexer.connect() time.sleep(0.1) mock_logger_error.assert_called_with( "Error in the receiving loop: a weird error.", exc_info=True ) multiplexer.disconnect() @pytest.mark.asyncio async def test_send_envelope_with_non_registered_connection(): """Test that sending an envelope with an unregistered connection raises an exception.""" connection = _make_dummy_connection() multiplexer = Multiplexer([connection], protocols=[DefaultProtocolMock]) multiplexer.connect() envelope = Envelope( to="", sender="", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", context=EnvelopeContext(connection_id=UNKNOWN_CONNECTION_PUBLIC_ID), ) with unittest.mock.patch.object( multiplexer.logger, "warning" ) as mock_logger_warning: await multiplexer._send(envelope) mock_logger_warning.assert_called_with( f"Dropping envelope, no connection available for sending: {envelope}" ) multiplexer.disconnect() @pytest.mark.asyncio async def test_send_envelope_when_no_connection(): """Test that sending an envelope with no connection logs a warning.""" multiplexer = Multiplexer([], protocols=[DefaultProtocolMock]) multiplexer.connect() envelope = Envelope( to="", sender="", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", ) with unittest.mock.patch.object( multiplexer.logger, "warning" ) as mock_logger_warning: await multiplexer._send(envelope) mock_logger_warning.assert_called_with( f"Dropping envelope, no connection available for sending: {envelope}" ) multiplexer.disconnect() def test_send_envelope_error_is_logged_by_send_loop(): """Test that the AEAConnectionError in the '_send' method is logged by the '_send_loop'.""" connection = _make_dummy_connection() multiplexer = Multiplexer([connection], protocols=[DefaultProtocolMock]) multiplexer.connect() fake_connection_id = UNKNOWN_CONNECTION_PUBLIC_ID envelope = Envelope( to="", sender="", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", context=EnvelopeContext(connection_id=fake_connection_id), ) with unittest.mock.patch.object(multiplexer.logger, "error") as mock_logger_error: multiplexer.put(envelope) time.sleep(0.1) mock_logger_error.assert_called_with( "No connection registered with id: {}".format(fake_connection_id) ) multiplexer.disconnect() def test_get_from_multiplexer_when_empty(): """Test that getting an envelope from the multiplexer when the input queue is empty raises an exception.""" connection = _make_dummy_connection() multiplexer = Multiplexer([connection]) with pytest.raises(aea.mail.base.Empty): multiplexer.get() def test_send_message_no_supported_protocol(): """Test the case when we send an envelope with a specific connection that does not support the protocol.""" with LocalNode() as node: identity_1 = Identity("identity", address="address_1") connection_1 = _make_local_connection( identity_1.address, node, restricted_to_protocols={DefaultMessage.protocol_id}, excluded_protocols={FipaMessage.protocol_id}, ) multiplexer = Multiplexer( [connection_1], protocols=[DefaultMessage, FipaMessage, UnknownProtocolMock] ) multiplexer.connect() with mock.patch.object(multiplexer.logger, "warning") as mock_logger_warning: envelope = Envelope( to=identity_1.address, sender=identity_1.address, protocol_specification_id=FipaMessage.protocol_specification_id, message=b"some bytes", ) multiplexer.put(envelope) time.sleep(0.5) mock_logger_warning.assert_called_with( "Connection {} does not support protocol {}. It is explicitly excluded.".format( connection_1.connection_id, FipaMessage.protocol_id ) ) with mock.patch.object(multiplexer.logger, "warning") as mock_logger_warning: envelope = Envelope( to=identity_1.address, sender=identity_1.address, protocol_specification_id=UnknownProtocolMock.protocol_specification_id, message=b"some bytes", ) multiplexer.put(envelope) time.sleep(0.5) mock_logger_warning.assert_called_with( "Connection {} does not support protocol {}. The connection is restricted to protocols in {}.".format( connection_1.connection_id, UnknownProtocolMock.protocol_id, connection_1.restricted_to_protocols, ) ) multiplexer.disconnect() def test_protocol_not_resolved(): """Test multiplexer raises ValueError on protocol not resolved.""" multiplexer = Multiplexer([Mock()]) envelope = Envelope( to="1", sender="2", protocol_specification_id=FipaMessage.protocol_specification_id, message=b"some bytes", ) with pytest.raises(ValueError): multiplexer._get_protocol_id_for_envelope(envelope) def test_autoset_default_connection(): """Set default connection automatically.""" connection_1 = _make_dummy_connection() connection_2 = _make_dummy_connection() connections = [connection_1, connection_2] multiplexer = Multiplexer(connections) multiplexer._default_connection = None multiplexer._set_default_connection_if_none() assert multiplexer._default_connection == connections[0] def test__get_connection(): """Test the method _get_connection.""" connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = Multiplexer(connections) conn_ = multiplexer._get_connection(connection_1.connection_id.to_any()) assert conn_ == connection_1 @pytest.mark.asyncio async def test_disconnect_when_not_connected(): """Test disconnect when not connected.""" connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer(connections) with patch.object(multiplexer, "_disconnect_all") as disconnect_all_mocked: await multiplexer.disconnect() disconnect_all_mocked.assert_not_called() @pytest.mark.asyncio async def test_exit_on_none_envelope(): """Test sending task exit on None envelope.""" connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer(connections, loop=asyncio.get_event_loop()) try: await multiplexer.connect() assert multiplexer.is_connected multiplexer.put(None) await asyncio.sleep(0.5) assert multiplexer._send_loop_task.done() finally: await multiplexer.disconnect() @pytest.mark.asyncio async def test_inbox_outbox(): """Test InBox OutBox objects.""" connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer(connections, loop=asyncio.get_event_loop()) msg = DefaultMessage(performative=DefaultMessage.Performative.BYTES, content=b"",) msg.to = "to" msg.sender = "sender" envelope = Envelope(to="to", sender="sender", message=msg,) try: await multiplexer.connect() inbox = InBox(multiplexer) outbox = OutBox(multiplexer) assert inbox.empty() assert outbox.empty() outbox.put(envelope) received = await inbox.async_get() assert received == envelope assert inbox.empty() assert outbox.empty() outbox.put_message(msg) await inbox.async_wait() received = inbox.get_nowait() assert received == envelope finally: await multiplexer.disconnect() @pytest.mark.asyncio async def test_threaded_mode(): """Test InBox OutBox objects in threaded mode.""" connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer(connections, threaded=True) msg = DefaultMessage(performative=DefaultMessage.Performative.BYTES, content=b"",) msg.to = "to" msg.sender = "sender" envelope = Envelope(to="to", sender="sender", message=msg) try: await multiplexer.connect() await asyncio.sleep(0.5) inbox = InBox(multiplexer) outbox = OutBox(multiplexer) assert inbox.empty() assert outbox.empty() outbox.put(envelope) received = await inbox.async_get() assert received == envelope assert inbox.empty() assert outbox.empty() outbox.put_message(msg) await inbox.async_wait() received = inbox.get_nowait() assert received == envelope finally: await multiplexer.disconnect() @pytest.mark.asyncio async def test_outbox_negative(): """Test InBox OutBox objects.""" connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer(connections, loop=asyncio.get_event_loop()) msg = DefaultMessage(performative=DefaultMessage.Performative.BYTES, content=b"",) context = EnvelopeContext(connection_id=connection_1.connection_id) envelope = Envelope( to="to", sender="sender", protocol_specification_id=msg.protocol_specification_id, message=b"", context=context, ) try: await multiplexer.connect() outbox = OutBox(multiplexer) assert outbox.empty() with pytest.raises(ValueError) as execinfo: outbox.put(envelope) assert ( str(execinfo.value) == "Only Message type allowed in envelope message field when putting into outbox." ) assert outbox.empty() with pytest.raises(ValueError) as execinfo: outbox.put_message("") assert str(execinfo.value) == "Provided message not of type Message." assert outbox.empty() with pytest.raises(ValueError) as execinfo: outbox.put_message(msg) assert str(execinfo.value) == "Provided message has message.to not set." assert outbox.empty() msg.to = "to" with pytest.raises(ValueError) as execinfo: outbox.put_message(msg) assert str(execinfo.value) == "Provided message has message.sender not set." finally: await multiplexer.disconnect() DefaultProtocolMock = Mock() DefaultProtocolMock.protocol_id = DefaultMessage.protocol_id DefaultProtocolMock.protocol_specification_id = DefaultMessage.protocol_specification_id @pytest.mark.asyncio async def test_default_route_applied(caplog): """Test default route is selected automatically.""" logger = logging.getLogger("aea.multiplexer") with caplog.at_level(logging.DEBUG, logger="aea.multiplexer"): connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer( connections, loop=asyncio.get_event_loop(), protocols=[DefaultProtocolMock] ) multiplexer.logger = logger envelope = Envelope( to="", sender="", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", context=EnvelopeContext(), ) multiplexer.default_routing = { DefaultMessage.protocol_id: connection_1.connection_id } try: await multiplexer.connect() inbox = InBox(multiplexer) outbox = InBox(multiplexer) assert inbox.empty() assert outbox.empty() multiplexer.put(envelope) await outbox.async_get() finally: await multiplexer.disconnect() assert "Using default routing:" in caplog.text @pytest.mark.asyncio async def test_connection_id_in_to_field_detected(caplog): """Test to field is parsed correctly and used for routing.""" logger = logging.getLogger("aea.multiplexer") with caplog.at_level(logging.DEBUG, logger="aea.multiplexer"): connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer( connections, loop=asyncio.get_event_loop(), protocols=[DefaultProtocolMock] ) multiplexer.logger = logger envelope = Envelope( to=str(connection_1.connection_id), sender="some_author/some_skill:0.1.0", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", ) try: await multiplexer.connect() inbox = InBox(multiplexer) outbox = InBox(multiplexer) assert inbox.empty() assert outbox.empty() multiplexer.put(envelope) await outbox.async_get() finally: await multiplexer.disconnect() assert "Using envelope `to` field as connection_id:" in caplog.text @pytest.mark.asyncio async def test_routing_helper_applied(caplog): """Test the routing helper is used for routing.""" logger = logging.getLogger("aea.multiplexer") with caplog.at_level(logging.DEBUG, logger="aea.multiplexer"): connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer( connections, loop=asyncio.get_event_loop(), protocols=[DefaultProtocolMock] ) multiplexer.logger = logger envelope = Envelope( to="test", sender="", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", ) multiplexer._routing_helper[envelope.to] = connection_1.connection_id try: await multiplexer.connect() inbox = InBox(multiplexer) outbox = InBox(multiplexer) assert inbox.empty() assert outbox.empty() multiplexer.put(envelope) await outbox.async_get() finally: await multiplexer.disconnect() assert ( f"Using routing helper with connection_id: {connection_1.connection_id}" in caplog.text ) def test_multiplexer_setup(): """Test multiplexer setup to set connections.""" node = LocalNode() tmpdir = Path(tempfile.mkdtemp()) d = tmpdir / "test_stub" d.mkdir(parents=True) input_file_path = d / "input_file.csv" output_file_path = d / "input_file.csv" connection_1 = _make_local_connection("my_addr", node) connection_2 = _make_stub_connection(input_file_path, output_file_path) connection_3 = _make_dummy_connection() connections = [connection_1, connection_2, connection_3] multiplexer = Multiplexer([]) with unittest.mock.patch.object(multiplexer.logger, "debug") as mock_logger_debug: multiplexer._connection_consistency_checks() mock_logger_debug.assert_called_with("List of connections is empty.") multiplexer._setup(connections, default_routing=None) multiplexer._connection_consistency_checks() class TestExceptionHandlingOnConnectionSend: """Test exception handling policy on connection.send.""" def setup(self): """Set up test case.""" self.connection = _make_dummy_connection() self.multiplexer = Multiplexer( [self.connection], protocols=[DefaultProtocolMock] ) self.multiplexer.connect() self.envelope = Envelope( to="", sender="", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", context=EnvelopeContext(connection_id=self.connection.connection_id), ) self.exception = ValueError("expected") def teardown(self): """Tear down test case.""" self.multiplexer.disconnect() def test_log_policy(self): """Test just log exception.""" with patch.object(self.connection, "send", side_effect=self.exception): self.multiplexer._exception_policy = ExceptionPolicyEnum.just_log self.multiplexer.put(self.envelope) time.sleep(1) assert not self.multiplexer._send_loop_task.done() def test_propagate_policy(self): """Test propagate exception.""" assert self.multiplexer._exception_policy == ExceptionPolicyEnum.propagate with patch.object(self.connection, "send", side_effect=self.exception): self.multiplexer.put(self.envelope) time.sleep(1) wait_for_condition( lambda: self.multiplexer._send_loop_task.done(), timeout=5 ) assert self.multiplexer._send_loop_task.exception() == self.exception def test_stop_policy(self): """Test stop multiplexer on exception.""" with patch.object(self.connection, "send", side_effect=self.exception): self.multiplexer._exception_policy = ExceptionPolicyEnum.stop_and_exit self.multiplexer.put(self.envelope) time.sleep(1) wait_for_condition( lambda: self.multiplexer.connection_status.is_disconnected, timeout=5 ) def test_disconnect_order(self): """Test disconnect order: tasks first, disconnect_all next.""" parent = MagicMock() async def fn(): return with patch.object( self.multiplexer, "_stop_receive_send_loops", return_value=fn() ) as stop_loops, patch.object( self.multiplexer, "_disconnect_all", return_value=fn() ) as disconnect_all, patch.object( self.multiplexer, "_check_and_set_disconnected_state" ) as check_and_set_disconnected_state: parent.attach_mock(stop_loops, "stop_loops") parent.attach_mock(disconnect_all, "disconnect_all") parent.attach_mock( check_and_set_disconnected_state, "check_and_set_disconnected_state" ) self.multiplexer.disconnect() assert parent.mock_calls == [ call.stop_loops(), call.disconnect_all(), call.check_and_set_disconnected_state(), ] class TestMultiplexerDisconnectsOnTermination: # pylint: disable=attribute-defined-outside-init """Test multiplexer disconnects on agent process keyboard interrupted.""" def setup(self): """Set the test up.""" self.proc = None self.runner = CliRunner() self.agent_name = "myagent" self.cwd = os.getcwd() self.t = tempfile.mkdtemp() shutil.copytree(Path(ROOT_DIR, "packages"), Path(self.t, "packages")) os.chdir(self.t) self.key_path = os.path.join(self.t, "fetchai_private_key.txt") self.conn_key_path = os.path.join(self.t, "conn_private_key.txt") result = self.runner.invoke( cli, [*CLI_LOG_OPTION, "init", "--local", "--author", AUTHOR] ) assert result.exit_code == 0 result = self.runner.invoke( cli, [*CLI_LOG_OPTION, "create", "--local", self.agent_name] ) assert result.exit_code == 0 os.chdir(Path(self.t, self.agent_name)) result = self.runner.invoke( cli, [*CLI_LOG_OPTION, "generate-key", DEFAULT_LEDGER, self.key_path] ) assert result.exit_code == 0, result.stdout_bytes result = self.runner.invoke( cli, [*CLI_LOG_OPTION, "add-key", DEFAULT_LEDGER, self.key_path] ) assert result.exit_code == 0, result.stdout_bytes def test_multiplexer_disconnected_on_early_interruption(self): """Test multiplexer disconnected properly on termination before connected.""" result = self.runner.invoke( cli, [*CLI_LOG_OPTION, "add", "--local", "connection", str(P2P_PUBLIC_ID)] ) assert result.exit_code == 0, result.stdout_bytes result = self.runner.invoke(cli, [*CLI_LOG_OPTION, "build"]) assert result.exit_code == 0, result.stdout_bytes result = self.runner.invoke( cli, [*CLI_LOG_OPTION, "generate-key", DEFAULT_LEDGER, self.conn_key_path] ) assert result.exit_code == 0, result.stdout_bytes result = self.runner.invoke( cli, [ *CLI_LOG_OPTION, "add-key", DEFAULT_LEDGER, self.conn_key_path, "--connection", ], ) assert result.exit_code == 0, result.stdout_bytes result = self.runner.invoke(cli, [*CLI_LOG_OPTION, "issue-certificates"]) assert result.exit_code == 0, result.stdout_bytes self.proc = PexpectWrapper( # nosec [sys.executable, "-m", "aea.cli", "-v", "DEBUG", "run"], env=os.environ, maxread=10000, encoding="utf-8", logfile=sys.stdout, ) self.proc.expect_all( ["Starting libp2p node..."], timeout=50, ) self.proc.control_c() self.proc.expect_all( ["Multiplexer .*disconnected."], timeout=20, strict=False, ) self.proc.expect_all( [EOF], timeout=20, ) def test_multiplexer_disconnected_on_termination_after_connected_no_connection( self, ): """Test multiplexer disconnected properly on termination after connected.""" self.proc = PexpectWrapper( # nosec [sys.executable, "-m", "aea.cli", "-v", "DEBUG", "run"], env=os.environ, maxread=10000, encoding="utf-8", logfile=sys.stdout, ) self.proc.expect_all( ["Start processing messages..."], timeout=20, ) self.proc.control_c() self.proc.expect_all( ["Multiplexer disconnecting...", "Multiplexer disconnected.", EOF], timeout=20, ) def test_multiplexer_disconnected_on_termination_after_connected_one_connection( self, ): """Test multiplexer disconnected properly on termination after connected.""" result = self.runner.invoke( cli, [*CLI_LOG_OPTION, "add", "--local", "connection", str(STUB_CONNECTION_ID)], ) assert result.exit_code == 0, result.stdout_bytes self.proc = PexpectWrapper( # nosec [sys.executable, "-m", "aea.cli", "-v", "DEBUG", "run"], env=os.environ, maxread=10000, encoding="utf-8", logfile=sys.stdout, ) self.proc.expect_all( ["Start processing messages..."], timeout=20, ) self.proc.control_c() self.proc.expect_all( ["Multiplexer disconnecting...", "Multiplexer disconnected.", EOF], timeout=20, ) def teardown(self): """Tear the test down.""" if self.proc: self.proc.wait_to_complete(10) os.chdir(self.cwd) try: shutil.rmtree(self.t) except (OSError, IOError): pass def test_multiplexer_setup_replaces_connections(): """Test proper connections reset on setup call.""" m = AsyncMultiplexer([MagicMock(), MagicMock(), MagicMock()]) assert len(m._id_to_connection) == 3 assert len(m._connections) == 3 m._setup([MagicMock()], MagicMock()) assert len(m._id_to_connection) == 1 assert len(m._connections) == 1 def test_connect_after_disconnect_sync(): """Test connect-disconnect-connect again for threaded multiplexer.""" multiplexer = Multiplexer([_make_dummy_connection()]) assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.disconnect() assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.disconnect() assert not multiplexer.connection_status.is_connected @pytest.mark.asyncio async def test_connect_after_disconnect_async(): """Test connect-disconnect-connect again for async multiplexer.""" multiplexer = AsyncMultiplexer([_make_dummy_connection()]) assert not multiplexer.connection_status.is_connected await multiplexer.connect() assert multiplexer.connection_status.is_connected await multiplexer.disconnect() assert not multiplexer.connection_status.is_connected await multiplexer.connect() assert multiplexer.connection_status.is_connected await multiplexer.disconnect() assert not multiplexer.connection_status.is_connected @pytest.mark.asyncio async def test_connection_timeouts(): """Test connect,send, disconnect timeouts for connections.""" async def slow_fn(*asrgs, **kwargs): await asyncio.sleep(100) connection = _make_dummy_connection() envelope = Envelope( to="", sender="", message=DefaultMessage(performative=DefaultMessage.Performative.BYTES), context=EnvelopeContext(connection_id=connection.connection_id), ) connection = _make_dummy_connection() connection.connect = slow_fn multiplexer = AsyncMultiplexer([connection]) multiplexer.CONNECT_TIMEOUT = 0.1 with pytest.raises(AEAConnectionError, match=r"TimeoutError"): await multiplexer.connect() connection = _make_dummy_connection() connection.send = slow_fn multiplexer = AsyncMultiplexer([connection]) multiplexer.SEND_TIMEOUT = 0.1 await multiplexer.connect() with pytest.raises(asyncio.TimeoutError): await multiplexer._send(envelope) await multiplexer.disconnect() connection = _make_dummy_connection() connection.disconnect = slow_fn multiplexer = AsyncMultiplexer([connection]) multiplexer.DISCONNECT_TIMEOUT = 0.1 await multiplexer.connect() with pytest.raises( AEAConnectionError, match=f"Failed to disconnect multiplexer, some connections are not disconnected.*{str(connection.connection_id)}", ): await multiplexer.disconnect() @pytest.mark.asyncio async def test_stops_on_connectionerror_during_connect(): """Test multiplexer stopped and reraise exception on connect fails on conection.connect with AEAConnectionError.""" connection = _make_dummy_connection() multiplexer = AsyncMultiplexer([connection]) with patch.object( connection, "connect", side_effect=AEAConnectionError("expected") ): with pytest.raises(AEAConnectionError, match=r"expected"): await multiplexer.connect() assert multiplexer.connection_status.is_disconnected
[]
[]
[]
[]
[]
python
0
0
lib-src/lv2/suil/waflib/Tools/c_osx.py
#!/usr/bin/env python # encoding: utf-8 # Thomas Nagy 2008-2018 (ita) """ MacOSX related tools """ import os, shutil, platform from waflib import Task, Utils from waflib.TaskGen import taskgen_method, feature, after_method, before_method app_info = ''' <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd"> <plist version="0.9"> <dict> <key>CFBundlePackageType</key> <string>APPL</string> <key>CFBundleGetInfoString</key> <string>Created by Waf</string> <key>CFBundleSignature</key> <string>????</string> <key>NOTE</key> <string>THIS IS A GENERATED FILE, DO NOT MODIFY</string> <key>CFBundleExecutable</key> <string>{app_name}</string> </dict> </plist> ''' """ plist template """ @feature('c', 'cxx') def set_macosx_deployment_target(self): """ see WAF issue 285 and also and also http://trac.macports.org/ticket/17059 """ if self.env.MACOSX_DEPLOYMENT_TARGET: os.environ['MACOSX_DEPLOYMENT_TARGET'] = self.env.MACOSX_DEPLOYMENT_TARGET elif 'MACOSX_DEPLOYMENT_TARGET' not in os.environ: if Utils.unversioned_sys_platform() == 'darwin': os.environ['MACOSX_DEPLOYMENT_TARGET'] = '.'.join(platform.mac_ver()[0].split('.')[:2]) @taskgen_method def create_bundle_dirs(self, name, out): """ Creates bundle folders, used by :py:func:`create_task_macplist` and :py:func:`create_task_macapp` """ dir = out.parent.find_or_declare(name) dir.mkdir() macos = dir.find_or_declare(['Contents', 'MacOS']) macos.mkdir() return dir def bundle_name_for_output(out): name = out.name k = name.rfind('.') if k >= 0: name = name[:k] + '.app' else: name = name + '.app' return name @feature('cprogram', 'cxxprogram') @after_method('apply_link') def create_task_macapp(self): """ To compile an executable into a Mac application (a .app), set its *mac_app* attribute:: def build(bld): bld.shlib(source='a.c', target='foo', mac_app=True) To force *all* executables to be transformed into Mac applications:: def build(bld): bld.env.MACAPP = True bld.shlib(source='a.c', target='foo') """ if self.env.MACAPP or getattr(self, 'mac_app', False): out = self.link_task.outputs[0] name = bundle_name_for_output(out) dir = self.create_bundle_dirs(name, out) n1 = dir.find_or_declare(['Contents', 'MacOS', out.name]) self.apptask = self.create_task('macapp', self.link_task.outputs, n1) inst_to = getattr(self, 'install_path', '/Applications') + '/%s/Contents/MacOS/' % name self.add_install_files(install_to=inst_to, install_from=n1, chmod=Utils.O755) if getattr(self, 'mac_files', None): # this only accepts files; they will be installed as seen from mac_files_root mac_files_root = getattr(self, 'mac_files_root', None) if isinstance(mac_files_root, str): mac_files_root = self.path.find_node(mac_files_root) if not mac_files_root: self.bld.fatal('Invalid mac_files_root %r' % self.mac_files_root) res_dir = n1.parent.parent.make_node('Resources') inst_to = getattr(self, 'install_path', '/Applications') + '/%s/Resources' % name for node in self.to_nodes(self.mac_files): relpath = node.path_from(mac_files_root or node.parent) self.create_task('macapp', node, res_dir.make_node(relpath)) self.add_install_as(install_to=os.path.join(inst_to, relpath), install_from=node) if getattr(self.bld, 'is_install', None): # disable regular binary installation self.install_task.hasrun = Task.SKIP_ME @feature('cprogram', 'cxxprogram') @after_method('apply_link') def create_task_macplist(self): """ Creates a :py:class:`waflib.Tools.c_osx.macplist` instance. """ if self.env.MACAPP or getattr(self, 'mac_app', False): out = self.link_task.outputs[0] name = bundle_name_for_output(out) dir = self.create_bundle_dirs(name, out) n1 = dir.find_or_declare(['Contents', 'Info.plist']) self.plisttask = plisttask = self.create_task('macplist', [], n1) plisttask.context = { 'app_name': self.link_task.outputs[0].name, 'env': self.env } plist_ctx = getattr(self, 'plist_context', None) if (plist_ctx): plisttask.context.update(plist_ctx) if getattr(self, 'mac_plist', False): node = self.path.find_resource(self.mac_plist) if node: plisttask.inputs.append(node) else: plisttask.code = self.mac_plist else: plisttask.code = app_info inst_to = getattr(self, 'install_path', '/Applications') + '/%s/Contents/' % name self.add_install_files(install_to=inst_to, install_from=n1) @feature('cshlib', 'cxxshlib') @before_method('apply_link', 'propagate_uselib_vars') def apply_bundle(self): """ To make a bundled shared library (a ``.bundle``), set the *mac_bundle* attribute:: def build(bld): bld.shlib(source='a.c', target='foo', mac_bundle = True) To force *all* executables to be transformed into bundles:: def build(bld): bld.env.MACBUNDLE = True bld.shlib(source='a.c', target='foo') """ if self.env.MACBUNDLE or getattr(self, 'mac_bundle', False): self.env.LINKFLAGS_cshlib = self.env.LINKFLAGS_cxxshlib = [] # disable the '-dynamiclib' flag self.env.cshlib_PATTERN = self.env.cxxshlib_PATTERN = self.env.macbundle_PATTERN use = self.use = self.to_list(getattr(self, 'use', [])) if not 'MACBUNDLE' in use: use.append('MACBUNDLE') app_dirs = ['Contents', 'Contents/MacOS', 'Contents/Resources'] class macapp(Task.Task): """ Creates mac applications """ color = 'PINK' def run(self): self.outputs[0].parent.mkdir() shutil.copy2(self.inputs[0].srcpath(), self.outputs[0].abspath()) class macplist(Task.Task): """ Creates plist files """ color = 'PINK' ext_in = ['.bin'] def run(self): if getattr(self, 'code', None): txt = self.code else: txt = self.inputs[0].read() context = getattr(self, 'context', {}) txt = txt.format(**context) self.outputs[0].write(txt)
[]
[]
[ "MACOSX_DEPLOYMENT_TARGET" ]
[]
["MACOSX_DEPLOYMENT_TARGET"]
python
1
0
src/coreclr/scripts/superpmi_aspnet.py
#!/usr/bin/env python3 # # Licensed to the .NET Foundation under one or more agreements. # The .NET Foundation licenses this file to you under the MIT license. # # # Title: superpmi_aspnet.py # # Notes: # # Script to perform the superpmi collection for Techempower Benchmarks # via "crank" (https://github.com/dotnet/crank) import argparse import logging import shutil import sys import zipfile from os import path from coreclr_arguments import * from superpmi import TempDir, determine_mcs_tool_path, determine_superpmi_tool_path, is_nonzero_length_file from jitutil import run_command # Start of parser object creation. is_windows = platform.system() == "Windows" parser = argparse.ArgumentParser(description="description") parser.add_argument("-source_directory", help="path to source directory") parser.add_argument("-output_mch_path", help="Absolute path to the mch file to produce") parser.add_argument("-arch", help="Architecture") def setup_args(args): """ Setup the args for SuperPMI to use. Args: args (ArgParse): args parsed by arg parser Returns: args (CoreclrArguments) """ coreclr_args = CoreclrArguments(args, require_built_core_root=True, require_built_product_dir=True, require_built_test_dir=False, default_build_type="Checked") coreclr_args.verify(args, "source_directory", lambda source_directory: os.path.isdir(source_directory), "source_directory doesn't exist") coreclr_args.verify(args, "output_mch_path", lambda output_mch_path: not os.path.isfile(output_mch_path), "output_mch_path already exist") coreclr_args.verify(args, "arch", lambda arch: arch.lower() in ["x64", "arm64"], "Unable to set arch") return coreclr_args def determine_native_name(coreclr_args, base_lib_name, target_os): """ Determine the name of the native lib based on the OS. Args: coreclr_args (CoreclrArguments): parsed args base_lib_name (str) : root name of the lib target_os (str) : os to run tests on Return: (str) : name of the native lib for this OS """ if target_os == "OSX": return "lib" + base_lib_name + ".dylib" elif target_os == "Linux": return "lib" + base_lib_name + ".so" elif target_os == "windows": return base_lib_name + ".dll" else: raise RuntimeError("Unknown OS.") # Where there is an option, we generally target the less performant machines # See https://github.com/aspnet/Benchmarks/tree/master/scenarios # def determine_benchmark_machine(coreclr_args): """ Determine the name of the benchmark machine to use Args: coreclr_args (CoreclrArguments): parsed args Return: (str) : name of the benchmnark machine """ if coreclr_args.arch == "x64": if coreclr_args.host_os == "windows": # return "aspnet-perf-win" return "aspnet-citrine-win" elif coreclr_args.host_os == "Linux": return "aspnet-perf-lin" else: raise RuntimeError("Invalid OS for x64.") elif coreclr_args.arch == "arm64": if coreclr_args.host_os == "Linux": return "aspnet-citrine-arm" else: raise RuntimeError("Invalid OS for arm64.") else: raise RuntimeError("Invalid arch.") def build_and_run(coreclr_args): """Run perf scenarios under crank and collect data with SPMI" Args: coreclr_args (CoreClrArguments): Arguments use to drive output_mch_name (string): Name of output mch file name """ source_directory = coreclr_args.source_directory target_arch = coreclr_args.arch target_os = coreclr_args.host_os checked_root = path.join(source_directory, "artifacts", "bin", "coreclr", target_os + "." + coreclr_args.arch + ".Checked") release_root = path.join(source_directory, "artifacts", "bin", "coreclr", target_os + "." + coreclr_args.arch + ".Release") # We'll use repo script to install dotnet dotnet_install_script_name = "dotnet-install.cmd" if is_windows else "dotnet-install.sh" dotnet_install_script_path = path.join(source_directory, "eng", "common", dotnet_install_script_name) with TempDir(skip_cleanup=True) as temp_location: print ("Executing in " + temp_location) # install dotnet 6.0 run_command([dotnet_install_script_path, "-Version", "6.0.4"], temp_location, _exit_on_fail=True) os.environ['DOTNET_MULTILEVEL_LOOKUP'] = '0' os.environ['DOTNET_SKIP_FIRST_TIME_EXPERIENCE'] = '1' dotnet_path = path.join(source_directory, ".dotnet") dotnet_exe = path.join(dotnet_path, "dotnet.exe") if is_windows else path.join(dotnet_path, "dotnet") run_command([dotnet_exe, "--info"], temp_location, _exit_on_fail=True) os.environ['DOTNET_ROOT'] = dotnet_path ## install crank as local tool run_command( [dotnet_exe, "tool", "install", "Microsoft.Crank.Controller", "--version", "0.2.0-*", "--tool-path", temp_location], _exit_on_fail=True) ## ideally just do sparse clone, but this doesn't work locally ## git clone --filter=blob:none --no-checkout https://github.com/aspnet/benchmarks ## cd benchmarks ## git sparse-checkout init --cone ## git sparse-checkout set scenarios ## could probably just pass a URL and avoid this run_command( ["git", "clone", "--quiet", "--depth", "1", "https://github.com/aspnet/benchmarks"], temp_location, _exit_on_fail=True) crank_app = path.join(temp_location, "crank") mcs_path = determine_mcs_tool_path(coreclr_args) superpmi_path = determine_superpmi_tool_path(coreclr_args) # todo: add grpc/signalr, perhaps configname_scenario_list = [("platform", "plaintext"), ("json", "json"), ("plaintext", "mvc"), ("database", "fortunes_dapper"), ("database", "fortunes_ef_mvc_https"), ("proxy", "proxy-yarp"), ("staticfiles", "static")] # configname_scenario_list = [("platform", "plaintext")] # note tricks to get one element tuples runtime_options_list = [("Dummy=0",), ("TieredCompilation=0", ), ("TieredPGO=1", "TC_QuickJitForLoops=1"), ("TieredPGO=1", "TC_QuickJitForLoops=1", "ReadyToRun=0"), ("TC_QuickJitForLoops=1", "ReadyToRun=0", "TC_OnStackReplacement=1", "OSR_HitLimit=0", "TC_OnStackReplacement_InitialCounter=0"), ("TieredPGO=1", "TC_QuickJitForLoops=1", "ReadyToRun=0", "TC_OnStackReplacement=1", "OSR_HitLimit=0", "TC_OnStackReplacement_InitialCounter=100")] # runtime_options_list = [("TieredCompilation=0", )] mch_file = path.join(coreclr_args.output_mch_path, "aspnet.run." + target_os + "." + target_arch + ".checked.mch") benchmark_machine = determine_benchmark_machine(coreclr_args) jitname = determine_native_name(coreclr_args, "clrjit", target_os) coreclrname = determine_native_name(coreclr_args, "coreclr", target_os) spminame = determine_native_name(coreclr_args, "superpmi-shim-collector", target_os) corelibname = "System.Private.CoreLib.dll" jitpath = path.join(".", jitname) jitlib = path.join(checked_root, jitname) coreclr = path.join(release_root, coreclrname) corelib = path.join(release_root, corelibname) spmilib = path.join(checked_root, spminame) for (configName, scenario) in configname_scenario_list: configYml = configName + ".benchmarks.yml" configFile = path.join(temp_location, "benchmarks", "scenarios", configYml) crank_arguments = ["--config", configFile, "--profile", benchmark_machine, "--scenario", scenario, "--application.framework", "net7.0", "--application.channel", "edge", "--application.sdkVersion", "latest", "--application.environmentVariables", "COMPlus_JitName=" + spminame, "--application.environmentVariables", "SuperPMIShimLogPath=.", "--application.environmentVariables", "SuperPMIShimPath=" + jitpath, "--application.environmentVariables", "COMPlus_EnableExtraSuperPmiQueries=1", "--application.options.downloadFiles", "*.mc", "--application.options.displayOutput", "true", # "--application.options.dumpType", "full", # "--application.options.fetch", "true", "--application.options.outputFiles", spmilib, "--application.options.outputFiles", jitlib, "--application.options.outputFiles", coreclr, "--application.options.outputFiles", corelib] for runtime_options in runtime_options_list: runtime_arguments = [] for runtime_option in runtime_options: runtime_arguments.append("--application.environmentVariables") runtime_arguments.append("COMPlus_" + runtime_option) print("") print("================================") print("Config: " + configName + " scenario: " + scenario + " options: " + " ".join(runtime_options)) print("================================") print("") description = ["--description", configName + "-" + scenario + "-" + "-".join(runtime_options)] subprocess.run([crank_app] + crank_arguments + description + runtime_arguments, cwd=temp_location) # merge command = [mcs_path, "-merge", "temp.mch", "*.mc", "-dedup", "-thin"] run_command(command, temp_location) # clean command = [superpmi_path, "-v", "ewmi", "-f", "fail.mcl", jitlib, "temp.mch"] run_command(command, temp_location) # strip if is_nonzero_length_file("fail.mcl"): print("Replay had failures, cleaning..."); fail_file = path.join(coreclr_args.output_mch_path, "fail.mcl"); command = [mcs_path, "-strip", "fail.mcl", "temp.mch", mch_file] run_command(command, temp_location) else: print("Replay was clean..."); shutil.copy2("temp.mch", mch_file) # index command = [mcs_path, "-toc", mch_file] run_command(command, temp_location) # overall summary print("Merged summary for " + mch_file) command = [mcs_path, "-jitflags", mch_file] run_command(command, temp_location) def main(main_args): """ Main entry point Args: main_args ([type]): Arguments to the script """ print (sys.version) coreclr_args = setup_args(main_args) build_and_run(coreclr_args) if __name__ == "__main__": args = parser.parse_args() sys.exit(main(args))
[]
[]
[ "DOTNET_MULTILEVEL_LOOKUP", "DOTNET_ROOT", "DOTNET_SKIP_FIRST_TIME_EXPERIENCE" ]
[]
["DOTNET_MULTILEVEL_LOOKUP", "DOTNET_ROOT", "DOTNET_SKIP_FIRST_TIME_EXPERIENCE"]
python
3
0
pkg/installation/install.go
// Copyright 2019 The Kubernetes Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package installation import ( "io/ioutil" "os" "path/filepath" "runtime" "strings" "github.com/golang/glog" "github.com/pkg/errors" "sigs.k8s.io/krew/pkg/constants" "sigs.k8s.io/krew/pkg/download" "sigs.k8s.io/krew/pkg/environment" "sigs.k8s.io/krew/pkg/index" "sigs.k8s.io/krew/pkg/installation/receipt" "sigs.k8s.io/krew/pkg/pathutil" ) // InstallOpts specifies options for plugin installation operation. type InstallOpts struct { ArchiveFileOverride string } type installOperation struct { pluginName string platform index.Platform downloadStagingDir string installDir string binDir string } // Plugin lifecycle errors var ( ErrIsAlreadyInstalled = errors.New("can't install, the newest version is already installed") ErrIsNotInstalled = errors.New("plugin is not installed") ErrIsAlreadyUpgraded = errors.New("can't upgrade, the newest version is already installed") ) // Install will download and install a plugin. The operation tries // to not get the plugin dir in a bad state if it fails during the process. func Install(p environment.Paths, plugin index.Plugin, opts InstallOpts) error { glog.V(2).Infof("Looking for installed versions") _, err := receipt.Load(p.PluginInstallReceiptPath(plugin.Name)) if err == nil { return ErrIsAlreadyInstalled } else if !os.IsNotExist(err) { return errors.Wrap(err, "failed to look up plugin receipt") } // Find available installation candidate candidate, ok, err := GetMatchingPlatform(plugin.Spec.Platforms) if err != nil { return errors.Wrap(err, "failed trying to find a matching platform in plugin spec") } if !ok { return errors.Errorf("plugin %q does not offer installation for this platform", plugin.Name) } // The actual install should be the last action so that a failure during receipt // saving does not result in an installed plugin without receipt. glog.V(3).Infof("Install plugin %s at version=%s", plugin.Name, plugin.Spec.Version) if err := install(installOperation{ pluginName: plugin.Name, platform: candidate, downloadStagingDir: filepath.Join(p.DownloadPath(), plugin.Name), binDir: p.BinPath(), installDir: p.PluginVersionInstallPath(plugin.Name, plugin.Spec.Version), }, opts); err != nil { return errors.Wrap(err, "install failed") } glog.V(3).Infof("Storing install receipt for plugin %s", plugin.Name) err = receipt.Store(plugin, p.PluginInstallReceiptPath(plugin.Name)) return errors.Wrap(err, "installation receipt could not be stored, uninstall may fail") } func install(op installOperation, opts InstallOpts) error { // Download and extract glog.V(3).Infof("Creating download staging directory %q", op.downloadStagingDir) if err := os.MkdirAll(op.downloadStagingDir, 0755); err != nil { return errors.Wrapf(err, "could not create download path %q", op.downloadStagingDir) } defer func() { glog.V(3).Infof("Deleting the download staging directory %s", op.downloadStagingDir) if err := os.RemoveAll(op.downloadStagingDir); err != nil { glog.Warningf("failed to clean up download staging directory: %s", err) } }() if err := downloadAndExtract(op.downloadStagingDir, op.platform.URI, op.platform.Sha256, opts.ArchiveFileOverride); err != nil { return errors.Wrap(err, "failed to download and extract") } applyDefaults(&op.platform) if err := moveToInstallDir(op.downloadStagingDir, op.installDir, op.platform.Files); err != nil { return errors.Wrap(err, "failed while moving files to the installation directory") } subPathAbs, err := filepath.Abs(op.installDir) if err != nil { return errors.Wrapf(err, "failed to get the absolute fullPath of %q", op.installDir) } fullPath := filepath.Join(op.installDir, filepath.FromSlash(op.platform.Bin)) pathAbs, err := filepath.Abs(fullPath) if err != nil { return errors.Wrapf(err, "failed to get the absolute fullPath of %q", fullPath) } if _, ok := pathutil.IsSubPath(subPathAbs, pathAbs); !ok { return errors.Wrapf(err, "the fullPath %q does not extend the sub-fullPath %q", fullPath, op.installDir) } err = createOrUpdateLink(op.binDir, fullPath, op.pluginName) return errors.Wrap(err, "failed to link installed plugin") } func applyDefaults(platform *index.Platform) { if platform.Files == nil { platform.Files = []index.FileOperation{{From: "*", To: "."}} glog.V(4).Infof("file operation not specified, assuming %v", platform.Files) } } // downloadAndExtract downloads the specified archive uri (or uses the provided overrideFile, if a non-empty value) // while validating its checksum with the provided sha256sum, and extracts its contents to extractDir that must be. // created. func downloadAndExtract(extractDir, uri, sha256sum, overrideFile string) error { var fetcher download.Fetcher = download.HTTPFetcher{} if overrideFile != "" { fetcher = download.NewFileFetcher(overrideFile) } verifier := download.NewSha256Verifier(sha256sum) err := download.NewDownloader(verifier, fetcher).Get(uri, extractDir) return errors.Wrap(err, "failed to download and verify file") } // Uninstall will uninstall a plugin. func Uninstall(p environment.Paths, name string) error { if name == constants.KrewPluginName { glog.Errorf("Removing krew through krew is not supported.") if !IsWindows() { // assume POSIX-like glog.Errorf("If you’d like to uninstall krew altogether, run:\n\trm -rf -- %q", p.BasePath()) } return errors.New("self-uninstall not allowed") } glog.V(3).Infof("Finding installed version to delete") if _, err := receipt.Load(p.PluginInstallReceiptPath(name)); err != nil { if os.IsNotExist(err) { return ErrIsNotInstalled } return errors.Wrapf(err, "failed to look up install receipt for plugin %q", name) } glog.V(1).Infof("Deleting plugin %s", name) symlinkPath := filepath.Join(p.BinPath(), pluginNameToBin(name, IsWindows())) glog.V(3).Infof("Unlink %q", symlinkPath) if err := removeLink(symlinkPath); err != nil { return errors.Wrap(err, "could not uninstall symlink of plugin") } pluginInstallPath := p.PluginInstallPath(name) glog.V(3).Infof("Deleting path %q", pluginInstallPath) if err := os.RemoveAll(pluginInstallPath); err != nil { return errors.Wrapf(err, "could not remove plugin directory %q", pluginInstallPath) } pluginReceiptPath := p.PluginInstallReceiptPath(name) glog.V(3).Infof("Deleting plugin receipt %q", pluginReceiptPath) err := os.Remove(pluginReceiptPath) return errors.Wrapf(err, "could not remove plugin receipt %q", pluginReceiptPath) } func createOrUpdateLink(binDir string, binary string, plugin string) error { dst := filepath.Join(binDir, pluginNameToBin(plugin, IsWindows())) if err := removeLink(dst); err != nil { return errors.Wrap(err, "failed to remove old symlink") } if _, err := os.Stat(binary); os.IsNotExist(err) { return errors.Wrapf(err, "can't create symbolic link, source binary (%q) cannot be found in extracted archive", binary) } // Create new glog.V(2).Infof("Creating symlink to %q at %q", binary, dst) if err := os.Symlink(binary, dst); err != nil { return errors.Wrapf(err, "failed to create a symlink form %q to %q", binDir, dst) } glog.V(2).Infof("Created symlink at %q", dst) return nil } // removeLink removes a symlink reference if exists. func removeLink(path string) error { fi, err := os.Lstat(path) if os.IsNotExist(err) { glog.V(3).Infof("No file found at %q", path) return nil } else if err != nil { return errors.Wrapf(err, "failed to read the symlink in %q", path) } if fi.Mode()&os.ModeSymlink == 0 { return errors.Errorf("file %q is not a symlink (mode=%s)", path, fi.Mode()) } if err := os.Remove(path); err != nil { return errors.Wrapf(err, "failed to remove the symlink in %q", path) } glog.V(3).Infof("Removed symlink from %q", path) return nil } // IsWindows sees if KREW_OS or runtime.GOOS to find out if current execution mode is win32. func IsWindows() bool { goos := runtime.GOOS if env := os.Getenv("KREW_OS"); env != "" { goos = env } return goos == "windows" } // pluginNameToBin creates the name of the symlink file for the plugin name. // It converts dashes to underscores. func pluginNameToBin(name string, isWindows bool) string { name = strings.Replace(name, "-", "_", -1) name = "kubectl-" + name if isWindows { name += ".exe" } return name } // CleanupStaleKrewInstallations removes the versions that aren't the current version. func CleanupStaleKrewInstallations(dir string, currentVersion string) error { ls, err := ioutil.ReadDir(dir) if err != nil { return errors.Wrap(err, "failed to read krew store directory") } glog.V(2).Infof("Found %d entries in krew store directory", len(ls)) for _, d := range ls { glog.V(2).Infof("Found a krew installation: %s (%s)", d.Name(), d.Mode()) if d.IsDir() && d.Name() != currentVersion { glog.V(1).Infof("Deleting stale krew install directory: %s", d.Name()) p := filepath.Join(dir, d.Name()) if err := os.RemoveAll(p); err != nil { return errors.Wrapf(err, "failed to remove stale krew version at path '%s'", p) } glog.V(1).Infof("Stale installation directory removed") } } return nil }
[ "\"KREW_OS\"" ]
[]
[ "KREW_OS" ]
[]
["KREW_OS"]
go
1
0
examples/k8petstore/web-server/PetStoreBook.go
/* Copyright 2014 The Kubernetes Authors All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package main import ( "encoding/json" "fmt" "net/http" "os" "strings" "github.com/codegangsta/negroni" "github.com/gorilla/mux" "github.com/xyproto/simpleredis" ) //return the path to static assets (i.e. index.html) func pathToStaticContents() string { var static_content = os.Getenv("STATIC_FILES") // Take a wild guess. This will work in dev environment. if static_content == "" { println("*********** WARNING: DIDNT FIND ENV VAR 'STATIC_FILES', guessing your running in dev.") static_content = "../../static/" } else { println("=========== Read ENV 'STATIC_FILES', path to assets : " + static_content) } //Die if no the static files are missing. _, err := os.Stat(static_content) if err != nil { println("*********** os.Stat failed on " + static_content + " This means no static files are available. Dying...") os.Exit(2) } return static_content } func main() { var connection = os.Getenv("REDISMASTER_SERVICE_HOST") + ":" + os.Getenv("REDISMASTER_SERVICE_PORT") if connection == ":" { print("WARNING ::: If in kube, this is a failure: Missing env variable REDISMASTER_SERVICE_HOST") print("WARNING ::: Attempting to connect redis localhost.") connection = "127.0.0.1:6379" } else { print("Found redis master host " + os.Getenv("REDISMASTER_SERVICE_PORT")) connection = os.Getenv("REDISMASTER_SERVICE_HOST") + ":" + os.Getenv("REDISMASTER_SERVICE_PORT") } println("Now connecting to : " + connection) /** * Create a connection pool. ?The pool pointer will otherwise * not be of any use.?https://gist.github.com/jayunit100/1d00e6d343056401ef00 */ pool = simpleredis.NewConnectionPoolHost(connection) println("Connection pool established : " + connection) defer pool.Close() r := mux.NewRouter() println("Router created ") /** * Define a REST path. * - The parameters (key) can be accessed via mux.Vars. * - The Methods (GET) will be bound to a handler function. */ r.Path("/info").Methods("GET").HandlerFunc(InfoHandler) r.Path("/lrange/{key}").Methods("GET").HandlerFunc(ListRangeHandler) r.Path("/rpush/{key}/{value}").Methods("GET").HandlerFunc(ListPushHandler) r.Path("/llen").Methods("GET").HandlerFunc(LLENHandler) //for dev environment, the site is one level up... r.PathPrefix("/").Handler(http.FileServer(http.Dir(pathToStaticContents()))) r.Path("/env").Methods("GET").HandlerFunc(EnvHandler) list := simpleredis.NewList(pool, "k8petstore") HandleError(nil, list.Add("jayunit100")) HandleError(nil, list.Add("tstclaire")) HandleError(nil, list.Add("rsquared")) // Verify that this is 3 on startup. infoL := HandleError(pool.Get(0).Do("LLEN", "k8petstore")).(int64) fmt.Printf("\n=========== Starting DB has %d elements \n", infoL) if infoL < 3 { print("Not enough entries in DB. something is wrong w/ redis querying") print(infoL) panic("Failed ... ") } println("=========== Now launching negroni...this might take a second...") n := negroni.Classic() n.UseHandler(r) n.Run(":3000") println("Done ! Web app is now running.") } /** * the Pool will be populated on startup, * it will be an instance of a connection pool. * Hence, we reference its address rather than copying. */ var pool *simpleredis.ConnectionPool /** * REST * input: key * * Writes all members to JSON. */ func ListRangeHandler(rw http.ResponseWriter, req *http.Request) { println("ListRangeHandler") key := mux.Vars(req)["key"] list := simpleredis.NewList(pool, key) //members := HandleError(list.GetAll()).([]string) members := HandleError(list.GetLastN(4)).([]string) print(members) membersJSON := HandleError(json.MarshalIndent(members, "", " ")).([]byte) print("RETURN MEMBERS = " + string(membersJSON)) rw.Write(membersJSON) } func LLENHandler(rw http.ResponseWriter, req *http.Request) { println("=========== LLEN HANDLER") infoL := HandleError(pool.Get(0).Do("LLEN", "k8petstore")).(int64) fmt.Printf("=========== LLEN is %d ", infoL) lengthJSON := HandleError(json.MarshalIndent(infoL, "", " ")).([]byte) fmt.Printf("================ LLEN json is %s", infoL) print("RETURN LEN = " + string(lengthJSON)) rw.Write(lengthJSON) } func ListPushHandler(rw http.ResponseWriter, req *http.Request) { println("ListPushHandler") /** * Expect a key and value as input. * */ key := mux.Vars(req)["key"] value := mux.Vars(req)["value"] println("New list " + key + " " + value) list := simpleredis.NewList(pool, key) HandleError(nil, list.Add(value)) ListRangeHandler(rw, req) } func InfoHandler(rw http.ResponseWriter, req *http.Request) { println("InfoHandler") info := HandleError(pool.Get(0).Do("INFO")).([]byte) rw.Write(info) } func EnvHandler(rw http.ResponseWriter, req *http.Request) { println("EnvHandler") environment := make(map[string]string) for _, item := range os.Environ() { splits := strings.Split(item, "=") key := splits[0] val := strings.Join(splits[1:], "=") environment[key] = val } envJSON := HandleError(json.MarshalIndent(environment, "", " ")).([]byte) rw.Write(envJSON) } func HandleError(result interface{}, err error) (r interface{}) { if err != nil { print("ERROR : " + err.Error()) //panic(err) } return result }
[ "\"STATIC_FILES\"", "\"REDISMASTER_SERVICE_HOST\"", "\"REDISMASTER_SERVICE_PORT\"", "\"REDISMASTER_SERVICE_PORT\"", "\"REDISMASTER_SERVICE_HOST\"", "\"REDISMASTER_SERVICE_PORT\"" ]
[]
[ "STATIC_FILES", "REDISMASTER_SERVICE_HOST", "REDISMASTER_SERVICE_PORT" ]
[]
["STATIC_FILES", "REDISMASTER_SERVICE_HOST", "REDISMASTER_SERVICE_PORT"]
go
3
0
jh-Search/src/main/java/com/mycompany/myapp/Application.java
package com.mycompany.myapp; import com.mycompany.myapp.config.Constants; import com.mycompany.myapp.config.JHipsterProperties; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.boot.SpringApplication; import org.springframework.boot.actuate.autoconfigure.MetricFilterAutoConfiguration; import org.springframework.boot.actuate.autoconfigure.MetricRepositoryAutoConfiguration; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.autoconfigure.liquibase.LiquibaseProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.ComponentScan; import org.springframework.core.env.Environment; import org.springframework.core.env.SimpleCommandLinePropertySource; import javax.annotation.PostConstruct; import javax.inject.Inject; import java.io.IOException; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.Arrays; import java.util.Collection; @ComponentScan @EnableAutoConfiguration(exclude = { MetricFilterAutoConfiguration.class, MetricRepositoryAutoConfiguration.class }) @EnableConfigurationProperties({ JHipsterProperties.class, LiquibaseProperties.class }) public class Application { private static final Logger log = LoggerFactory.getLogger(Application.class); @Inject private Environment env; /** * Initializes jhipster. * <p/> * Spring profiles can be configured with a program arguments --spring.profiles.active=your-active-profile * <p/> * <p> * You can find more information on how profiles work with JHipster on <a href="http://jhipster.github.io/profiles.html">http://jhipster.github.io/profiles.html</a>. * </p> */ @PostConstruct public void initApplication() throws IOException { if (env.getActiveProfiles().length == 0) { log.warn("No Spring profile configured, running with default configuration"); } else { log.info("Running with Spring profile(s) : {}", Arrays.toString(env.getActiveProfiles())); Collection<String> activeProfiles = Arrays.asList(env.getActiveProfiles()); if (activeProfiles.contains(Constants.SPRING_PROFILE_DEVELOPMENT) && activeProfiles.contains(Constants.SPRING_PROFILE_PRODUCTION)) { log.error("You have misconfigured your application! " + "It should not run with both the 'dev' and 'prod' profiles at the same time."); } if (activeProfiles.contains(Constants.SPRING_PROFILE_PRODUCTION) && activeProfiles.contains(Constants.SPRING_PROFILE_FAST)) { log.error("You have misconfigured your application! " + "It should not run with both the 'prod' and 'fast' profiles at the same time."); } if (activeProfiles.contains(Constants.SPRING_PROFILE_DEVELOPMENT) && activeProfiles.contains(Constants.SPRING_PROFILE_CLOUD)) { log.error("You have misconfigured your application! " + "It should not run with both the 'dev' and 'cloud' profiles at the same time."); } } } /** * Main method, used to run the application. */ public static void main(String[] args) throws UnknownHostException { SpringApplication app = new SpringApplication(Application.class); SimpleCommandLinePropertySource source = new SimpleCommandLinePropertySource(args); addDefaultProfile(app, source); Environment env = app.run(args).getEnvironment(); log.info("Access URLs:\n----------------------------------------------------------\n\t" + "Local: \t\thttp://127.0.0.1:{}\n\t" + "External: \thttp://{}:{}\n----------------------------------------------------------", env.getProperty("server.port"), InetAddress.getLocalHost().getHostAddress(), env.getProperty("server.port")); } /** * If no profile has been configured, set by default the "dev" profile. */ private static void addDefaultProfile(SpringApplication app, SimpleCommandLinePropertySource source) { if (!source.containsProperty("spring.profiles.active") && !System.getenv().containsKey("SPRING_PROFILES_ACTIVE")) { app.setAdditionalProfiles(Constants.SPRING_PROFILE_DEVELOPMENT); } } }
[]
[]
[]
[]
[]
java
0
0
cli/cmd/root.go
package cmd import ( "bytes" "errors" "fmt" "net" "os" "regexp" "strings" "time" "github.com/spf13/pflag" corev1 "k8s.io/api/core/v1" "k8s.io/client-go/tools/clientcmd" "github.com/fatih/color" log "github.com/sirupsen/logrus" "github.com/spf13/cobra" k8sResource "k8s.io/apimachinery/pkg/api/resource" ) const ( defaultLinkerdNamespace = "linkerd" defaultCNINamespace = "linkerd-cni" defaultClusterDomain = "cluster.local" defaultDockerRegistry = "gcr.io/linkerd-io" jsonOutput = "json" tableOutput = "table" wideOutput = "wide" maxRps = 100.0 ) var ( // special handling for Windows, on all other platforms these resolve to // os.Stdout and os.Stderr, thanks to https://github.com/mattn/go-colorable stdout = color.Output stderr = color.Error okStatus = color.New(color.FgGreen, color.Bold).SprintFunc()("\u221A") // √ warnStatus = color.New(color.FgYellow, color.Bold).SprintFunc()("\u203C") // ‼ failStatus = color.New(color.FgRed, color.Bold).SprintFunc()("\u00D7") // × controlPlaneNamespace string cniNamespace string apiAddr string // An empty value means "use the Kubernetes configuration" kubeconfigPath string kubeContext string defaultNamespace string // Default namespace taken from current kubectl context impersonate string impersonateGroup []string verbose bool // These regexs are not as strict as they could be, but are a quick and dirty // sanity check against illegal characters. alphaNumDash = regexp.MustCompile(`^[a-zA-Z0-9-]+$`) alphaNumDashDot = regexp.MustCompile(`^[\.a-zA-Z0-9-]+$`) alphaNumDashDotSlashColon = regexp.MustCompile(`^[\./a-zA-Z0-9-:]+$`) alphaNumDashDotSlashColonUnderscore = regexp.MustCompile(`^[\./a-zA-Z0-9-:_]+$`) // Full Rust log level syntax at // https://docs.rs/env_logger/0.6.0/env_logger/#enabling-logging r = strings.NewReplacer("\t", "", "\n", "") validProxyLogLevel = regexp.MustCompile(r.Replace(` ^( ( (trace|debug|warn|info|error)| (\w|::)+| ((\w|::)+=(trace|debug|warn|info|error)) )(?:,|$) )+$`)) ) // RootCmd represents the root Cobra command var RootCmd = &cobra.Command{ Use: "linkerd", Short: "linkerd manages the Linkerd service mesh", Long: `linkerd manages the Linkerd service mesh.`, PersistentPreRunE: func(cmd *cobra.Command, args []string) error { // enable / disable logging if verbose { log.SetLevel(log.DebugLevel) } else { log.SetLevel(log.PanicLevel) } controlPlaneNamespaceFromEnv := os.Getenv("LINKERD_NAMESPACE") if controlPlaneNamespace == defaultLinkerdNamespace && controlPlaneNamespaceFromEnv != "" { controlPlaneNamespace = controlPlaneNamespaceFromEnv } if !alphaNumDash.MatchString(controlPlaneNamespace) { return fmt.Errorf("%s is not a valid namespace", controlPlaneNamespace) } return nil }, } func init() { defaultNamespace = getDefaultNamespace() RootCmd.PersistentFlags().StringVarP(&controlPlaneNamespace, "linkerd-namespace", "L", defaultLinkerdNamespace, "Namespace in which Linkerd is installed [$LINKERD_NAMESPACE]") RootCmd.PersistentFlags().StringVarP(&cniNamespace, "cni-namespace", "", defaultCNINamespace, "Namespace in which the Linkerd CNI plugin is installed") RootCmd.PersistentFlags().StringVar(&kubeconfigPath, "kubeconfig", "", "Path to the kubeconfig file to use for CLI requests") RootCmd.PersistentFlags().StringVar(&kubeContext, "context", "", "Name of the kubeconfig context to use") RootCmd.PersistentFlags().StringVar(&impersonate, "as", "", "Username to impersonate for Kubernetes operations") RootCmd.PersistentFlags().StringArrayVar(&impersonateGroup, "as-group", []string{}, "Group to impersonate for Kubernetes operations") RootCmd.PersistentFlags().StringVar(&apiAddr, "api-addr", "", "Override kubeconfig and communicate directly with the control plane at host:port (mostly for testing)") RootCmd.PersistentFlags().BoolVar(&verbose, "verbose", false, "Turn on debug logging") RootCmd.AddCommand(newCmdAlpha()) RootCmd.AddCommand(newCmdCheck()) RootCmd.AddCommand(newCmdCompletion()) RootCmd.AddCommand(newCmdDashboard()) RootCmd.AddCommand(newCmdDiagnostics()) RootCmd.AddCommand(newCmdDoc()) RootCmd.AddCommand(newCmdEdges()) RootCmd.AddCommand(newCmdEndpoints()) RootCmd.AddCommand(newCmdGet()) RootCmd.AddCommand(newCmdInject()) RootCmd.AddCommand(newCmdInstall()) RootCmd.AddCommand(newCmdInstallCNIPlugin()) RootCmd.AddCommand(newCmdInstallSP()) RootCmd.AddCommand(newCmdLogs()) RootCmd.AddCommand(newCmdMetrics()) RootCmd.AddCommand(newCmdProfile()) RootCmd.AddCommand(newCmdRoutes()) RootCmd.AddCommand(newCmdStat()) RootCmd.AddCommand(newCmdTap()) RootCmd.AddCommand(newCmdTop()) RootCmd.AddCommand(newCmdUninject()) RootCmd.AddCommand(newCmdUpgrade()) RootCmd.AddCommand(newCmdVersion()) RootCmd.AddCommand(newCmdMulticluster()) RootCmd.AddCommand(newCmdUninstall()) } type statOptionsBase struct { namespace string timeWindow string outputFormat string } func newStatOptionsBase() *statOptionsBase { return &statOptionsBase{ namespace: defaultNamespace, timeWindow: "1m", outputFormat: tableOutput, } } func (o *statOptionsBase) validateOutputFormat() error { switch o.outputFormat { case tableOutput, jsonOutput, wideOutput: return nil default: return fmt.Errorf("--output currently only supports %s, %s and %s", tableOutput, jsonOutput, wideOutput) } } func renderStats(buffer bytes.Buffer, options *statOptionsBase) string { var out string switch options.outputFormat { case jsonOutput: out = buffer.String() default: // strip left padding on the first column b := buffer.Bytes() if len(b) > padding { out = string(b[padding:]) } out = strings.Replace(out, "\n"+strings.Repeat(" ", padding), "\n", -1) } return out } // getRequestRate calculates request rate from Public API BasicStats. func getRequestRate(success, failure uint64, timeWindow string) float64 { windowLength, err := time.ParseDuration(timeWindow) if err != nil { log.Error(err.Error()) return 0.0 } return float64(success+failure) / windowLength.Seconds() } // getSuccessRate calculates success rate from Public API BasicStats. func getSuccessRate(success, failure uint64) float64 { if success+failure == 0 { return 0.0 } return float64(success) / float64(success+failure) } // getDefaultNamespace fetches the default namespace // used in the current KubeConfig context func getDefaultNamespace() string { rules := clientcmd.NewDefaultClientConfigLoadingRules() if kubeconfigPath != "" { rules.ExplicitPath = kubeconfigPath } overrides := &clientcmd.ConfigOverrides{CurrentContext: kubeContext} kubeCfg := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(rules, overrides) ns, _, err := kubeCfg.Namespace() if err != nil { log.Errorf("could not set namespace from kubectl context: ensure a valid KUBECONFIG path has been set") return corev1.NamespaceDefault } return ns } // proxyConfigOptions holds values for command line flags that apply to both the // install and inject commands. All fields in this struct should have // corresponding flags added in the addProxyConfigFlags func later in this file. type proxyConfigOptions struct { proxyVersion string proxyImage string initImage string initImageVersion string debugImage string debugImageVersion string dockerRegistry string imagePullPolicy string destinationGetNetworks []string ignoreInboundPorts []string ignoreOutboundPorts []string proxyUID int64 proxyLogLevel string proxyLogFormat string proxyInboundPort uint proxyOutboundPort uint proxyControlPort uint proxyAdminPort uint proxyCPURequest string proxyMemoryRequest string proxyCPULimit string proxyMemoryLimit string enableExternalProfiles bool traceCollector string traceCollectorSvcAccount string waitBeforeExitSeconds uint64 ignoreCluster bool // not validated by validate() disableIdentity bool requireIdentityOnInboundPorts []string disableTap bool } func (options *proxyConfigOptions) validate() error { for _, network := range options.destinationGetNetworks { if _, _, err := net.ParseCIDR(network); err != nil { return fmt.Errorf("cannot parse destination get networks: %s", err) } } if options.disableIdentity && len(options.requireIdentityOnInboundPorts) > 0 { return errors.New("Identity must be enabled when --require-identity-on-inbound-ports is specified") } if options.proxyVersion != "" && !alphaNumDashDot.MatchString(options.proxyVersion) { return fmt.Errorf("%s is not a valid version", options.proxyVersion) } if options.initImageVersion != "" && !alphaNumDashDot.MatchString(options.initImageVersion) { return fmt.Errorf("%s is not a valid version", options.initImageVersion) } if options.dockerRegistry != "" && !alphaNumDashDotSlashColon.MatchString(options.dockerRegistry) { return fmt.Errorf("%s is not a valid Docker registry. The url can contain only letters, numbers, dash, dot, slash and colon", options.dockerRegistry) } if options.imagePullPolicy != "" && options.imagePullPolicy != "Always" && options.imagePullPolicy != "IfNotPresent" && options.imagePullPolicy != "Never" { return fmt.Errorf("--image-pull-policy must be one of: Always, IfNotPresent, Never") } if options.proxyCPURequest != "" { if _, err := k8sResource.ParseQuantity(options.proxyCPURequest); err != nil { return fmt.Errorf("Invalid cpu request '%s' for --proxy-cpu-request flag", options.proxyCPURequest) } } if options.proxyMemoryRequest != "" { if _, err := k8sResource.ParseQuantity(options.proxyMemoryRequest); err != nil { return fmt.Errorf("Invalid memory request '%s' for --proxy-memory-request flag", options.proxyMemoryRequest) } } if options.proxyCPULimit != "" { cpuLimit, err := k8sResource.ParseQuantity(options.proxyCPULimit) if err != nil { return fmt.Errorf("Invalid cpu limit '%s' for --proxy-cpu-limit flag", options.proxyCPULimit) } if options.proxyCPURequest != "" { // Not checking for error because option proxyCPURequest was already validated if cpuRequest, _ := k8sResource.ParseQuantity(options.proxyCPURequest); cpuRequest.MilliValue() > cpuLimit.MilliValue() { return fmt.Errorf("The cpu limit '%s' cannot be lower than the cpu request '%s'", options.proxyCPULimit, options.proxyCPURequest) } } } if options.proxyMemoryLimit != "" { memoryLimit, err := k8sResource.ParseQuantity(options.proxyMemoryLimit) if err != nil { return fmt.Errorf("Invalid memory limit '%s' for --proxy-memory-limit flag", options.proxyMemoryLimit) } if options.proxyMemoryRequest != "" { // Not checking for error because option proxyMemoryRequest was already validated if memoryRequest, _ := k8sResource.ParseQuantity(options.proxyMemoryRequest); memoryRequest.Value() > memoryLimit.Value() { return fmt.Errorf("The memory limit '%s' cannot be lower than the memory request '%s'", options.proxyMemoryLimit, options.proxyMemoryRequest) } } } if options.proxyLogLevel != "" && !validProxyLogLevel.MatchString(options.proxyLogLevel) { return fmt.Errorf("\"%s\" is not a valid proxy log level - for allowed syntax check https://docs.rs/env_logger/0.6.0/env_logger/#enabling-logging", options.proxyLogLevel) } if err := validateRangeSlice(options.ignoreInboundPorts); err != nil { return err } if err := validateRangeSlice(options.ignoreOutboundPorts); err != nil { return err } return nil } // registryOverride replaces the registry of the provided image if the image is // using the default registry and the provided registry is not the default. func registryOverride(image, registry string) string { return strings.Replace(image, defaultDockerRegistry, registry, 1) } func (options *proxyConfigOptions) flagSet(e pflag.ErrorHandling) *pflag.FlagSet { flags := pflag.NewFlagSet("proxy", e) flags.StringVarP(&options.proxyVersion, "proxy-version", "v", options.proxyVersion, "Tag to be used for the Linkerd proxy images") flags.StringVar(&options.proxyImage, "proxy-image", options.proxyImage, "Linkerd proxy container image name") flags.StringVar(&options.initImage, "init-image", options.initImage, "Linkerd init container image name") flags.StringVar(&options.initImageVersion, "init-image-version", options.initImageVersion, "Linkerd init container image version") flags.StringVar(&options.dockerRegistry, "registry", options.dockerRegistry, "Docker registry to pull images from") flags.StringVar(&options.imagePullPolicy, "image-pull-policy", options.imagePullPolicy, "Docker image pull policy") flags.UintVar(&options.proxyInboundPort, "inbound-port", options.proxyInboundPort, "Proxy port to use for inbound traffic") flags.UintVar(&options.proxyOutboundPort, "outbound-port", options.proxyOutboundPort, "Proxy port to use for outbound traffic") flags.StringSliceVar(&options.ignoreInboundPorts, "skip-inbound-ports", options.ignoreInboundPorts, "Ports and/or port ranges (inclusive) that should skip the proxy and send directly to the application") flags.StringSliceVar(&options.ignoreOutboundPorts, "skip-outbound-ports", options.ignoreOutboundPorts, "Outbound ports and/or port ranges (inclusive) that should skip the proxy") flags.Int64Var(&options.proxyUID, "proxy-uid", options.proxyUID, "Run the proxy under this user ID") flags.StringVar(&options.proxyLogLevel, "proxy-log-level", options.proxyLogLevel, "Log level for the proxy") flags.UintVar(&options.proxyControlPort, "control-port", options.proxyControlPort, "Proxy port to use for control") flags.UintVar(&options.proxyAdminPort, "admin-port", options.proxyAdminPort, "Proxy port to serve metrics on") flags.StringVar(&options.proxyCPURequest, "proxy-cpu-request", options.proxyCPURequest, "Amount of CPU units that the proxy sidecar requests") flags.StringVar(&options.proxyMemoryRequest, "proxy-memory-request", options.proxyMemoryRequest, "Amount of Memory that the proxy sidecar requests") flags.StringVar(&options.proxyCPULimit, "proxy-cpu-limit", options.proxyCPULimit, "Maximum amount of CPU units that the proxy sidecar can use") flags.StringVar(&options.proxyMemoryLimit, "proxy-memory-limit", options.proxyMemoryLimit, "Maximum amount of Memory that the proxy sidecar can use") flags.BoolVar(&options.enableExternalProfiles, "enable-external-profiles", options.enableExternalProfiles, "Enable service profiles for non-Kubernetes services") // Deprecated flags flags.StringVar(&options.proxyMemoryRequest, "proxy-memory", options.proxyMemoryRequest, "Amount of Memory that the proxy sidecar requests") flags.StringVar(&options.proxyCPURequest, "proxy-cpu", options.proxyCPURequest, "Amount of CPU units that the proxy sidecar requests") flags.MarkDeprecated("proxy-memory", "use --proxy-memory-request instead") flags.MarkDeprecated("proxy-cpu", "use --proxy-cpu-request instead") return flags }
[ "\"LINKERD_NAMESPACE\"" ]
[]
[ "LINKERD_NAMESPACE" ]
[]
["LINKERD_NAMESPACE"]
go
1
0
pkg/session/session_test.go
package session import ( "fmt" "os" "testing" "time" "github.com/google/uuid" "github.com/jmoiron/sqlx" _ "github.com/lib/pq" "github.com/trussworks/sesh/pkg/dbstore" "github.com/trussworks/sesh/pkg/domain" "github.com/trussworks/sesh/pkg/mock" ) func dbURLFromEnv() string { host := os.Getenv("DATABASE_HOST") port := os.Getenv("DATABASE_PORT") name := os.Getenv("DATABASE_NAME") user := os.Getenv("DATABASE_USER") // password := os.Getenv("DATABASE_PASSWORD") sslmode := os.Getenv("DATABASE_SSL_MODE") connStr := fmt.Sprintf("postgres://%s@%s:%s/%s?sslmode=%s", user, host, port, name, sslmode) return connStr } func getTestStore(t *testing.T) domain.SessionStorageService { t.Helper() connStr := dbURLFromEnv() connection, err := sqlx.Open("postgres", connStr) if err != nil { t.Fatal(err) return nil } return dbstore.NewDBStore(connection) } func TestAuthExists(t *testing.T) { timeout := 5 * time.Second store := getTestStore(t) defer store.Close() sessionLog := domain.FmtLogger(true) session := NewSessionService(timeout, store, sessionLog) session.UserDidAuthenticate("foo") } func TestLogSessionCreatedDestroyed(t *testing.T) { timeout := 5 * time.Second store := getTestStore(t) defer store.Close() sessionLog := mock.NewLogRecorder(domain.FmtLogger(true)) session := NewSessionService(timeout, store, &sessionLog) accountID := uuid.New().String() sessionKey, authErr := session.UserDidAuthenticate(accountID) if authErr != nil { t.Fatal(authErr) } createMsg, logErr := sessionLog.GetOnlyMatchingMessage(domain.SessionCreated) if logErr != nil { t.Fatal(logErr) } if createMsg.Level != "INFO" { t.Fatal("Wrong Log Level", createMsg.Level) } sessionHash, ok := createMsg.Fields["session_hash"] if !ok { t.Fatal("Didn't log the hashed session key") } if sessionHash == sessionKey { t.Fatal("We logged the actual session key!") } delErr := session.UserDidLogout(sessionKey) if delErr != nil { t.Fatal(delErr) } delMsg, delLogErr := sessionLog.GetOnlyMatchingMessage(domain.SessionDestroyed) if delLogErr != nil { t.Fatal(delLogErr) } if delMsg.Level != "INFO" { t.Fatal("Wrong Log Level", delMsg.Level) } delSessionHash, ok := delMsg.Fields["session_hash"] if !ok { t.Fatal("Didn't log the hashed session key") } if delSessionHash == sessionKey { t.Fatal("We logged the actual session key!") } _, getErr := session.GetSessionIfValid(sessionKey) if getErr != domain.ErrValidSessionNotFound { t.Fatal(getErr) } nonExistantMsg, logNonExistantErr := sessionLog.GetOnlyMatchingMessage(domain.SessionDoesNotExist) if logNonExistantErr != nil { t.Fatal(logNonExistantErr) } nonExistantSessionHash, ok := nonExistantMsg.Fields["session_hash"] if !ok { t.Fatal("Didn't log the hashed session key") } if nonExistantSessionHash == sessionKey { t.Fatal("We logged the actual session key!") } } func TestLogSessionExpired(t *testing.T) { timeout := -5 * time.Second store := getTestStore(t) defer store.Close() sessionLog := mock.NewLogRecorder(domain.FmtLogger(true)) session := NewSessionService(timeout, store, &sessionLog) accountID := uuid.New().String() sessionKey, authErr := session.UserDidAuthenticate(accountID) if authErr != nil { t.Fatal(authErr) } logCreateMsg, logCreateErr := sessionLog.GetOnlyMatchingMessage(domain.SessionCreated) if logCreateErr != nil { t.Fatal(logCreateErr) } if logCreateMsg.Level != "INFO" { t.Fatal("Wrong Log Level", logCreateMsg.Level) } _, getErr := session.GetSessionIfValid(sessionKey) if getErr != domain.ErrSessionExpired { t.Fatal("didn't get the right error back getting the expired session:", getErr) } expiredMsg, logExpiredErr := sessionLog.GetOnlyMatchingMessage(domain.SessionExpired) if logExpiredErr != nil { t.Fatal(logExpiredErr) } expiredSessionHash, ok := expiredMsg.Fields["session_hash"] if !ok { t.Fatal("Didn't log the hashed session key") } if expiredSessionHash == sessionKey { t.Fatal("We logged the actual session key!") } // make sure you can re-auth after ending a session _, newAuthErr := session.UserDidAuthenticate(accountID) if newAuthErr != nil { t.Fatal(newAuthErr) } } // TestLogConcurrentSession tests that if you create a session, then create a new session over it, we log something. func TestLogConcurrentSession(t *testing.T) { timeout := 5 * time.Second store := getTestStore(t) defer store.Close() sessionLog := mock.NewLogRecorder(domain.FmtLogger(true)) session := NewSessionService(timeout, store, &sessionLog) accountID := uuid.New().String() _, authErr := session.UserDidAuthenticate(accountID) if authErr != nil { t.Fatal(authErr) } _, logCreateErr := sessionLog.GetOnlyMatchingMessage(domain.SessionCreated) if logCreateErr != nil { t.Fatal(logCreateErr) } // Now login again: _, authAgainErr := session.UserDidAuthenticate(accountID) if authAgainErr != nil { t.Fatal(authAgainErr) } createMessages := sessionLog.MatchingMessages(domain.SessionCreated) if len(createMessages) != 2 { t.Fatal("Should have 2 create messages now") } _, logConcurrentErr := sessionLog.GetOnlyMatchingMessage(domain.SessionConcurrentLogin) if logConcurrentErr != nil { t.Fatal(logConcurrentErr) } }
[ "\"DATABASE_HOST\"", "\"DATABASE_PORT\"", "\"DATABASE_NAME\"", "\"DATABASE_USER\"", "\"DATABASE_PASSWORD\"", "\"DATABASE_SSL_MODE\"" ]
[]
[ "DATABASE_SSL_MODE", "DATABASE_PASSWORD", "DATABASE_NAME", "DATABASE_HOST", "DATABASE_USER", "DATABASE_PORT" ]
[]
["DATABASE_SSL_MODE", "DATABASE_PASSWORD", "DATABASE_NAME", "DATABASE_HOST", "DATABASE_USER", "DATABASE_PORT"]
go
6
0
modules/selfserve/files/selfserve/lib/selfserve/__init__.py
#!/usr/bin/python # # UI for selfserve ss2. # # ==================================================================== # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. ###################################################################### import cgi import cgitb import logging import logging.handlers import os import sys import time import re import StringIO import ezt from ss2config import * import selfserve.email import selfserve.exceptions import selfserve.ldap import selfserve.tokens class AppendHandler(logging.Handler): def __init__(self, tdata, level=logging.DEBUG): logging.Handler.__init__(self, level) self._tdata = tdata def emit(self, record): self._tdata['_debug'] = self._tdata.pop('_debug', "") + self.format(record) + "\n" def debug_dump(): for key, val in os.environ.iteritems(): print "%r: %r" % (key, val) print `sys.argv` def render_exception(e, tdata, lookup): template = lookup.get_template('results.html') msgs = { selfserve.exceptions.BadUserOrPassword : "Wrong username '%s' or password" % str(e), selfserve.exceptions.CorruptToken : 'Internal error: corrupt token %s' % str(e), selfserve.exceptions.NoSuchToken : 'No such token %s' % str(e), selfserve.exceptions.NonMatchingPasswords : "Passwords don't match, try again", selfserve.exceptions.EncryptionError : "Encryption failed", selfserve.exceptions.WeakPassword : "Password does not meet complexity policy", selfserve.exceptions.InvalidInput : "Invalid input: %s" % str(e), } codes = { selfserve.exceptions.BadUserOrPassword : 401, selfserve.exceptions.CorruptToken : 500, selfserve.exceptions.NoSuchToken : 404, selfserve.exceptions.NonMatchingPasswords : 409, selfserve.exceptions.EncryptionError : 500, selfserve.exceptions.WeakPassword : 403, selfserve.exceptions.InvalidInput : 405, } tdata['status'] = get_by_subclass(codes, e, 500) tdata['message'] = get_by_subclass(msgs, e, "Unspecified exception; logged.") if tdata['message'].endswith('; logged') or tdata['status'] >= 500: logger.error("Unspecified exception: %s", `e`) print template.render(**tdata) def render_index(tdata, lookup, form, pathinfo): template = lookup.get_template('index.html') tdata['availid'] = form.getvalue('availid', '') # /details/$availid redirector tdata['changepw_is_checked'] = (form.getvalue('changepw') and 'checked' or '') print template.render(**tdata) def render_reset(tdata, lookup, form, pathinfo): "The 'Request a password reset email' screen." if 'submit_sendmail' in form: availid = form.getvalue('availid') if availid is None: template = lookup.get_template('results.html') tdata['message'] = "No username given" tdata['status'] = 500 else: template = lookup.get_template('results.html') remote24 = os.environ['REMOTE_ADDR'] m = re.search("(?:\d+\.){3}", remote24) remote24 = m.group(0); msgid = selfserve.email.send_email(availid, lookup.PATH, remote24, tdata['base_url']) tdata['message'] = "Email sent, Message-ID=<%s>." % msgid else: template = lookup.get_template('sendemail.html') print template.render(**tdata) def get_by_subclass(dict_, obj, default_value): for k, v in dict_.iteritems(): if isinstance(obj, k): return v else: return default_value def render_token(tdata, lookup, form, pathinfo): "The 'Here is the password reset token I got by email' screen." token = pathinfo.split('/', 3)[-1] # Validate the token # ### layering violation? remote24 = os.environ['REMOTE_ADDR'] m = re.search("(?:\d+\.){3}", remote24) remote24 = m.group(0); hextoken, availid, expiry = selfserve.tokens.has_token(PW_RESET_MAGIC, token, remote24) tdata['availid'] = availid tdata['hextoken'] = hextoken if os.environ.get('REQUEST_METHOD') == 'POST': assert form['hextoken'].value == hextoken # SECURITY: The ONLY criterion for to accept this new pw is that # the POST was made to the correct token URI. logger.info('finishing password reset for valid token=%s', selfserve.tokens.censor_token(hextoken)) remote24 = os.environ['REMOTE_ADDR'] m = re.search("(?:\d+\.){3}", remote24) remote24 = m.group(0); selfserve.ldap.do_pw_reset(availid, form.getvalue('new_pw1'), form.getvalue('new_pw2'), hextoken, remote24) template = lookup.get_template('results.html') tdata['message'] = 'Password change successful' print template.render(**tdata) else: logger.info('starting password reset for valid token=%s', selfserve.tokens.censor_token(hextoken)) template = lookup.get_template('resetpassword.html') print template.render(**tdata) def render_login_redirector(tdata, lookup, form, pathinfo): template = lookup.get_template('results.html') availid = form.getvalue('availid') password = form.getvalue('password') selfserve.ldap.bind_as_user(availid, password) remote24 = os.environ['REMOTE_ADDR'] m = re.search("(?:\d+\.){3}", remote24) remote24 = m.group(0); sesskey = selfserve.tokens.make_token(SESSION_MAGIC, availid, seconds=60, cookie=remote24)[0] # one minute tdata['session'] = sesskey if 'changepw' in form: tdata['location'] = '%s/details/%s/password?session=%s' % (tdata['base_url'], availid, sesskey) else: tdata['location'] = '%s/details/%s?session=%s' % (tdata['base_url'], availid, sesskey) tdata['message'] = "Login successful" print template.render(**tdata) def make_attrs_dict(attributes): retval = {} for k, v in attributes: retval[k] = v return retval class Attribute(object): def __init__(self, key, name, editable, multivalue, values): self.key = key self.name = name self.editable = editable self.multivalue = multivalue self.values = values def render_edit_details(tdata, lookup, form, pathinfo): "The 'edit my details or password' screens." pathinfo_parts = pathinfo.split('/') assert len(pathinfo_parts) == 3 or len(pathinfo_parts) == 4 and pathinfo_parts[-1] in [ 'password' , '' ] # let's hope we don't have [email protected] editing_the_password = (pathinfo_parts[-1] == 'password') # validation if os.environ.get('REQUEST_METHOD') == 'POST': # submitting a filled form availid = form['availid'].value tdata['availid'] = availid else: if 'session' in form: # came here via the login screen and the 1-minute redirector remote24 = os.environ['REMOTE_ADDR'] m = re.search("(?:\d+\.){3}", remote24) remote24 = m.group(0); hextoken, availid, expiry = selfserve.tokens.has_token(SESSION_MAGIC, form.getvalue('session'), remote24) tdata['availid'] = availid # for the "logout" function tdata['session'] = hextoken else: # redirect to login screen template = lookup.get_template('results.html') tdata['location'] = '%s?availid=%s&changepw=%s' % ( tdata['base_url'], pathinfo_parts[2], ['', '1'][editing_the_password]) tdata['message'] = "Redirecting..." if editing_the_password: # TODO pass print template.render(**tdata) return if editing_the_password: if os.environ.get('REQUEST_METHOD') == 'POST': template = lookup.get_template('results.html') selfserve.ldap.do_pw_change(availid, form.getvalue('old_pw'), form.getvalue('new_pw1'), form.getvalue('new_pw2')) tdata['message'] = 'Password change successful' print template.render(**tdata) else: template = lookup.get_template('changepassword.html') print template.render(**tdata) else: attributesdict = make_attrs_dict(ATTRIBUTES) if os.environ.get('REQUEST_METHOD') == 'POST': template = lookup.get_template('results.html') edits = {} for k in form: if k.endswith('_attr'): attr = k[:-5] if attributesdict[attr][1]: edits[attr] = form.getlist(k) for attr in attributesdict: if attr not in edits and attributesdict[attr][1]: edits[attr] = None selfserve.ldap.do_details_change(availid, form.getvalue('old_pw'), edits) # TODO: maybe kill the session token here? tdata['message'] = "Details change successful" print template.render(**tdata) else: template = lookup.get_template('changedetails.html') values = selfserve.ldap.fetch_attributes(availid, attributesdict.keys()) attrs = [] for key, (name, editable, multivalue) in ATTRIBUTES: if editable: editword = '' else: editword = 'readonly' if key not in values: editword = 'disabled' attrs.append(Attribute(key, name, editword, ezt.boolean(multivalue), values.get(key, ['<not present>']))) tdata['attributes'] = attrs tdata['dn'] = USER_DN_T % availid print template.render(**tdata) def render_logout(tdata, lookup, form, pathinfo): template = lookup.get_template('results.html') sesskey = pathinfo.split('/')[-1] try: # don't check remote24/cookie selfserve.tokens.kill_token(sesskey) tdata['status'] = 200 tdata['message'] = "Bye, token '%s' removed" % sesskey except selfserve.exceptions.NoSuchToken: tdata['status'] = 200 tdata['message'] = "Bye" except selfserve.exceptions.SS2Exception, ss2e: raise print template.render(**tdata) def render_unknown_uri(tdata, lookup, form, pathinfo): template = lookup.get_template('results.html') tdata['status'] = 500 tdata['message'] = "Unknown URI '%s'" % pathinfo print template.render(**tdata) ### this will go away, but it is handy for the conversion from Mako class CompatTemplate(object): def __init__(self, template): self.template = template def render(self, **kw): buffer = StringIO.StringIO() self.template.generate(buffer, kw) return buffer.getvalue() class CompatLookup(object): PATH = '../templates' def get_template(self, template_name): template = ezt.Template(os.path.join(self.PATH, template_name), base_format=ezt.FORMAT_HTML) return CompatTemplate(template) def start(tdata): pathinfo = os.environ.get("PATH_INFO") logger.debug("pathinfo = %r", pathinfo) lookup = CompatLookup() form = cgi.FieldStorage() # some default values tdata['location'] = None tdata['status'] = None tdata['toolbar'] = None tdata['menu'] = None tdata['messagebox'] = None tdata['message'] = None tdata['availid'] = None tdata['_debug'] = '' # to force a newline, in the presence of whitespace compression tdata['newline'] = '\n' try: if DEBUG_EVERYTHING: # this may include passwords! logger.debug(`form`) if pathinfo in [None, '/']: render_index(tdata, lookup, form, pathinfo) elif pathinfo == '/reset/enter': render_reset(tdata, lookup, form, pathinfo) elif pathinfo.startswith('/reset/token/'): render_token(tdata, lookup, form, pathinfo) elif pathinfo == '/details/login': render_login_redirector(tdata, lookup, form, pathinfo) elif pathinfo.startswith('/details/logout/'): render_logout(tdata, lookup, form, pathinfo) elif pathinfo.startswith('/details/'): render_edit_details(tdata, lookup, form, pathinfo) else: render_unknown_uri(tdata, lookup, form, pathinfo) except selfserve.exceptions.SS2Exception, ss2e: return render_exception(ss2e, tdata, lookup) except Exception, e: return render_exception(e, tdata, lookup) except BaseException, e: return render_exception(e, tdata, lookup) finally: pass class CustomSubjectHandler(logging.handlers.SMTPHandler): def getSubject(self, logrecord): # logging.handlers.SMTPHandler.getSubject(self, logrecord) return logrecord.getMessage().split("\n")[0] def main(): #print "Content-type: text/plain\n\n"; debug_dump() if DEBUG_MODE: cgitb.enable() # TODO config file # TODO don't spam stderr (presumably due to the root logger?) logging.basicConfig( level=logging.__dict__[LOG_LEVEL], #self.setFormatter(logging.Formatter( format=(( "[%(asctime)s]\t[%(processName)s:%(process)d]\t[%(levelname)s]\t[%(filename)s:%(lineno)d %(funcName)s()]\t%(message)s"))) global logger logger = logging.getLogger("%s.app" % LOGGER_NAME) #logger.setLevel(logging.__dict__[LOG_LEVEL]) SCRIPT_NAME = os.environ['SCRIPT_NAME'] tdata = { 'script_name' : SCRIPT_NAME, # ensure SCRIPT_DIRNAME has a trailing slash 'script_dirname' : (os.path.dirname(SCRIPT_NAME)+'/').replace('//','/'), 'base_url' : '%s://%s%s' % (HTTP_PROTOCOL, os.environ['HTTP_HOST'], os.environ['SCRIPT_NAME']), } # add a root logger if DEBUG_MODE: ah = AppendHandler(tdata) logging.getLogger().addHandler(ah) basename = os.path.basename(os.getenv('SCRIPT_FILENAME')) rootMailHandler = CustomSubjectHandler( SMTP_HOST, '"Selfserve (%s)" <%s>' % (basename, FROM_ADDRESS), NOTIFY_TO, "Selfserve <%s>" % basename # unused by the subclass ); rootMailHandler.setLevel(logging.__dict__[LOG_LEVEL_MAIL]) logging.getLogger().addHandler(rootMailHandler) start(tdata) #raise Exception("Hello world")
[]
[]
[ "PATH_INFO", "HTTP_HOST", "REQUEST_METHOD", "SCRIPT_FILENAME", "SCRIPT_NAME", "REMOTE_ADDR" ]
[]
["PATH_INFO", "HTTP_HOST", "REQUEST_METHOD", "SCRIPT_FILENAME", "SCRIPT_NAME", "REMOTE_ADDR"]
python
6
0
lor/test.py
# -*- coding: utf-8 -*- # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # """Testing support This module contains helper functions that downstream workspaces might want to use for testing purposes. """ import os import tempfile from lor import workspace from lor.generators.workspace import workspace_generator class TemporaryEnv(object): """Enable the application's environment (env vars, pwd) to be temporarily mutated, resetting it afterwards. """ def __enter__(self): self.env = os.environ.copy() self.cwd = os.getcwd() return os.environ def __exit__(self, exc_type, exc_val, exc_tb): os.environ.clear() os.environ.update(self.env) os.chdir(self.cwd) if exc_val is not None: raise exc_val else: return True class ChangeWorkspace(object): """Set the global workspace temporarily. """ def __init__(self, ws_path): self.ws_path = ws_path def __enter__(self): self.existing = workspace.get_path() workspace._set_path(self.ws_path) return self.ws_path def __exit__(self, exc_type, exc_val, exc_tb): workspace._set_path(self.existing) if exc_val is not None: raise exc_val else: return True class TemporaryWorkspace(object): """Create a temporary workspace Creates a workspace and sets it as the global workspace temporarily. """ def __enter__(self): self.existing = workspace.get_path() ws_path = os.path.join(tempfile.mkdtemp(), "ws") ws = workspace_generator.create(ws_path) workspace._set_path(ws) return ws def __exit__(self, exc_type, exc_val, exc_tb): workspace._set_path(self.existing) if exc_val is not None: raise exc_val else: return True
[]
[]
[]
[]
[]
python
0
0
mesos/mesos-master/src/main/java/com/bennavetta/aeneas/mesos/master/MesosMaster.java
/** * Copyright 2015 Benjamin Navetta * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.bennavetta.aeneas.mesos.master; import java.io.IOException; import java.nio.file.Path; import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.zeroturnaround.exec.ProcessExecutor; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; /** * Launch a Mesos master instance * @see <a href="http://mesos.apache.org/documentation/latest/configuration/">Mesos Configuration</a> */ public final class MesosMaster { private static final Logger LOG = LoggerFactory.getLogger(MesosMaster.class); private final Map<String, String> configuration = Maps.newHashMap(); private final Path masterExecutable; private Process process; /** * Create a new Mesos master handler that will run the given {@code mesos-master} executable. * @param masterExecutable the path to {@code mesos-master} */ public MesosMaster(Path masterExecutable) { this.masterExecutable = Preconditions.checkNotNull(masterExecutable); } /** * The size of the quorum of replicas when using 'replicated_log' based registry. It is imperative to set this * value to be a majority of masters i.e., quorum > (number of masters)/2. * * @param size the quorum size */ public void setQuorumSize(int size) { setOption("quorum", String.valueOf(size)); } /** * Where to store the persistent information stored in the Registry. * @param workDir a directory path */ public void setWorkDir(String workDir) { setOption("work_dir", workDir); } /** * IP address to listen on * @param ip an IP address */ public void setIp(String ip) { setOption("ip", ip); } /** * Port to listen on (master default: 5050 and slave default: 5051) * @param port a port number */ public void setPort(int port) { setOption("port", String.valueOf(port)); } /** * ZooKeeper URL (used for leader election amongst masters) May be one of: * <ul> * <li>zk://host1:port1,host2:port2,.../path</li> * <li>zk://username:password@host1:port1,host2:port2,.../path</li> * <li>file://path/to/file (where file contains one of the above)</li> * </ul> * @param connection a ZooKeeper connection string */ public void setZk(String connection) { setOption("zk", connection); } public void setOption(String name, String value) { configuration.put(name, value); } public void configureFromEnvironment() { final ImmutableSet<String> ignoredKeys = ImmutableSet.of("version", "download_sha1", "download_url"); System.getenv().forEach((key, value) -> { if(key.startsWith("MESOS_")) { String argName = key.substring(6).toLowerCase(); if(!ignoredKeys.contains(argName)) { setOption(argName, value); } } }); } public void launch() throws IOException { Preconditions.checkState(process == null, "Mesos master already running"); ImmutableMap.Builder<String, String> environment = ImmutableMap.<String, String>builder(); configuration.forEach((key, value) -> environment.put("MESOS_" + key.toUpperCase(), value)); environment.put("MESOS_VERSION", "false"); // Mesos interprets the Dockerfile environment variable as the '--version' flag LOG.info("Starting Mesos master '{}' with configuration {}", masterExecutable, environment.build()); process = new ProcessExecutor() .command(masterExecutable.toAbsolutePath().toString()) .redirectError(System.err) .redirectOutput(System.out) .environment(environment.build()) .destroyOnExit() .start().getProcess(); } public void kill() { Preconditions.checkState(process != null, "Mesos master not running"); process.destroy(); } public int waitFor() throws InterruptedException { Preconditions.checkState(process != null, "Mesos master not running"); return process.waitFor(); } }
[]
[]
[]
[]
[]
java
0
0
go/test/endtoend/mysqlctl/mysqlctl_test.go
/* Copyright 2019 The Vitess Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package mysqlctl import ( "flag" "fmt" "os" "os/exec" "testing" "github.com/stretchr/testify/require" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/test/endtoend/cluster" ) var ( clusterInstance *cluster.LocalProcessCluster masterTablet cluster.Vttablet replicaTablet cluster.Vttablet hostname = "localhost" keyspaceName = "test_keyspace" shardName = "0" cell = "zone1" ) func TestMain(m *testing.M) { flag.Parse() exitCode := func() int { clusterInstance = cluster.NewCluster(cell, hostname) defer clusterInstance.Teardown() // Start topo server err := clusterInstance.StartTopo() if err != nil { return 1 } if err := clusterInstance.VtctlProcess.CreateKeyspace(keyspaceName); err != nil { return 1 } initCluster([]string{"0"}, 2) // Collect tablet paths and ports tablets := clusterInstance.Keyspaces[0].Shards[0].Vttablets for _, tablet := range tablets { if tablet.Type == "master" { masterTablet = *tablet } else if tablet.Type != "rdonly" { replicaTablet = *tablet } } return m.Run() }() os.Exit(exitCode) } func initCluster(shardNames []string, totalTabletsRequired int) { keyspace := cluster.Keyspace{ Name: keyspaceName, } for _, shardName := range shardNames { shard := &cluster.Shard{ Name: shardName, } var mysqlCtlProcessList []*exec.Cmd for i := 0; i < totalTabletsRequired; i++ { // instantiate vttablet object with reserved ports tabletUID := clusterInstance.GetAndReserveTabletUID() tablet := &cluster.Vttablet{ TabletUID: tabletUID, HTTPPort: clusterInstance.GetAndReservePort(), GrpcPort: clusterInstance.GetAndReservePort(), MySQLPort: clusterInstance.GetAndReservePort(), Alias: fmt.Sprintf("%s-%010d", clusterInstance.Cell, tabletUID), } if i == 0 { // Make the first one as master tablet.Type = "master" } // Start Mysqlctl process tablet.MysqlctlProcess = *cluster.MysqlCtlProcessInstance(tablet.TabletUID, tablet.MySQLPort, clusterInstance.TmpDirectory) proc, err := tablet.MysqlctlProcess.StartProcess() if err != nil { return } mysqlCtlProcessList = append(mysqlCtlProcessList, proc) // start vttablet process tablet.VttabletProcess = cluster.VttabletProcessInstance(tablet.HTTPPort, tablet.GrpcPort, tablet.TabletUID, clusterInstance.Cell, shardName, keyspaceName, clusterInstance.VtctldProcess.Port, tablet.Type, clusterInstance.TopoProcess.Port, clusterInstance.Hostname, clusterInstance.TmpDirectory, clusterInstance.VtTabletExtraArgs, clusterInstance.EnableSemiSync) tablet.Alias = tablet.VttabletProcess.TabletPath shard.Vttablets = append(shard.Vttablets, tablet) } for _, proc := range mysqlCtlProcessList { if err := proc.Wait(); err != nil { return } } for _, tablet := range shard.Vttablets { if _, err := tablet.VttabletProcess.QueryTablet(fmt.Sprintf("create database vt_%s", keyspace.Name), keyspace.Name, false); err != nil { log.Error(err.Error()) return } } keyspace.Shards = append(keyspace.Shards, *shard) } clusterInstance.Keyspaces = append(clusterInstance.Keyspaces, keyspace) } func TestRestart(t *testing.T) { err := masterTablet.MysqlctlProcess.Stop() require.Nil(t, err) masterTablet.MysqlctlProcess.CleanupFiles(masterTablet.TabletUID) err = masterTablet.MysqlctlProcess.Start() require.Nil(t, err) } func TestAutoDetect(t *testing.T) { // Start up tablets with an empty MYSQL_FLAVOR, which means auto-detect sqlFlavor := os.Getenv("MYSQL_FLAVOR") os.Setenv("MYSQL_FLAVOR", "") err := clusterInstance.Keyspaces[0].Shards[0].Vttablets[0].VttabletProcess.Setup() require.Nil(t, err, "error should be nil") err = clusterInstance.Keyspaces[0].Shards[0].Vttablets[1].VttabletProcess.Setup() require.Nil(t, err, "error should be nil") // Reparent tablets, which requires flavor detection err = clusterInstance.VtctlclientProcess.InitShardMaster(keyspaceName, shardName, cell, masterTablet.TabletUID) require.Nil(t, err, "error should be nil") //Reset flavor os.Setenv("MYSQL_FLAVOR", sqlFlavor) }
[ "\"MYSQL_FLAVOR\"" ]
[]
[ "MYSQL_FLAVOR" ]
[]
["MYSQL_FLAVOR"]
go
1
0
telebot_test.go
package telebot import ( "fmt" "os" "testing" ) func TestBot(t *testing.T) { if testing.Short() { t.Skip("skipping test in short mode.") } token := os.Getenv("TELEBOT_SECRET") if token == "" { fmt.Println("ERROR: " + "In order to test telebot functionality, you need to set up " + "TELEBOT_SECRET environmental variable, which represents an API " + "key to a Telegram bot.\n") t.Fatal("Could't find TELEBOT_SECRET, aborting.") } _, err := NewBot(Settings{Token: token}) if err != nil { t.Fatal("couldn't create bot:", err) } } func TestRecipient(t *testing.T) { token := os.Getenv("TELEBOT_SECRET") if token == "" { fmt.Println("ERROR: " + "In order to test telebot functionality, you need to set up " + "TELEBOT_SECRET environmental variable, which represents an API " + "key to a Telegram bot.\n") t.Fatal("Could't find TELEBOT_SECRET, aborting.") } bot, err := NewBot(Settings{Token: token}) if err != nil { t.Fatal("couldn't create bot:", err) } bot.Send(&User{}, "") bot.Send(&Chat{}, "") } func TestFile(t *testing.T) { file := FromDisk("telebot.go") if file.InCloud() { t.Fatal("Newly created file can't exist on Telegram servers!") } file.FileID = "magic" if file.FileLocal != "telebot.go" { t.Fatal("File doesn't preserve its original filename.") } } func TestCustomURL(t *testing.T) { token := os.Getenv("TELEBOT_SECRET") if token == "" { fmt.Println("ERROR: " + "In order to test telebot functionality, you need to set up " + "TELEBOT_SECRET environmental variable, which represents an API " + "key to a Telegram bot.\n") t.Fatal("Could't find TELEBOT_SECRET, aborting.") } customURL := "http://api.telegram.org" bot, err := NewBot(Settings{Token: token, URL: customURL}) if err != nil { t.Fatal("couldn't create bot:", err) } if bot.URL != customURL { t.Fatal("custom api url is not set") } }
[ "\"TELEBOT_SECRET\"", "\"TELEBOT_SECRET\"", "\"TELEBOT_SECRET\"" ]
[]
[ "TELEBOT_SECRET" ]
[]
["TELEBOT_SECRET"]
go
1
0
main/backspaceCompare_test.go
package main import "testing" /** goos: darwin goarch: amd64 BenchmarkBackspaceCompare1-4 100000000 12.6 ns/op 0 B/op 0 allocs/op BenchmarkBackspaceCompareMy1-4 500000 2200 ns/op 928 B/op 51 allocs/op PASS ok command-line-arguments 2.406s */ func BenchmarkBackspaceCompare1(b *testing.B) { for i := 0; i < b.N; i++ { backspaceCompare1("sdgfasgfgqugofgeyegqufg#######asdfasf", "dyaadsuigfyuegquygasdhgfaosgd#####sdgf") } } func BenchmarkBackspaceCompareMy1(b *testing.B) { for i := 0; i < b.N; i++ { backspaceCompareMy1("sdgfasgfgqugofgeyegqufg#######asdfasf", "dyaadsuigfyuegquygasdhgfaosgd#####sdgf") } } func backspaceCompare1(S string, T string) bool { slen, tlen := len(S), len(T) if slen == 0 && tlen == 0 { return true } scur, tcur := slen-1, tlen-1 sbs, tbs := 0, 0 for { for scur >= 0 && (S[scur] == '#' || sbs > 0) { if S[scur] == '#' { sbs++ } else { sbs-- } scur-- } for tcur >= 0 && (T[tcur] == '#' || tbs > 0) { if T[tcur] == '#' { tbs++ } else { tbs-- } tcur-- } if (scur == 0 && tcur == 0) || (scur < 0 && tcur < 0) { return true } else if (scur >= 0 && tcur < 0) || (scur < 0 && tcur >= 0) || S[scur] != T[tcur] { return false } scur-- tcur-- } } func backspaceCompareMy1(S string, T string) bool { s := "" istep := 0 for i := len(S) - 1; i >= 0; i-- { if S[i] == '#' { istep++ continue } if istep > 0 { istep-- continue } s = string(S[i]) + s } t := "" lstep := 0 for l := len(T) - 1; l >= 0; l-- { if T[l] == '#' { lstep++ continue } if lstep > 0 { lstep-- continue } t = string(T[l]) + t } return s == t }
[]
[]
[]
[]
[]
go
null
null
null
server/config_test.go
package server import ( "os" "testing" ) func compareString(t *testing.T, name string, str, exp string, i int) { if str != exp { t.Fatalf("expected %s to be:\n%s\nbut got:\n%s\nin test #%d", name, exp, str, i+1) } } func compareStringPtr(t *testing.T, name string, str, exp *string, i int) { if str == exp { return } if str == nil && exp != nil { t.Fatalf("expected %s to be:\n%s\nbut got:\nnil\nin test %d", name, *exp, i+1) } else if str != nil && exp == nil { t.Fatalf("expected %s to be:\nnil\nbut got:\n%s\nin test %d", name, *str, i+1) } else if *str != *exp { t.Fatalf("expected %s to be:\n%s\nbut got:\n%s\nin test %d", name, *exp, *str, i+1) } } // Test config prepare method func TestConfigPrepare(t *testing.T) { defaultAddr := "0.0.0.0" emptyAddr := "" localAddr := "127.0.0.1" ipv6Addr := "::1" invalidAddr := "127.0.0" invalidHeaderAuth := "test" allowOriginAll := "*" allowOriginSingle := "http://resgate.io" allowOriginMultiple := "http://localhost;http://resgate.io" allowOriginInvalidEmpty := "" allowOriginInvalidEmptyOrigin := ";http://localhost" allowOriginInvalidMultipleAll := "http://localhost;*" allowOriginInvalidMultipleSame := "http://localhost;*" allowOriginInvalidOrigin := "http://this.is/invalid" method := "foo" invalidMethod := "foo.bar" defaultCfg := Config{} defaultCfg.SetDefault() tbl := []struct { Initial Config Expected Config PrepareError bool }{ // Valid config {defaultCfg, Config{Addr: &defaultAddr, Port: 8080, WSPath: "/", APIPath: "/api/", APIEncoding: "json", scheme: "http", netAddr: "0.0.0.0:8080", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, {Config{WSPath: "/"}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, {Config{Addr: &emptyAddr, WSPath: "/"}, Config{Addr: &emptyAddr, Port: 80, WSPath: "/", APIPath: "/", scheme: "http", netAddr: ":80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, {Config{Addr: &localAddr, WSPath: "/"}, Config{Addr: &localAddr, Port: 80, WSPath: "/", APIPath: "/", scheme: "http", netAddr: "127.0.0.1:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, {Config{Addr: &ipv6Addr, WSPath: "/"}, Config{Addr: &ipv6Addr, Port: 80, WSPath: "/", APIPath: "/", scheme: "http", netAddr: "[::1]:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, // Allow origin {Config{AllowOrigin: &allowOriginAll, WSPath: "/"}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, {Config{AllowOrigin: &allowOriginSingle, WSPath: "/"}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"http://resgate.io"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, {Config{AllowOrigin: &allowOriginMultiple, WSPath: "/"}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"http://localhost", "http://resgate.io"}, allowMethods: "GET, HEAD, OPTIONS, POST"}, false}, // HTTP method mapping {Config{WSPath: "/", PUTMethod: &method}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", PUTMethod: &method, scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST, PUT"}, false}, {Config{WSPath: "/", DELETEMethod: &method}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", DELETEMethod: &method, scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST, DELETE"}, false}, {Config{WSPath: "/", PATCHMethod: &method}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", PATCHMethod: &method, scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST, PATCH"}, false}, {Config{WSPath: "/", PUTMethod: &method, DELETEMethod: &method, PATCHMethod: &method}, Config{Addr: nil, Port: 80, WSPath: "/", APIPath: "/", PUTMethod: &method, DELETEMethod: &method, PATCHMethod: &method, scheme: "http", netAddr: "0.0.0.0:80", allowOrigin: []string{"*"}, allowMethods: "GET, HEAD, OPTIONS, POST, PUT, DELETE, PATCH"}, false}, // Invalid config {Config{Addr: &invalidAddr, WSPath: "/"}, Config{}, true}, {Config{HeaderAuth: &invalidHeaderAuth, WSPath: "/"}, Config{}, true}, {Config{AllowOrigin: &allowOriginInvalidEmpty, WSPath: "/"}, Config{}, true}, {Config{AllowOrigin: &allowOriginInvalidEmptyOrigin, WSPath: "/"}, Config{}, true}, {Config{AllowOrigin: &allowOriginInvalidMultipleAll, WSPath: "/"}, Config{}, true}, {Config{AllowOrigin: &allowOriginInvalidMultipleSame, WSPath: "/"}, Config{}, true}, {Config{AllowOrigin: &allowOriginInvalidOrigin, WSPath: "/"}, Config{}, true}, {Config{PUTMethod: &invalidMethod, WSPath: "/"}, Config{}, true}, {Config{DELETEMethod: &invalidMethod, WSPath: "/"}, Config{}, true}, {Config{PATCHMethod: &invalidMethod, WSPath: "/"}, Config{}, true}, } for i, r := range tbl { cfg := r.Initial err := cfg.prepare() if err != nil { if !r.PrepareError { t.Fatalf("expected no error, but got:\n%s\nin test #%d", err, i+1) } continue } else if r.PrepareError { t.Fatalf("expected an error, but got none, in test #%d", i+1) } compareString(t, "WSPath", cfg.WSPath, r.Expected.WSPath, i) compareString(t, "APIPath", cfg.APIPath, r.Expected.APIPath, i) compareString(t, "APIEncoding", cfg.APIEncoding, r.Expected.APIEncoding, i) compareStringPtr(t, "Addr", cfg.Addr, r.Expected.Addr, i) compareStringPtr(t, "PUTMethod", cfg.PUTMethod, r.Expected.PUTMethod, i) compareStringPtr(t, "DELETEMethod", cfg.DELETEMethod, r.Expected.DELETEMethod, i) compareStringPtr(t, "PATCHMethod", cfg.PATCHMethod, r.Expected.PATCHMethod, i) if cfg.Port != r.Expected.Port { t.Fatalf("expected Port to be:\n%d\nbut got:\n%d\nin test %d", r.Expected.Port, cfg.Port, i+1) } compareString(t, "scheme", cfg.scheme, r.Expected.scheme, i) compareString(t, "netAddr", cfg.netAddr, r.Expected.netAddr, i) compareString(t, "headerAuthAction", cfg.headerAuthAction, r.Expected.headerAuthAction, i) compareString(t, "headerAuthRID", cfg.headerAuthRID, r.Expected.headerAuthRID, i) compareString(t, "allowMethods", cfg.allowMethods, r.Expected.allowMethods, i) if len(cfg.allowOrigin) != len(r.Expected.allowOrigin) { t.Fatalf("expected allowOrigin to be:\n%+v\nbut got:\n%+v\nin test %d", r.Expected.allowOrigin, cfg.allowOrigin, i+1) } for i, origin := range cfg.allowOrigin { if origin != r.Expected.allowOrigin[i] { t.Fatalf("expected allowOrigin to be:\n%+v\nbut got:\n%+v\nin test %d", r.Expected.allowOrigin, cfg.allowOrigin, i+1) } } compareStringPtr(t, "HeaderAuth", cfg.HeaderAuth, r.Expected.HeaderAuth, i) } } // Test NewService configuration error func TestNewServiceConfigError(t *testing.T) { tbl := []struct { Initial Config ServiceError bool }{ {Config{}, false}, {Config{APIEncoding: "json"}, false}, {Config{APIEncoding: "JSON"}, false}, {Config{APIEncoding: "jsonFlat"}, false}, {Config{APIEncoding: "jsonflat"}, false}, {Config{APIEncoding: "test"}, true}, } for i, r := range tbl { cfg := r.Initial cfg.SetDefault() _, err := NewService(nil, cfg) if err != nil && !r.ServiceError { t.Fatalf("expected no error, but got:\n%s\nin test #%d", err, i+1) } else if err == nil && r.ServiceError { t.Fatalf("expected an error, but got none, in test #%d", i+1) } } } // Test that the travis version tag (if existing) matches that // of the Version constant. func TestVersionMatchesTag(t *testing.T) { tag := os.Getenv("TRAVIS_TAG") if tag == "" { t.SkipNow() } if tag[0] != 'v' { t.Fatalf("Expected tag to start with `v`, got %+v", tag) } if Version != tag[1:] { t.Fatalf("Expected version %+v, got %+v", Version, tag[1:]) } } func TestMatchesOrigins(t *testing.T) { tbl := []struct { AllowedOrigins []string Origin string Expected bool }{ {[]string{"http://localhost"}, "http://localhost", true}, {[]string{"https://resgate.io"}, "https://resgate.io", true}, {[]string{"https://resgate.io"}, "https://Resgate.IO", true}, {[]string{"http://localhost", "https://resgate.io"}, "http://localhost", true}, {[]string{"http://localhost", "https://resgate.io"}, "https://resgate.io", true}, {[]string{"http://localhost", "https://resgate.io"}, "https://Resgate.IO", true}, {[]string{"http://localhost", "https://resgate.io", "http://resgate.io"}, "http://Localhost", true}, {[]string{"http://localhost", "https://resgate.io", "http://resgate.io"}, "https://Resgate.io", true}, {[]string{"http://localhost", "https://resgate.io", "http://resgate.io"}, "http://resgate.IO", true}, {[]string{"https://resgate.io"}, "http://resgate.io", false}, {[]string{"http://localhost", "https://resgate.io"}, "http://resgate.io", false}, {[]string{"http://localhost", "https://resgate.io", "http://resgate.io"}, "http://localhost/", false}, } for i, r := range tbl { if matchesOrigins(r.AllowedOrigins, r.Origin) != r.Expected { t.Fatalf("expected matchesOrigins to return %#v\n\tmatchesOrigins(%#v, %#v)\n\tin test #%d", r.Expected, r.AllowedOrigins, r.Origin, i+1) } } }
[ "\"TRAVIS_TAG\"" ]
[]
[ "TRAVIS_TAG" ]
[]
["TRAVIS_TAG"]
go
1
0
Megatron-LM-v1.1.5-ZeRO3/megatron/initialize.py
# coding=utf-8 # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Megatron initialization.""" import random import os import numpy as np import torch from megatron import get_adlr_autoresume from megatron import get_args from megatron import get_tensorboard_writer from megatron import mpu from megatron.global_vars import set_global_variables from megatron.mpu import set_model_parallel_rank, set_model_parallel_world_size import deepspeed def initialize_megatron(extra_args_provider=None, args_defaults={}, ignore_unknown_args=False, allow_no_cuda=False): """Set global variables, initialize distributed, and set autoresume and random seeds. `allow_no_cuda` should not be set unless using megatron for cpu only data processing. In general this arg should not be set unless you know what you are doing. Returns a function to finalize distributed env initialization (optionally, only when args.lazy_mpu_init == True) """ if not allow_no_cuda: # Make sure cuda is available. assert torch.cuda.is_available(), 'Megatron requires CUDA.' # Parse args, build tokenizer, and set adlr-autoresume, # tensorboard-writer, and timers. set_global_variables(extra_args_provider=extra_args_provider, args_defaults=args_defaults, ignore_unknown_args=ignore_unknown_args) # torch.distributed initialization def finish_mpu_init(): args = get_args() # Pytorch distributed. _initialize_distributed() # Random seeds for reproducibility. if args.rank == 0: print('> setting random seeds to {} ...'.format(args.seed)) _set_random_seed(args.seed) args = get_args() if args.lazy_mpu_init: args.use_cpu_initialization=True # delayed initialization of DDP-related stuff # We only set basic DDP globals set_model_parallel_world_size(args.model_parallel_size) # and return function for external DDP manager to call when it has DDP initialized set_model_parallel_rank(args.rank) return finish_mpu_init else: # Megatron's MPU is the master. Complete initialization right away. finish_mpu_init() # Initialize memory buffers. _initialize_mem_buffs() # Autoresume. _init_autoresume() # Write arguments to tensorboard. _write_args_to_tensorboard() # No continuation function return None def setup_deepspeed_random_and_activation_checkpointing(args): '''Optional DeepSpeed Activation Checkpointing features. Gives access to partition activations, contiguous memory optimizations and cpu checkpointing. Activation checkpoint requires keep track of the random states and setting the random seed for each MP process. Megatron uses mpu.get_cuda_rng_tracker and mpu.model_parallel_cuda_manual_seed for keeping track of the random states and setting the random seeds. Since they are used in places outside of activation checkpointing, we overwrite them to maintain consistency. This must be called before all the calls to mpu.model_parallel_cuda_manual_seed ''' num_layers = args.num_layers // args.checkpoint_num_layers num_layers = num_layers if args.num_layers % args.checkpoint_num_layers == 0 else num_layers + 1 if args.split_transformers: num_layers *= 2 deepspeed.checkpointing.configure( mpu, partition_activations=args.partition_activations, contiguous_checkpointing=args.contigious_checkpointing, num_checkpoints=num_layers, checkpoint_in_cpu=args.checkpoint_in_cpu, synchronize=args.synchronize_each_layer, profile=args.profile_backward) mpu.checkpoint = deepspeed.checkpointing.checkpoint mpu.get_cuda_rng_tracker = deepspeed.checkpointing.get_cuda_rng_tracker mpu.model_parallel_cuda_manual_seed = deepspeed.checkpointing.model_parallel_cuda_manual_seed def _initialize_distributed(): """Initialize torch.distributed and mpu.""" args = get_args() device_count = torch.cuda.device_count() if torch.distributed.is_initialized(): if args.rank == 0: print('torch distributed is already initialized, ' 'skipping initialization ...', flush=True) args.rank = torch.distributed.get_rank() args.world_size = torch.distributed.get_world_size() else: if args.rank == 0: print('> initializing torch distributed ...', flush=True) # Manually set the device ids. if device_count > 0: device = args.rank % device_count if args.local_rank is not None: assert args.local_rank == device, \ 'expected local-rank to be the same as rank % device-count.' else: args.local_rank = device torch.cuda.set_device(device) # Call the init process init_method = 'tcp://' master_ip = os.getenv('MASTER_ADDR', 'localhost') master_port = os.getenv('MASTER_PORT', '6000') init_method += master_ip + ':' + master_port torch.distributed.init_process_group( backend=args.distributed_backend, world_size=args.world_size, rank=args.rank, init_method=init_method) # Set the model-parallel / data-parallel communicators. if device_count > 0: if mpu.model_parallel_is_initialized(): print('model parallel is already initialized') else: mpu.initialize_model_parallel(args.model_parallel_size) # Optional DeepSpeed Activation Checkpointing Features # if args.deepspeed and args.deepspeed_activation_checkpointing: setup_deepspeed_random_and_activation_checkpointing(args) def _init_autoresume(): """Set autoresume start time.""" autoresume = get_adlr_autoresume() if autoresume: torch.distributed.barrier() autoresume.init() torch.distributed.barrier() def _set_random_seed(seed): """Set random seed for reproducability.""" if seed is not None and seed > 0: random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) if torch.cuda.device_count() > 0: mpu.model_parallel_cuda_manual_seed(seed) else: raise ValueError('Seed ({}) should be a positive integer.'.format(seed)) def _write_args_to_tensorboard(): """Write arguments to tensorboard.""" args = get_args() writer = get_tensorboard_writer() if writer: for arg in vars(args): writer.add_text(arg, str(getattr(args, arg))) def _initialize_mem_buffs(): """Initialize manually allocated static memory.""" args = get_args() # Initialize memory for checkpointed activations. if args.distribute_checkpointed_activations: mpu.init_checkpointed_activations_memory_buffer()
[]
[]
[ "MASTER_ADDR", "MASTER_PORT" ]
[]
["MASTER_ADDR", "MASTER_PORT"]
python
2
0
Tools/tdd/src/testAllPkgs.py
############################################################################### # Copyright (c) 2021, Milan Neubert ([email protected]) # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # 3. Neither the name of the copyright holder nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, # OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE # OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, # EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ############################################################################### import threading import TDDConfig from TDDConfig import CEnvCfg import tdd_support import readchar import os import time from tabulate import tabulate import CodeStatistics import colorama from colorama import Fore, Style from pathlib import Path import subprocess import KeyPressThread import keyboard # import sys import cmakeSupport as CS env_bckp = os.environ.copy() def assertWithText(condition, text): ''' Assertion wrapping function ''' assert condition, text def removeDirectory(path: Path): ''' Function for removing directory ''' if path.is_dir(): tdd_support.del_folder(path) assertWithText(not path.is_dir(), "Something went wrong. Path(%s) was not deleted!" % (str(path))) def backUpEnvVariable(): env_bckp = os.environ.copy() def setEnvVariable(co_env: CEnvCfg): os.environ['PATH'] = co_env.str_cmake + ";" + os.environ['PATH'] os.environ['PATH'] = co_env.str_mingw + ";" + os.environ['PATH'] os.environ['PATH'] = co_env.str_cppcheck + ";" + os.environ['PATH'] os.environ['PATH'] = co_env.str_clang + ";" + os.environ['PATH'] os.environ['PATH'] = co_env.str_cppumockgen + ";" + os.environ['PATH'] def resetEnvVariable(): os.environ = env_bckp def testOnePkg(pckgDir, mCfg): print(pckgDir) kpt = KeyPressThread.KeyboardThread() backUpEnvVariable() setEnvVariable(mCfg.co_env) str_testPackagesPath = mCfg.co_pkg.str_testpath str_testPackageSuffix = mCfg.co_pkg.str_testfldr_suffix len_tpkgS = len(str_testPackageSuffix) path_dir = Path(str_testPackagesPath).glob("*_Tpkg") dir_lst = [folder for folder in path_dir if folder.is_dir()] lst_testDir = [] for dir in dir_lst: strdir = str(dir.stem) if (strdir[-len_tpkgS:] == str_testPackageSuffix): lst_testDir.append(strdir) task_lst = [CTestPkg(pckg, mCfg, kpt) for pckg in lst_testDir] pTask = None for task in task_lst: if task.name == pckgDir: pTask = task break pTask.b_silent = False pTask.run() # revert environment varaiables resetEnvVariable() print("Press any key to quit.\n") # keyboard.read_key() readchar.readkey() def debug(lstPackage, mainCfg): kpt = KeyPressThread.KeyboardThreadDbg() task_lst = [CTestPkg(pckg, mainCfg, kpt) for pckg in lstPackage] id = 1 task_lst[id].b_silent = False task_lst[id].run() def tests_minimized(lstPackage, mainCfg): colorama.init() backUpEnvVariable() setEnvVariable(mainCfg.co_env) kpt = KeyPressThread.KeyboardThread() task_lst = [CTestPkgThread(pckg, mainCfg, kpt) for pckg in lstPackage] numTasks = len(task_lst) resultTabRef = [] tdd_support.clear() while(True): numOfTerminated = 0 numOfIdle = 0 resultTab = [] for task in task_lst: result = [ task.name, task.str_step, task.str_status, task.str_testStatus, task.str_uncoverage, task.str_analysis, task.str_complexity] resultTab.append(result) if "Terminated" in task.str_status: numOfTerminated += 1 if "Idle" in task.str_status: numOfIdle += 1 if numOfTerminated == numTasks: break bRewrite = False if not resultTabRef: bRewrite = True else: bIsSame = True for idx in range(len(resultTab)): for idy in range(len(resultTab[0])): bIsSame *= (resultTab[idx][idy] == resultTabRef[idx][idy]) if not bIsSame: bRewrite = True if bRewrite: resultTabRef = resultTab errPkgList = [] #tdd_support.clear() #print(result[1]) statusStr = "" resultStr = "" # for id in range(3): # resultStr += chr(0x00BC + id) # resultStr += "|" colorChar = Style.RESET_ALL for result in resultTab: # statusStr += result[1] + " " charAsNum = 0x20 if result[1] in ["CMake", "Makefile"]: # charAsNum = 177 charAsNum = 0xBC if result[1] == "Test": charAsNum = 0xBD # charAsNum = 66 if result[1] in ["Coverage", "StaticCheck", "Analysis"]: charAsNum = 0xBE # charAsNum = 67 if result[1] == "Finished": charAsNum = 0x2588 statusStr += result[3] + " " # StatusList = ["Empty" "Fail" "Pass"] if "Empty" in result[3]: colorChar = Fore.YELLOW if "Fail" in result[3]: colorChar = Fore.RED errPkgList.append(result[0]) if "Pass" in result[3]: colorChar = Fore.GREEN resultStr += colorChar + chr(charAsNum) + Style.RESET_ALL tdd_support.clear() print("[%s]" % (resultStr)) if errPkgList: print("Corrupted or incompilable tests:") for errPkg in errPkgList: print(Fore.RED + errPkg + Style.RESET_ALL) # sys.stdout.write("\r") # sys.stdout.flush() # sys.stdout.write("\r\r[%s]" % (resultStr)) # sys.stdout.flush() # sys.stdout.write("\r[%s]%s" % (resultStr, 5*" ")) # print("[%s], [%s]" % (resultStr, statusStr)) # sys.stdout.write("\r[%s]" % (resultStr)) # sys.stdout.write("[%s]\n" % (resultStr)) #sys.stdout.write("[%s] %s\n" % (resultStr, statusStr)) # print(tabulate(resultTab, headerTab, tablefmt="pretty")) time.sleep(0.5) # revert environment varaiables resetEnvVariable() print("Press any key to quit.\n") readchar.readkey() def tests(lstPackage, mainCfg): colorama.init() # print("Test all pkgs") # print(lstPackage) # debug(lstPackage, mainCfg) backUpEnvVariable() setEnvVariable(mainCfg.co_env) kpt = KeyPressThread.KeyboardThread() task_lst = [CTestPkgThread(pckg, mainCfg, kpt) for pckg in lstPackage] numTasks = len(task_lst) headerTab = [ "Name", "Step", "Status", "Test Status", "Noncovered line", "Static err", "Complexity err"] resultTabRef = [] while(True): numOfTerminated = 0 resultTab = [] for task in task_lst: result = [ task.name, task.str_step, task.str_status, task.str_testStatus, task.str_uncoverage, task.str_analysis, task.str_complexity] resultTab.append(result) if "Terminated" in task.str_status: numOfTerminated += 1 if numOfTerminated == numTasks: break bRewrite = False if not resultTabRef: bRewrite = True else: bIsSame = True for idx in range(len(resultTab)): for idy in range(len(resultTab[0])): bIsSame *= (resultTab[idx][idy] == resultTabRef[idx][idy]) if not bIsSame: bRewrite = True if bRewrite: resultTabRef = resultTab tdd_support.clear() print(tabulate(resultTab, headerTab, tablefmt="pretty")) # print(tabulate(resultTab)) time.sleep(1) resultTab = [] for task in task_lst: result = [ task.name, task.str_step, task.str_status, task.str_testStatus, task.str_uncoverage, task.str_analysis, task.str_complexity] resultTab.append(result) tdd_support.clear() print(tabulate(resultTab, headerTab, tablefmt="pretty")) # revert environment varaiables resetEnvVariable() print("Press any key to quit.\n") readchar.readkey() # keyboard.read_key() class CTestPkg(): str_step: str str_status: str str_testBinName: str str_uncoverage: str str_testStatus: str str_analysis: str str_complexity: str path_buildFldr: Path path_TpkgRoot: Path str_srcFldr: str str_TpkgRoot: str tCfg: TDDConfig.CTestConfig b_silent: bool str_cmakeName: str b_infiniteRun: bool LS_chckLFile: [str] LS_srcL: [str] LS_dstL: [str] dic_chckFiles: {} IncMockLst: [] def __init__(self, name, mainCfg, kpt): # super(CTestPkg, self).__init__(name=name) self.mCfg = mainCfg self.name = name self.str_testBinName = CS.getTestBinaryName() self.str_step = "Created" self.str_status = "Ready" self.str_uncoverage = "Empty" self.str_testStatus = "Empty" self.str_analysis = "Empty" self.str_complexity = "Empty" self.path_buildFldr = Path("") self.path_TpkgRoot = Path(self.mCfg.co_pkg.str_testpath) / self.name self.str_TpkgRoot = str(self.path_TpkgRoot) self.str_srcFldr = "" self.tCfg = TDDConfig.CTestConfig() self.b_silent = False self.str_testType = "single" self.str_cmakeName = "" self.b_infiniteRun = True self.LS_chckLFile = [] self.LS_srcL = [] self.LS_dstL = [] self.dic_chckFiles = {} self.thread_keyPress = kpt self.IncMockLst = [] self.DicMock = {} self.DickCppMock = {} self.dic_chckMockFiles = {} self.dic_chckCppMockFiles = {} # self.start() def __getBuildFolderName__(self): return self.tCfg.co_testToolchain.str_compiler + self.mCfg.co_pkg.str_buildsuffix + "_" + self.str_testType def __getBuildFolderPath__(self): return self.path_TpkgRoot / self.__getBuildFolderName__() def __readInit__(self): self.__writeStep__("Read inifile") iniFile = self.path_TpkgRoot / self.mCfg.co_pkg.str_testcfgfilename self.tCfg.readCfgFile(str(iniFile)) pass def __createCmake__(self): self.__writeStep__("Gen CMake") # self.str_cmakeName = tdd_support.getCompilerNameInTestConfig(self.tCfg) self.str_cmakeName = self.tCfg.co_testToolchain.str_compiler self.str_cmakeName += "_" + self.str_testType self.str_cmakeName += ".cmake" path_cmakelist = Path(self.mCfg.co_pkg.str_testpath) / \ self.name / self.str_cmakeName str_cmakelist = str(path_cmakelist) if path_cmakelist.is_file(): try: path_cmakelist.unlink() except BaseException: print('Error: removing CMakeLists.txt failed.') self.__writeStep__("Creating CMakeLists") cmakeGen = CS.CCMakeGenerator(str_cmakelist, self.str_testType,self.mCfg, self.tCfg ) cmakeGen.generate() pass def __fileCopying__(self): self.__writeStep__("Copy files") # copy all files and create lists self.LS_srcL, self.LS_dstL, self.LS_chckLFile, self.DicMock, self.DicCppMock, self.IncMockLst = tdd_support.processAllFilesAndReturnListOfThem( self.name, self.mCfg, self.tCfg, self.str_testType) # create dictionary key is chckLFile, value status_time self.dic_chckFiles = { chckF: os.stat(chckF).st_mtime for chckF in self.LS_chckLFile} self.dic_chckMockFiles = {chckF: os.stat(chckF).st_mtime for chckF in self.DicMock} self.dic_chckCppMockFiles = {chckF: os.stat(chckF).st_mtime for chckF in self.DicCppMock} # self.str_srcFldr self.str_srcFldr = tdd_support.getSrcTestTempFolderName( self.tCfg, self.mCfg, self.str_testType) self.path_buildFldr = self.__getBuildFolderPath__() removeDirectory(self.path_buildFldr) self.path_buildFldr.mkdir() pass def __fileCopyingUpdatedOnly__(self): locdic_chckFiles = { chckF: os.stat(chckF).st_mtime for chckF in self.LS_chckLFile} for id_file, str_file in enumerate(self.LS_chckLFile): if locdic_chckFiles.get(str_file) != self.dic_chckFiles.get(str_file): # check list could be bigger than source and dst list. if id_file < len(self.LS_dstL): Path(self.LS_dstL[id_file]).write_text( Path(self.LS_srcL[id_file]).read_text()) self.dic_chckFiles = locdic_chckFiles def __cmake__(self): self.__writeStep__("CMake") op_cmakeLst = [] op_cmakeLst.append("cmake") # root folder (position of cmakefile) op_cmakeLst.append("-S") op_cmakeLst.append(self.str_TpkgRoot) op_cmakeLst.append("-B") op_cmakeLst.append(str(self.path_buildFldr)) op_cmakeLst.append("-G") op_cmakeLst.append(CS.getGeneratorName(self.tCfg)) op_cmakeLst.append("-DTDD_FRAMEWORK_ROOT_DIR=%s" % str(Path.cwd())) op_cmakeLst.append("-DCMAKE_CXX_OUTPUT_EXTENSION_REPLACE=ON") if True == self.tCfg.co_debugconfig.isDebugConfigOn: op_cmakeLst.append('-DCMAKE_BUILD_TYPE=Debug') op_cmakeLst.append("-DCMAKELISTS_NAME=" + self.str_cmakeName) if self.b_silent: op_cmakeLst.append(">") op_cmakeLst.append(str(self.path_buildFldr / "cmake.out")) op_cmakeLst.append("2>") op_cmakeLst.append(str(self.path_buildFldr / "cmake.err")) # print(op_cmakeLst) subprocess.call(op_cmakeLst, shell=True) def __make__(self): self.__writeStep__("Makefile") testAppPath = self.path_buildFldr / self.str_testBinName if testAppPath.is_file(): try: testAppPath.unlink() except BaseException: with open("debug.log", "a") as log: log.write("BaseException when trying to delete this file: " + testAppPath + "\n") pass op_makeLst = [] op_makeLst.append(CS.getMaketoolName(self.tCfg)) op_makeLst.append('-C') op_makeLst.append(str(self.path_buildFldr)) if self.b_silent: op_makeLst.append('>') op_makeLst.append(str(self.path_buildFldr / "makefile.out")) op_makeLst.append('2>') op_makeLst.append(str(self.path_buildFldr / "makefile.err")) subprocess.call(op_makeLst, shell=True) if not (self.path_buildFldr / self.str_testBinName).is_file(): self.__writeStatus__("Terminated") self.str_testStatus = "Fail" return(False) return(True) def __runTestBin__(self): bRetVal = True testAppPath = str(self.path_buildFldr / self.str_testBinName) outF = str(self.path_buildFldr / "testbin.out") errF = str(self.path_buildFldr / "testbin.err") self.__writeStep__("Test") op_testRunLst = [] op_testRunLst.append(testAppPath) if self.b_silent: op_testRunLst.append(">") op_testRunLst.append(outF) op_testRunLst.append("2>") op_testRunLst.append(errF) else: op_testRunLst.append("-v") op_testRunLst.append("-c") print(10*'-' + '< ' + self.name + ' >' + 10*'-' + '\n') intRetVal = subprocess.call(op_testRunLst, shell=True) if self.b_silent: testResult = 0 if intRetVal <= 1 : testResult = tdd_support.interpretCPPUTESToutput(outF) if testResult == True: self.str_testStatus = Fore.GREEN + "Pass" + Style.RESET_ALL else: self.str_testStatus = Fore.RED + "Fail" + Style.RESET_ALL bRetVal = False else: if not ( intRetVal in range(0,100) ): print(Fore.RED + '\nSomething is rotten in (Denmark) that code.') print('Test application terminate with this error: %i' % intRetVal) print(Style.RESET_ALL) return(bRetVal) def __coverage__(self, sutList: [str], silent=True): # if tdd_support.isCoverageEnabled(self.tCfg): if self.tCfg.co_coverage.isTurnedOn: self.__writeStep__("Coverage") cover_out = str(self.path_buildFldr / "coverage.out") cover_err = str(self.path_buildFldr / "coverage.err") covCmdLst = [] # gcovr --object-directory CMakeFiles\TestApp.dir\mingw_tmp_single -r ..\mingw_tmp_single\ -f "\.\./mingw_tmp_single/Calculator.cpp" -b --txt cov_vypis.txt --html cov\cov_html.html --html-details cov\coverage_details.html covCmdLst.append("gcov") covCmdLst.append("--object-directory") covCmdLst.append( str(Path("CMakeFiles") / "TestApp.dir" / self.str_srcFldr)) for sutCovListItem in sutList: covCmdLst.append(str(Path(self.str_TpkgRoot, sutCovListItem))) covCmdLst.append(">") covCmdLst.append("coverage.out") covCmdLst.append("2>") covCmdLst.append("coverage.err") # print(covCmdLst) subprocess.call(covCmdLst, shell=True, cwd=self.path_buildFldr) lst_file, dict_covFile = tdd_support.interpretGCOV2lists( cover_out, self.path_buildFldr) if not lst_file: self.str_uncoverage = Fore.RED + "Fail" + Style.RESET_ALL if not self.b_silent: print(Fore.RED + "Coverage evaluation failed!" + Style.RESET_ALL) return # self.str_uncoverage = "" listLines = [] # sutFileNames = [sutFileName.split( # "\\")[-1] for sutFileName in sutList] sutFileNames = [str(Path(sutFileName).name) for sutFileName in sutList] isCoverageProblem = False for key in dict_covFile: # if not key.contain(".hpp."): # if dict_covFile[key] : # print( key,"Uncovered lines: ", dict_covFile[key]) if any(sfname in key for sfname in sutFileNames): cntUncov = len(set(dict_covFile[key])) if cntUncov: str_uncov = Fore.RED isCoverageProblem = True else: str_uncov = Fore.GREEN str_uncov += str(cntUncov) + Style.RESET_ALL listLines.append(str_uncov) # else : # listLines.append("0") self.str_uncoverage = ','.join(listLines) if not self.b_silent: print("Non covered lines: " + self.str_uncoverage) if isCoverageProblem: pass # This is probably obsolete, but with coverage can be trouble with different behavior for c and c++ # print( # "Some lines could be duplicite" # + " because c++ create multiple implementation of functions") for file in dict_covFile: lineLst = list(set(dict_covFile[file])) lineLst.sort() # res = [] # [res.append(x) for x in lineLst if x not in res] # lenOfLineLst = len(res) lenOfLineLst = len(lineLst) if lenOfLineLst != 0: # strLineLst = ", ".join(res) strLineLst = ", ".join(lineLst) print(Fore.LIGHTRED_EX + '.'.join(file.split(".")[ :-1]) + " [ " + strLineLst + "]" + Style.RESET_ALL) else: self.str_uncoverage = Fore.YELLOW + "OFF" + Style.RESET_ALL def __staticCheck__(self, sutList: [str]): if self.tCfg.co_staticAnalysis.isTurnedOn: self.__writeStep__("StaticCheck") op_lst = [] op_lst.append("cppcheck") op_lst.append("--enable=all") op_lst.append("--inconclusive") op_lst.append("--library=posix") if not self.tCfg.co_staticAnalysis.isLanguageDefinedBySuffix: op_lst.append("--language=" + self.tCfg.co_staticAnalysis.str_ForcedLang) op_lst.append("--std=" + self.tCfg.co_staticAnalysis.str_c_version) op_lst.append( "--std=" + self.tCfg.co_staticAnalysis.str_cpp_version) for supp in self.tCfg.co_staticAnalysis.suppressionLst: op_lst.append("--suppress=" + supp) # TODO add switch for turning all to C++ file. Configurable from test.ini # add c++ version standard # op_statCheck += "--std=c++11 " check_out = str(self.path_buildFldr / "cppcheck.out") check_err = str(self.path_buildFldr / "cppcheck.err") for sutListItem in sutList: op_lst.append(str(self.path_buildFldr / sutListItem)) op_lst.append("-I") op_lst.append(str(self.path_buildFldr / ".." / self.str_srcFldr)) op_lst.append(">") op_lst.append(check_out) op_lst.append("2>") op_lst.append(check_err) # print(op_lst) subprocess.call(op_lst, shell=True) numOfError = tdd_support.interpretCPPCHECKerrors(check_err) if numOfError != 0: self.str_analysis = Fore.RED else: self.str_analysis = Fore.GREEN self.str_analysis += str(numOfError) + Style.RESET_ALL if not self.b_silent: print("Number of static check errors: ", self.str_analysis) if numOfError: numL = 40 print(numL*'-' + '\n') with open(check_err, 'r') as fin: print(fin.read()) print(numL*'-') else: self.str_analysis = Fore.YELLOW + "OFF" + Style.RESET_ALL def __codeAnalysis__(self, sutList: [str]): if self.tCfg.co_codeStatistics.isTurnedOn: self.__writeStep__("Analysis") lizardCsv = str(self.path_buildFldr / "lizard.csv") lizard_out = str(self.path_buildFldr / "lizard.out") lizard_err = str(self.path_buildFldr / "lizard.err") # choose used parameters if self.tCfg.co_codeStatistics.isUsedTestSpecificOnly == True: int_McCabeCompl = self.tCfg.co_codeStatistics.int_mccabeComplex int_FncLen = self.tCfg.co_codeStatistics.int_fncLength int_ParCnt = self.tCfg.co_codeStatistics.int_paramCnt else: if self.tCfg.co_codeStatistics.isUsedStricter == True: int_McCabeCompl = min(self.tCfg.co_codeStatistics.int_mccabeComplex, self.mCfg.co_stat.int_mccabeComplex) int_FncLen = min(self.tCfg.co_codeStatistics.int_fncLength, self.mCfg.co_stat.int_fncLength) int_ParCnt = min(self.tCfg.co_codeStatistics.int_paramCnt, self.mCfg.co_stat.int_paramCnt) else: int_McCabeCompl = self.mCfg.co_stat.int_mccabeComplex int_FncLen = self.mCfg.co_stat.int_fncLength int_ParCnt = self.mCfg.co_stat.int_paramCnt op_lst = [] op_lst.append('lizard') for sutListItem in sutList: op_lst.append(str(self.path_buildFldr / sutListItem)) op_lst.append("-C") op_lst.append(str(int_McCabeCompl)) op_lst.append("-L") op_lst.append(str(int_FncLen)) op_lst.append("-a") op_lst.append(str(int_ParCnt)) op_lst.append("-o") op_lst.append(lizardCsv) op_lst.append(">") op_lst.append(lizard_out) op_lst.append("2>") op_lst.append(lizard_err) subprocess.call(op_lst, shell=True) errTab = CodeStatistics.interpretLIZARDoutfile( lizardCsv, int_McCabeCompl, int_ParCnt, int_FncLen) cntError = len(errTab) if cntError: self.str_complexity = Fore.RED else: self.str_complexity = Fore.GREEN self.str_complexity += str(cntError) + Style.RESET_ALL if not self.b_silent: print("Number of error functions: ", self.str_complexity) if cntError: CodeStatistics.printLIZARDerrArrayShortAndColor(errTab, int_McCabeCompl, int_ParCnt, int_FncLen) else: self.str_complexity = Fore.YELLOW + "OFF" + Style.RESET_ALL def __codeEvaluation__(self): sutList = tdd_support.createSutList( self.tCfg, self.mCfg, self.str_testType) self.__coverage__(sutList) self.__staticCheck__(sutList) self.__codeAnalysis__(sutList) def __writeStatus__(self, status: str): lStatus = status colDict = {"Start": Fore.YELLOW, "Run": Fore.GREEN, "Idle": Fore.MAGENTA, "Error": Fore.RED, "Failure": Fore.RED, "Terminated": Fore.LIGHTYELLOW_EX} if lStatus in colDict: lStatus = colDict.get(status) + lStatus + Style.RESET_ALL else: lStatus = Fore.CYAN + lStatus + Style.RESET_ALL self.str_status = lStatus def __writeStep__(self, step: str): self.str_step = step if not self.b_silent: print("\n" + Fore.YELLOW + self.str_step + Style.RESET_ALL) pass def __checkExternalTerminationCondition__(self): if self.thread_keyPress.isAnyKeyPressed(): return(False) else: return(True) def __checkIniFileChanged__(self): locdic_chckFiles = { chckF: os.stat(chckF).st_mtime for chckF in self.LS_chckLFile} if locdic_chckFiles.get(self.LS_chckLFile[-1]) == self.dic_chckFiles.get(self.LS_chckLFile[-1]): return(False) else: return(True) def __cleanStatusVariables__(self): self.str_uncoverage = "Empty" self.str_testStatus = "Empty" self.str_analysis = "Empty" self.str_complexity = "Empty" def __cleanTmpSource__(self): path_srcFldr = Path(self.mCfg.co_pkg.str_testpath) / self.name / tdd_support.getSrcTestTempFolderName( self.tCfg, self.mCfg, self.str_testType) removeDirectory(path_srcFldr) def __checkSrcFileChanged__(self): locdic_chckFiles = { chckF: os.stat(chckF).st_mtime for chckF in self.LS_chckLFile} for str_file in self.LS_chckLFile: if locdic_chckFiles.get(str_file) != self.dic_chckFiles.get(str_file): return(True) return(False) def __cleanScreenBeforeRerun__(self): if not self.b_silent: tdd_support.clear() def __automocks__(self): pass def __updateAutomocks__(self): # self.dic_chckMockFiles (check and process) self.dic_chckMockFiles = self.checkAndUpdateCheckMockDictionary( self.dic_chckMockFiles, self.DicMock, self.IncMockLst, False) # self.dic_chckCppMockFiles (check and process) self.dic_chckCppMockFiles = self.checkAndUpdateCheckMockDictionary( self.dic_chckCppMockFiles, self.DicCppMock, self.IncMockLst, True) def checkAndUpdateCheckMockDictionary(self, dic_chck, dic_mock, lst_mockInc, fCpp): hMockLst = list(dic_chck.keys()) hMockLst.sort() locdic_chckFiles = { chckF: os.stat(chckF).st_mtime for chckF in hMockLst} for key in dic_chck: if locdic_chckFiles.get(key) != dic_chck.get(key): #NOTE: header file copy is not neccesary it happend in loop above #create new mock print({key:dic_mock.get(key)}) tdd_support.createAutomocks({key:dic_mock.get(key)}, lst_mockInc, forcedCpp=fCpp) return locdic_chckFiles def __runTest__(self): b_buildStatus = False self.__writeStep__("Start") self.__writeStatus__("Run") self.__readInit__() self.__createCmake__() self.__cleanTmpSource__() self.__fileCopying__() self.__automocks__() self.__cmake__() while True: b_buildStatus = self.__make__() if b_buildStatus is True: b_buildStatus = self.__runTestBin__() if b_buildStatus is True: self.__codeEvaluation__() self.__writeStatus__("Idle") else: self.__writeStatus__("Error") self.__writeStep__("Finished") while True: time.sleep(1) self.b_infiniteRun = self.__checkExternalTerminationCondition__() if not self.b_infiniteRun: return if self.__checkIniFileChanged__(): self.__cleanStatusVariables__() return if self.__checkSrcFileChanged__(): self.__cleanStatusVariables__() self.__fileCopyingUpdatedOnly__() self.__updateAutomocks__() self.__cleanScreenBeforeRerun__() break def run(self): while self.b_infiniteRun: self.__runTest__() self.__writeStep__("Finished") self.__writeStatus__("Terminated") # print("\n",self.name, " Finished!") class CTestPkgThread(CTestPkg, threading.Thread): def __init__(self, name, mainCfg, kpt): threading.Thread.__init__(self, name=name) CTestPkg.__init__(self, name=name, mainCfg=mainCfg, kpt=kpt) self.b_silent = True self.str_testType = "summary" self.start() class CTestPkgThreadMinimal(CTestPkg, threading.Thread): def __init__(self, name, mainCfg, kpt): threading.Thread.__init__(self, name=name) CTestPkg.__init__(self, name=name, mainCfg=mainCfg, kpt=kpt) self.b_silent = True self.str_testType = "minimal" self.start() if __name__ == "__main__": mainConfig = TDDConfig.CMainConfig("project.ini") os.environ['PATH'] += ";" + mainConfig.co_env.str_cmake os.environ['PATH'] += ";" + mainConfig.co_env.str_mingw os.environ['PATH'] += ";" + mainConfig.co_env.str_cppcheck scrP = "C:\\Users\\z003ukaz\\AppData\\Local" scrP += "\\Programs\\Python\\Python39\\Scripts" os.environ['PATH'] += ";" + scrP str_testPackagesPath = mainConfig.co_pkg.str_testpath str_testPackageSuffix = mainConfig.co_pkg.str_testfldr_suffix len_tpkgS = len(str_testPackageSuffix) path_dir = Path(str_testPackagesPath).glob("*_Tpkg") dir_lst = [folder for folder in path_dir if folder.is_dir()] lst_testDir = [] for dir in dir_lst: strdir = str(dir.stem) if (strdir[-len_tpkgS:] == str_testPackageSuffix): lst_testDir.append(strdir) debug(lst_testDir, mainConfig) debug(lst_testDir, mainConfig)
[]
[]
[ "PATH" ]
[]
["PATH"]
python
1
0
parse.go
// parse.go // // Copyright © 2018 by Ollivier Robert <[email protected]> package proxy // import "github.com/keltia/proxy" import ( "bufio" "crypto/tls" "encoding/base64" "fmt" "io" "log" "net/http" "net/url" "os" "strings" "golang.org/x/net/http/httpproxy" ) const ( proxyTag = "proxy" // MyVersion is our API Version MyVersion = "0.9.5" // MyName is the library name MyName = "proxy" ) var ( ctx Context ) type Context struct { proxyauth string level int Log *log.Logger } func init() { // Default is stderr ctx = Context{Log: log.New(os.Stderr, "", log.LstdFlags)} } // ErrNoAuth is just to say we do not use auth for proxy var ErrNoAuth = fmt.Errorf("no proxy auth") func SetupProxyAuth() (proxyauth string, err error) { // Try to load $HOME/.netrc or file pointed at by $NETRC user, password := loadNetrc() if user != "" { verbose("Proxy user %s found.", user) } err = ErrNoAuth // Do we have a proxy user/password? if user != "" && password != "" { auth := fmt.Sprintf("%s:%s", user, password) proxyauth = "Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) err = nil // Store copy in context ctx.proxyauth = proxyauth } return } // SetLevel change the log level (currently 0, 1 or 2) func SetLevel(level int) { ctx.level = level debug("logging level set to %d", level) } // SetLog allow to change the default logger func SetLog(l *log.Logger) { ctx.Log = l debug("logging logger set to %v", l) } // GetAuth returns the proxyauth encoded string func GetAuth() string { debug("returns cached credentials") return ctx.proxyauth } // SetupTransport is the way to have a custom http client func SetupTransport(str string) (*http.Request, *http.Transport) { /* Proxy code taken from https://github.com/LeoCBS/poc-proxy-https/blob/master/main.go */ myurl, err := url.Parse(str) if err != nil { log.Printf("error parsing %s: %v", str, err) return nil, nil } req, err := http.NewRequest("GET", str, nil) if err != nil { debug("error: req is nil: %v", err) return nil, nil } req.Header.Set("Host", myurl.Host) req.Header.Add("User-Agent", fmt.Sprintf("%s/%s", MyName, MyVersion)) // Get proxy URL proxyURL := getProxy(req) if ctx.proxyauth != "" { req.Header.Add("Proxy-Authorization", ctx.proxyauth) } transport := &http.Transport{ Proxy: http.ProxyURL(proxyURL), TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, ProxyConnectHeader: req.Header, } debug("transport=%#v", transport) return req, transport } // Version should be obvious func Version() string { return MyVersion } // Private functions func getProxy(req *http.Request) (uri *url.URL) { config := httpproxy.FromEnvironment() f := config.ProxyFunc() uri, _ = f(req.URL) return } // loadNetrc supports a subset of the original ftp(1) .netrc file. /* We support: machine default login password Format: machine <host> login <user> password <pass> */ func loadNetrc() (user, password string) { var dnetrc string // is $NETRC defined? dnetVar := os.Getenv("NETRC") // Allow override if dnetVar == "" { dnetrc = netrcFile } else { dnetrc = dnetVar } if dnetrc == "ignore" { return "", "" } verbose("NETRC=%s", dnetrc) // First check for permissions fh, err := os.Open(dnetrc) if err != nil { verbose("warning: can not find/read %s: %v", dnetrc, err) return "", "" } defer fh.Close() // Now check permissions st, err := fh.Stat() if err != nil { verbose("unable to stat: %v", err) return "", "" } if (st.Mode() & 077) != 0 { verbose("invalid permissions, must be 0400/0600") return "", "" } verbose("now parsing") user, password = parseNetrc(fh) return } /* Format: machine proxy|default login <user> password <pass> */ func parseNetrc(r io.Reader) (user, password string) { verbose("found netrc") s := bufio.NewScanner(r) for s.Scan() { line := s.Text() if line == "" { break } flds := strings.Split(line, " ") debug("%s: %d fields", line, len(flds)) if flds[0] != "machine" { verbose("machine is not the first word") continue } // Check what we need if len(flds) != 6 { verbose("bad format") continue } if flds[1] == proxyTag || flds[1] == "default" { if flds[2] == "login" && flds[4] == "password" { user = flds[3] password = flds[5] verbose("got %s/default entry for user %s", proxyTag, user) } break } } if err := s.Err(); err != nil { verbose("error reading netrc: %v", err) return "", "" } debug("nothing found for %s", proxyTag) if user == "" { verbose("no user/password for %s/default in netrc", proxyTag) } return }
[ "\"NETRC\"" ]
[]
[ "NETRC" ]
[]
["NETRC"]
go
1
0
python/paddle/fluid/tests/unittests/test_fleet_lamb_meta_optimizer.py
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import unittest import paddle from paddle import fluid import os import paddle.distributed.fleet as fleet import paddle.distributed.fleet.base.role_maker as role_maker class TestFleetLambMetaOptimizer(unittest.TestCase): def setUp(self): os.environ["PADDLE_TRAINER_ID"] = "1" os.environ[ "PADDLE_TRAINER_ENDPOINTS"] = "127.0.0.1:36001,127.0.0.1:36002" def net(self, main_prog, startup_prog): with fluid.program_guard(main_prog, startup_prog): with fluid.unique_name.guard(): input_x = paddle.fluid.layers.data( name="x", shape=[32], dtype='float32') input_y = paddle.fluid.layers.data( name="y", shape=[1], dtype='int64') fc_1 = paddle.fluid.layers.fc(input=input_x, size=64, act='tanh') fc_2 = paddle.fluid.layers.fc(input=fc_1, size=256, act='tanh') prediction = paddle.fluid.layers.fc(input=[fc_2], size=2, act='softmax') cost = paddle.fluid.layers.cross_entropy( input=prediction, label=input_y) avg_cost = paddle.fluid.layers.mean(x=cost) strategy = paddle.distributed.fleet.DistributedStrategy() strategy.lamb = True strategy.lamb_configs = { 'lamb_weight_decay': 0.01, 'exclude_from_weight_decay': [], } return avg_cost, strategy def test_lamb_optimizer(self): role = role_maker.PaddleCloudRoleMaker(is_collective=True) fleet.init(role) startup_prog = fluid.Program() train_prog = fluid.Program() avg_cost, strategy = self.net(train_prog, startup_prog) optimizer = paddle.fluid.optimizer.Adam(learning_rate=0.01) optimizer = fleet.distributed_optimizer(optimizer, strategy=strategy) optimizer.minimize(avg_cost) ops = [op.type for op in avg_cost.block.ops] self.assertIn('lamb', ops) def test_lamb_not_apply_with_momentum(self): role = role_maker.PaddleCloudRoleMaker(is_collective=True) fleet.init(role) startup_prog = fluid.Program() train_prog = fluid.Program() avg_cost, strategy = self.net(train_prog, startup_prog) optimizer = paddle.fluid.optimizer.Momentum( learning_rate=0.1, momentum=0.9) optimizer = fleet.distributed_optimizer(optimizer, strategy=strategy) optimizer.minimize(avg_cost) ops = [op.type for op in avg_cost.block.ops] self.assertNotIn('lamb', ops) def test_lamb_exclude_fn(self): role = role_maker.PaddleCloudRoleMaker(is_collective=True) fleet.init(role) startup_prog = fluid.Program() train_prog = fluid.Program() avg_cost, strategy = self.net(train_prog, startup_prog) optimizer = paddle.fluid.optimizer.Adam(learning_rate=0.01) strategy.lamb_configs = { 'lamb_weight_decay': 0.01, 'exclude_from_weight_decay': ['.b_0'], } optimizer = fleet.distributed_optimizer(optimizer, strategy=strategy) optimizer.minimize(avg_cost) ops_without_wd = [ op for op in avg_cost.block.ops if op.type == 'lamb' and op.attr('op_role_var')[0].endswith('.b_0') ] for op in ops_without_wd: self.assertEqual(op.attr('weight_decay'), 0) def test_lamb_apply_with_amp(self): role = role_maker.PaddleCloudRoleMaker(is_collective=True) fleet.init(role) input_x = paddle.fluid.layers.data( name="x", shape=[32], dtype='float32') input_y = paddle.fluid.layers.data(name="y", shape=[1], dtype='int64') fc_1 = paddle.fluid.layers.fc(input=input_x, size=64, act='tanh') fc_2 = paddle.fluid.layers.fc(input=fc_1, size=64, act='tanh') prediction = paddle.fluid.layers.fc(input=[fc_2], size=2, act='softmax') cost = paddle.fluid.layers.cross_entropy( input=prediction, label=input_y) avg_cost = paddle.fluid.layers.mean(x=cost) strategy = paddle.distributed.fleet.DistributedStrategy() strategy.amp = True strategy.amp_configs = { "init_loss_scaling": 32768, "decr_every_n_nan_or_inf": 2, "incr_every_n_steps": 1000, "incr_ratio": 2.0, "use_dynamic_loss_scaling": True, "decr_ratio": 0.5, "custom_white_list": ['softmax'], "custom_black_list": ['tanh'], } strategy.lamb = True strategy.lamb_configs = { 'lamb_weight_decay': 0.01, 'exclude_from_weight_decay': [], } optimizer = paddle.fluid.optimizer.Adam(learning_rate=0.01) optimizer = fleet.distributed_optimizer(optimizer, strategy=strategy) optimizer.minimize(avg_cost) ops = [op.type for op in avg_cost.block.ops] self.assertIn('lamb', ops) self.assertIn('cast', ops) self.assertIn('isfinite', ops) if __name__ == "__main__": unittest.main()
[]
[]
[ "PADDLE_TRAINER_ID", "PADDLE_TRAINER_ENDPOINTS" ]
[]
["PADDLE_TRAINER_ID", "PADDLE_TRAINER_ENDPOINTS"]
python
2
0
main.go
/* Copyright 2019 Google LLC. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package main import ( "context" "flag" "os" "cloud.google.com/go/compute/metadata" "github.com/GoogleCloudPlatform/gke-autoneg-controller/controllers" "google.golang.org/api/compute/v1" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/runtime" clientgoscheme "k8s.io/client-go/kubernetes/scheme" _ "k8s.io/client-go/plugin/pkg/client/auth/gcp" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/log/zap" // +kubebuilder:scaffold:imports ) var ( scheme = runtime.NewScheme() setupLog = ctrl.Log.WithName("setup") ) func init() { _ = clientgoscheme.AddToScheme(scheme) _ = corev1.AddToScheme(scheme) // +kubebuilder:scaffold:scheme } func main() { var metricsAddr string var enableLeaderElection bool flag.StringVar(&metricsAddr, "metrics-addr", ":8080", "The address the metric endpoint binds to.") flag.BoolVar(&enableLeaderElection, "enable-leader-election", false, "Enable leader election for controller manager. Enabling this will ensure there is only one active controller manager.") flag.Parse() ctrl.SetLogger(zap.Logger(true)) ctx, cancel := context.WithCancel(context.Background()) defer cancel() s, err := compute.NewService(ctx) if err != nil { setupLog.Error(err, "can't request Google compute service") os.Exit(1) } project := getProject() if project == "" { setupLog.Error(err, "can't determine project ID") os.Exit(1) } mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{ Scheme: scheme, MetricsBindAddress: metricsAddr, LeaderElection: enableLeaderElection, }) if err != nil { setupLog.Error(err, "unable to start manager") os.Exit(1) } if err = (&controllers.ServiceReconciler{ Client: mgr.GetClient(), BackendController: controllers.NewBackendController(project, s), Recorder: mgr.GetEventRecorderFor("autoneg-controller"), Log: ctrl.Log.WithName("controllers").WithName("Service"), }).SetupWithManager(mgr); err != nil { setupLog.Error(err, "unable to create controller", "controller", "Service") os.Exit(1) } // +kubebuilder:scaffold:builder setupLog.Info("starting manager") if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil { setupLog.Error(err, "problem running manager") os.Exit(1) } } func getProject() string { // probe metadata service for project, or fall back to PROJECT_ID in environment p, err := metadata.ProjectID() if err == nil { return p } return os.Getenv("PROJECT_ID") }
[ "\"PROJECT_ID\"" ]
[]
[ "PROJECT_ID" ]
[]
["PROJECT_ID"]
go
1
0
code/SSGP_classifier.py
import os #os.environ["CUDA_VISIBLE_DEVICES"] = "-1" import numpy as np import tensorflow as tf import common_funcs from common_funcs import FLOAT_TYPE import data_loader from sklearn.cluster import KMeans import time import joblib as jb # Streaming Sparse Gaussian Tensor Decomposition # By ZMP import sys #run as print("usage : python *.py rank=3 batch_size=256 dataset=dblp") print('start') print( sys.argv) #parse args py_name = sys.argv[0] args = sys.argv[1:] args_dict = {} for arg_pair in args: arg, val_str = arg_pair.split( '=') args_dict[ arg] = val_str.strip() arg_rank = int( args_dict['rank']) arg_data_name = args_dict['dataset'] arg_batch_size = int( args_dict['batch_size']) class SSGP_CLF: def __init__(self, init_config): #Model configuration parameters self.num_pseudo_points = init_config['num_pseudo_points'] self.rank = init_config['rank'] self.init_method = init_config['init_method'] self.elem_sizes = init_config['elem_sizes'] # list, number of elements( users, items, ...) self.learning_rate = init_config['learning_rate'] self.N_data_points = init_config['N_data_points'] if 'saved_model' in init_config: saved_model = init_config['saved_model'] self.init_mu_U = saved_model['mu_U'] self.init_std_vec_U = saved_model['std_vec_U'] self.fix_U = True else: self.fix_U = False self.num_mods = len( self.elem_sizes) self.num_factors = np.sum( self.elem_sizes) self.rank_psd_input = self.num_mods * self.rank # Will be different if use neural kernel self.tf_initializer = common_funcs.get_initializer(self.init_method, args = None) #Parameters self.PARAS_SCOPE_NAME = 'PARAS' with tf.variable_scope( self.PARAS_SCOPE_NAME): if self.fix_U: self.tf_mu_U = [ tf.constant( self.init_mu_U[i], dtype = FLOAT_TYPE) for i in range( self.num_mods)] self.tf_std_vec_U = [ tf.constant( self.init_std_vec_U[i], dtype=FLOAT_TYPE) for i in range( self.num_mods)] else: #Embeddings initialized by default initlizer self.tf_mu_U = [tf.Variable(np.random.randn( num_elem, self.rank) * 1.0, dtype=FLOAT_TYPE) for num_elem in self.elem_sizes] self.tf_std_vec_U = [ tf.Variable( np.ones( shape = [ num_elem, self.rank]) * 0.1, dtype=FLOAT_TYPE) for num_elem in self.elem_sizes] #var = diag( std * std ) self.B_init_holder = tf.placeholder( dtype=FLOAT_TYPE, shape=[ self.num_pseudo_points, self.rank_psd_input]) self.tf_B = tf.Variable( initial_value=self.B_init_holder) self.tf_post_mu_b = tf.Variable(tf.random.normal( shape = [self.num_pseudo_points, 1], dtype=FLOAT_TYPE), dtype=FLOAT_TYPE) self.tf_post_Ltrig_b = tf.linalg.band_part(tf.Variable(np.eye( self.num_pseudo_points), dtype=FLOAT_TYPE), -1, 0) #Kernel parameters. ARD self.tf_log_lengthscale = tf.Variable(np.zeros(shape = [self.rank_psd_input, 1]), dtype=FLOAT_TYPE) self.tf_log_amp = tf.Variable(0.0, dtype=FLOAT_TYPE) #Place holders self.batch_inds = tf.placeholder(dtype=tf.int32, shape=[None, self.num_mods]) self.batch_rates = tf.placeholder(dtype=FLOAT_TYPE, shape=[None, ]) self.batch_uniq_fac_inds = [tf.placeholder( dtype=tf.int32,shape= [None,] ) for _ in range( self.num_mods)] #Old values. Be aware, Complicated logic here. Becareful to modify. self.mu_b_old_ori = tf.Variable( np.zeros( shape=[self.num_pseudo_points,1]), dtype=FLOAT_TYPE) self.mu_b_old = tf.stop_gradient(self.mu_b_old_ori ) self.Ltrig_b_old_ori_init_holder = tf.placeholder( dtype=FLOAT_TYPE, shape=[ self.num_pseudo_points, self.num_pseudo_points]) self.Ltrig_b_old_ori = tf.Variable(self.Ltrig_b_old_ori_init_holder , dtype=FLOAT_TYPE) self.Ltrig_b_old = tf.stop_gradient( self.Ltrig_b_old_ori) self.Kmm_old_ori = tf.Variable( np.zeros( shape = [ self.num_pseudo_points, self.num_pseudo_points]), dtype=FLOAT_TYPE) self.Kmm_old = tf.stop_gradient( self.Kmm_old_ori) self.mu_U_old_ori = [ tf.Variable( np.zeros( shape = [ num_elem, self.rank]), dtype=FLOAT_TYPE) for num_elem in self.elem_sizes] self.mu_U_old = [ tf.stop_gradient( self.mu_U_old_ori[k]) for k in range( self.num_mods)] self.std_vec_U_old_ori = [tf.Variable(np.zeros(shape = [num_elem, self.rank]), dtype=FLOAT_TYPE) for num_elem in self.elem_sizes] self.std_vec_U_old = [tf.stop_gradient( self.std_vec_U_old_ori[k]) for k in range( self.num_mods)] self.var_normal_params_old_ori = tf.Variable(np.array([0, 1]), dtype=FLOAT_TYPE) self.var_normal_params_old = tf.stop_gradient(self.var_normal_params_old_ori) self.assign_old_values_op = [tf.assign( self.mu_b_old_ori, self.tf_post_mu_b), tf.assign( self.Ltrig_b_old_ori, self.tf_post_Ltrig_b)] self.assign_old_values_op = self.assign_old_values_op + [ tf.assign( self.mu_U_old_ori[k], self.tf_mu_U[k]) for k in range( self.num_mods)] + \ [tf.assign(self.std_vec_U_old_ori[k], self.tf_std_vec_U[k]) for k in range( self.num_mods)] self.sub_batch_size = self.N_data_points #sample posterior embeddings sampled_embeddings, self.batch_mean, self.batch_std_vec = common_funcs.sample_embeddings( self.tf_mu_U, self.tf_std_vec_U, self.batch_inds, return_batch_info= True) self.sampled_X = tf.concat( sampled_embeddings, axis=1) ''' Some neural kernel transform here if using neural kernel ''' self.Kmm = common_funcs.kernel_cross_tf(self.tf_B, self.tf_B, self.tf_log_amp, self.tf_log_lengthscale)# + MATRIX_JITTER * tf.eye( self.num_pseudo_points) self.Knm = common_funcs.kernel_cross_tf(self.sampled_X, self.tf_B, self.tf_log_amp, self.tf_log_lengthscale) self.assign_old_values_op.append( tf.assign( self.Kmm_old_ori, self.Kmm)) post_sample_f, f_std = common_funcs.sample_sparse_f( self.tf_post_mu_b, self.tf_post_Ltrig_b, self.Kmm, self.Knm, self.tf_log_amp, return_std=True) #[batch_size, 1] self.post_sample_f = tf.reshape(post_sample_f, shape=[-1]) # [ batch_size,] #MLE sample of f. Used in prediction self.f_mle = tf.reshape( self.Knm @ tf.linalg.solve( self.Kmm, self.tf_post_mu_b), shape=[-1]) self.f_std = tf.reshape( f_std, shape = [-1]) self.data_fidelity = self.sub_batch_size * tf.reduce_mean(- tf.nn.sigmoid_cross_entropy_with_logits( labels=self.batch_rates, logits=self.post_sample_f)) # KL U # Note this is biased, because uniformly sampling from rating is not equivalent to uniformly sampling from factors uniq_mu_U = common_funcs.get_uniq_factors(self.tf_mu_U, self.batch_uniq_fac_inds) uniq_std_vec_U = common_funcs.get_uniq_factors(self.tf_std_vec_U, self.batch_uniq_fac_inds) uniq_mu_U_old = common_funcs.get_uniq_factors( self.mu_U_old, self.batch_uniq_fac_inds) uniq_std_vec_U_old = common_funcs.get_uniq_factors( self.std_vec_U_old, self.batch_uniq_fac_inds) self.batch_KL_U = common_funcs.KL_Gaussian_std_vec_tf(tf.concat(uniq_mu_U, axis=0), tf.concat(uniq_std_vec_U, axis=0), tf.concat(uniq_mu_U_old, axis=0), tf.concat(uniq_std_vec_U_old, axis=0), self.rank) self.KL_U = self.batch_KL_U # KL( q(b)|| p(b)) self.KL_q_pb_new = common_funcs.KL_pseudo_output(self.Kmm, self.tf_post_Ltrig_b, self.tf_post_mu_b, self.num_pseudo_points) # KL( q(b) || q(b)_old) self.KL_q_qb_old = common_funcs.KL_Gaussian_Ltrig_tf( self.tf_post_mu_b, self.tf_post_Ltrig_b, self.mu_b_old, self.Ltrig_b_old, self.num_pseudo_points) # KL ( q(b) || p(b)_old) self.KL_q_pb_old = common_funcs.KL_pseudo_output( self.Kmm_old, self.tf_post_Ltrig_b, self.tf_post_mu_b,self.num_pseudo_points) self.KL_b = self.KL_q_qb_old + self.KL_q_pb_new - self.KL_q_pb_old # Loss functions self.ELBO = self.data_fidelity - self.KL_b - self.KL_U #Session settings self.min_opt = tf.train.AdamOptimizer(self.learning_rate) self.min_step = self.min_opt.minimize(- self.ELBO) self.train_hist = [] # GPU settings config = tf.ConfigProto() config.gpu_options.allow_growth = True self.sess = tf.Session(config=config) self.run_options = tf.RunOptions(report_tensor_allocations_upon_oom=True) #Pre-initialize pseudo input self.sess.run( tf.global_variables_initializer(), feed_dict={ self.B_init_holder : np.random.randn(self.num_pseudo_points, self.rank_psd_input), self.Ltrig_b_old_ori_init_holder : np.random.randn( self.num_pseudo_points, self.num_pseudo_points)} ) self.is_B_initialized = False def _get_init_pseudo_input(self, inds): max_num_input_points = self.num_pseudo_points * 100 if len( inds) > max_num_input_points: arg_random = np.random.permutation( len( inds)) inds = inds[ arg_random[ : max_num_input_points]] X = self.sess.run( self.sampled_X, feed_dict={ self.batch_inds : inds}) kmeans = KMeans( n_clusters = self.num_pseudo_points, n_jobs=-1) _ = kmeans.fit(X) return kmeans.cluster_centers_ def _fit(self, inds, rates, batch_size, num_iters_per_batch, print_every_by_iters): num_batches = int( len( inds / batch_size)) self.batch_X_y_gnrt = common_funcs.DataGenerator(inds, rates, shuffle=True) for n_batch in range( 1, num_batches + 1): batch_inds, batch_rates = self.batch_X_y_gnrt.draw_next(batch_size) self.fit_batch( batch_inds, batch_rates, num_iters_per_batch, print_every = print_every_by_iters) def fit_batch(self, inds, rates, steps, print_every = 100, clean_hist = True, verbose = True ): start_time = time.time() if not self.is_B_initialized: # Initialized model using print('Re-initializing B using Kmeans') cluster_centers = self._get_init_pseudo_input( inds) self.sess.run( self.tf_B.initializer, feed_dict = { self.B_init_holder : cluster_centers}) self.is_B_initialized = True # update old posteriors and hyper-parameters _ = self.sess.run(self.assign_old_values_op) init_Kmm = self.sess.run(self.Kmm) L = np.linalg.cholesky(init_Kmm) self.sess.run(self.Ltrig_b_old_ori, feed_dict={self.Ltrig_b_old_ori_init_holder: L}) print("Re-initializing Done") if clean_hist: self.train_hist = [] # Get unique inds uniq_inds = [np.unique(inds[:, k]) for k in range(self.num_mods)] for step in range( 1, steps + 1): # Get unique inds train_feed = {self.batch_inds: inds, self.batch_rates: rates} for k in range( self.num_mods): train_feed[ self.batch_uniq_fac_inds[k]] = uniq_inds[k] ELBO, sampled_f, data_fidelity,KL_U, KL_b, batch_U_mean, batch_U_std_vec, _ = self.sess.run( [ self.ELBO, self.post_sample_f, self.data_fidelity,self.KL_U,self.KL_b, self.batch_mean, self.batch_std_vec, self.min_step], feed_dict= train_feed, options= self.run_options) self.train_hist.append( ELBO) if step % print_every == 0 and verbose: print('true_rates: ', rates[:5]) print('sampled logits: ', sampled_f[:5]) print('sampled rates: ', (sampled_f[:5] >= 0).astype(np.float32)) train_auc = common_funcs.metrics_auc( rates, sampled_f ) print( '\nstep = %d, ELBO = %g, data_fidelity = %g, -KL_U = %g, -KL_b = %g, train_auc = %g' % ( step, ELBO,data_fidelity, -KL_U, -KL_b,train_auc)) # update old posteriors and hyper-parameters _ = self.sess.run(self.assign_old_values_op) end_time = time.time() if verbose: print( 'secs_per_entry = %e' % (( end_time - start_time)/ len( inds))) return self def predict_log_llk(self, inds, y, batch_size): N = len( inds) test_llk = [] start_idx = 0 end_idx = start_idx + batch_size while( start_idx < N): end_idx = min( end_idx, N) batch_inds = inds[ start_idx : end_idx] batch_y = y[ start_idx : end_idx] test_feed = { self.batch_inds : batch_inds} batch_f, batch_f_std = self.sess.run( [ self.f_mle, self.f_std], feed_dict=test_feed) f_var = batch_f_std ** 2 kappa = np.sqrt( 1 + np.pi * f_var/ 8) p = common_funcs.sigmoid( kappa * batch_f) llk = batch_y * np.log( p) + ( 1 - batch_y) * np.log( 1 - p) test_llk.append(llk) start_idx += batch_size end_idx = start_idx + batch_size test_llk = np.concatenate( test_llk) assert len( test_llk) == N, "Dims not match" return test_llk def _batch_wise_predict(self, inds, batch_size, return_logits): y_pred_logits = [] N = len(inds) start_idx = 0 end_idx = start_idx + batch_size while (start_idx < N): end_idx = min(end_idx, N) batch_inds = inds[start_idx:end_idx] test_feed = {self.batch_inds: batch_inds} batch_y = self.sess.run(self.f_mle, feed_dict=test_feed) y_pred_logits.append(batch_y) start_idx += batch_size end_idx = start_idx + batch_size y_pred_logits = np.concatenate(y_pred_logits) y_pred = ( y_pred_logits >= 0).astype( np.float32) assert len(y_pred_logits) == N, "prediction length not match" if return_logits: return y_pred, y_pred_logits else: return y_pred def predict(self, inds, batch_size=None, return_logits = False): if batch_size is not None: return self._batch_wise_predict(inds, batch_size, return_logits) else: test_feed = {self.batch_inds: inds} y_pred_logits = self.sess.run(self.f_mle, feed_dict=test_feed) y_pred = (y_pred_logits >= 0).astype( np.float32) if return_logits: return y_pred, y_pred_logits else: return y_pred def main(): assert arg_data_name in ['dblp','anime'], 'Wrong data name %s' % (arg_data_name) if arg_data_name == 'dblp': data = data_loader.load_dblp() elif arg_data_name == 'anime': data = data_loader.load_anime_binary( ) else: raise NameError('wrong data set: %s' % arg_data_name) train_inds = data['train_X'] train_rates = data['train_y'] test_inds = data['test_X'] test_rates = data['test_y'] data_name = data['name'] elem_sizes = data['elem_sizes'] N_train = len( train_rates) N_test = len(test_rates) print('elem size:', elem_sizes) print('pseudo N train = %d, true N train = %d' % (N_train, len(train_rates))) print("N train = %d, N test = %d" % (N_train, N_test)) print('mods = ', elem_sizes) # np.random.seed(47) # tf.random.set_random_seed( 47) #parameters settings-------------- batch_size = arg_batch_size num_iters_per_batch = 100 # init U init_config = { 'elem_sizes': elem_sizes, 'learning_rate': 1e-3, 'init_method': 'he_normal', 'rank': arg_rank, 'num_pseudo_points': 128, 'batch_size': batch_size, 'num_iters_per_batch': num_iters_per_batch, 'N_data_points': N_train, 'init_batch_size' : 2048 } #end parameters settings---------- if 'USER' in os.environ: user_name = os.environ['USER'] else: user_name = os.environ['USERNAME'] log_file = common_funcs.init_log_file('ssgp_classifier_by_%s.txt' % user_name, data_name, init_config) init_config['log_file'] = log_file model = SSGP_CLF(init_config) num_batches = int(len(train_inds) / batch_size) print("num train = %d, num test = %d, batch_size = %d, num batches = %d" % ( len(train_inds), len(test_inds), batch_size, num_batches)) batch_X_y_gnrt = common_funcs.DataGenerator(train_inds, train_rates, shuffle=True) batch_inds, batch_rates = batch_X_y_gnrt.draw_next(init_config['init_batch_size']) model.fit_batch(batch_inds, batch_rates, num_iters_per_batch, print_every=20, verbose=True) for n_batch in range(1, num_batches + 1): batch_inds, batch_rates = batch_X_y_gnrt.draw_next(batch_size) verbose = n_batch % int(num_batches / 20) == 0 model.fit_batch(batch_inds, batch_rates, steps=num_iters_per_batch, verbose=verbose,print_every=50) if verbose: y_pred, logtis_pred = model.predict(test_inds, return_logits=True, batch_size = 1024) acc = common_funcs.metrics_accuracy(test_rates, y_pred) auc = common_funcs.metrics_auc(test_rates, logtis_pred) test_llk = model.predict_log_llk( test_inds, test_rates, batch_size=1024) ave_test_llk = np.average( test_llk) print("\nbatch = %d, progress = %4.3g, test_acc = %g, test_auc = %g, ave_llk = %g\n" % ( n_batch, n_batch / num_batches * 100, acc, auc, ave_test_llk)) log_file.write("batch = %d, progress = %4.3g, test_acc = %g, test_auc = %g, ave_llk = %g\n" % ( n_batch, n_batch / num_batches * 100, acc, auc, ave_test_llk)) log_file.flush() os.fsync(log_file.fileno()) y_pred, logtis_pred = model.predict(test_inds, return_logits=True, batch_size = 1024) acc = common_funcs.metrics_accuracy(test_rates, y_pred) auc = common_funcs.metrics_auc(test_rates, logtis_pred) test_llk = model.predict_log_llk(test_inds, test_rates, batch_size=1024) ave_test_llk = np.average(test_llk) print("\nbatch = %d, progress = %4.3g, test_acc = %g, test_auc = %g, ave_llk = %g\n" % ( n_batch, n_batch / num_batches * 100, acc, auc, ave_test_llk)) log_file.write("batch = %d, progress = %4.3g, test_acc = %g, test_auc = %g, ave_llk = %g\n" % ( n_batch, n_batch / num_batches * 100, acc, auc, ave_test_llk)) log_file.close() if __name__ == '__main__': main()
[]
[]
[ "CUDA_VISIBLE_DEVICES", "USERNAME", "USER" ]
[]
["CUDA_VISIBLE_DEVICES", "USERNAME", "USER"]
python
3
0
start.py
from telethon import TelegramClient, events, Button import requests import sqlite3 from headers import headers import urls import os #from flask import request client = TelegramClient('anfghohn', int(os.environ.get("APP_ID" )), os.environ.get("API_HASH")).start(bot_token= os.environ.get("TG_BOT_TOKEN")) @client.on(events.NewMessage(pattern='/start')) async def handler(event): chat = await event.get_chat() await client.send_message(chat,"""嗨,这是Player Video Uploader Bot.您可以使用我制作任何Zee5或MX Player视频的Streamable Link.""") @client.on(events.NewMessage(pattern='/help')) async def handler(event): chat = await event.get_chat() await client.send_message(chat,"""嗨,这是** Zee5 **和** MX Player **视频下载器和上传器Bot.您可以使用我制作任何Zee5或MX Player视频的Streamable Link.只需从Zee5或MX Player复制视频链接并将其发送给我,我将对其进行加载并将其发送给您.""") @client.on(events.NewMessage(pattern='(?i)https://www.zee5.com')) async def handler(event): link =event.text.split('/')[-1] chat = await event.get_chat() w =link markup = client.build_reply_markup(Button.url("https://www.zee5.com/tvshows/details/sembaruthi/0-6-675/sembaruthi-november-18-2020/0-1-manual_7adlhget67b0"+link)) req1 = requests.get(urls.token_url1, headers=headers).json() req2 = requests.get(urls.platform_token).json()["token"] headers["X-Access-Token"] = req2 req3 = requests.get(urls.token_url2, headers=headers).json() r1 = requests.get(urls.search_api_endpoint + w,headers=headers, params={"translation":"en", "country":"IN"}).json() g1 = (r1["hls"][0].replace("drm", "hls") + req1["video_token"]) # await client.send_file(chat,r1["image_url"],caption = r1["title"]) markup = client.build_reply_markup(Button.url("Transloaded Link",urls.stream_baseurl+g1)) await client.send_message(chat, "Zee5 Link Transloaded! \n\n"+"**Video Title:** "+r1["title"]+" \n**Video Description:** "+r1["description"],file=r1["image_url"], buttons=markup) #rgx = w # await client.send_message(chat, g1) #await client.send_message(chat,"445") @client.on(events.NewMessage(pattern='(?i)https://www.mxplayer.in')) async def handler(event): link =event.text.split('/')[-1] video_d = "https://llvod.mxplay.com/" A =requests.get("https://api.mxplay.com/v1/web/detail/video?type=movie&id="+link+"&platform=com.mxplay.desktop&device-density=2&userid=30bb09af-733a-413b-b8b7-b10348ec2b3d&platform=com.mxplay.mobile&content-languages=hi,en,ta").json() #A =requests.get("https://api.mxplay.com/v1/web/detail/video?type=movie&id="+link+"&platform=com.mxplay.desktop&device-density=2&userid=30bb09af-733a-413b-b8b7-b10348ec2b3d&platform=com.mxplay.mobile&content-languages=hi,en,ta").json() chat = await event.get_chat() markup = client.build_reply_markup(Button.url("Transloaded Link",video_d+A["stream"]['hls']['high'])) await client.send_message(chat,"Title: "+A["title"],buttons=markup) print(A) print(link) @client.on(events.NewMessage(pattern='(?i)https://www.hotstar.com/in/')) async def handler(event): link =event.text print(link) #import youtube_dl ydl = youtube_dl.YoutubeDL({'outtmpl': '%(id)s.%(ext)s'}) with ydl: result = ydl.extract_info( link, download=True # We just want to extract the info ) await client.send_message(chat,result) @client.on(events.NewMessage(pattern='(?i)/ls')) async def handler(event): link =event.text.split(" ")[1] e = os.listdir(link) chat = await event.get_chat() c = "|" #str1.join(s) #print(c) await client.send_message(chat,c.join(e)) @client.on(events.NewMessage(pattern='(?i)sm')) async def handler(event): link =event.text.split(" ")[1] print(link) chat = await event.get_chat() await client.send_file(chat, '/Download'+link,force_document=True) client.start() client.run_until_disconnected()
[]
[]
[ "API_HASH", "TG_BOT_TOKEN", "APP_ID\"" ]
[]
["API_HASH", "TG_BOT_TOKEN", "APP_ID\""]
python
3
0
plugins/inputs/tail/tail_test.go
package tail import ( "io/ioutil" "os" "runtime" "testing" "github.com/lavaorg/telex/plugins/parsers" "github.com/lavaorg/telex/testutil" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestTailFromBeginning(t *testing.T) { if os.Getenv("CIRCLE_PROJECT_REPONAME") != "" { t.Skip("Skipping CI testing due to race conditions") } tmpfile, err := ioutil.TempFile("", "") require.NoError(t, err) defer os.Remove(tmpfile.Name()) _, err = tmpfile.WriteString("cpu,mytag=foo usage_idle=100\n") require.NoError(t, err) tt := NewTail() tt.FromBeginning = true tt.Files = []string{tmpfile.Name()} tt.SetParserFunc(parsers.NewInfluxParser) defer tt.Stop() defer tmpfile.Close() acc := testutil.Accumulator{} require.NoError(t, tt.Start(&acc)) require.NoError(t, acc.GatherError(tt.Gather)) acc.Wait(1) acc.AssertContainsTaggedFields(t, "cpu", map[string]interface{}{ "usage_idle": float64(100), }, map[string]string{ "mytag": "foo", "path": tmpfile.Name(), }) } func TestTailFromEnd(t *testing.T) { if os.Getenv("CIRCLE_PROJECT_REPONAME") != "" { t.Skip("Skipping CI testing due to race conditions") } tmpfile, err := ioutil.TempFile("", "") require.NoError(t, err) defer os.Remove(tmpfile.Name()) _, err = tmpfile.WriteString("cpu,mytag=foo usage_idle=100\n") require.NoError(t, err) tt := NewTail() tt.Files = []string{tmpfile.Name()} tt.SetParserFunc(parsers.NewInfluxParser) defer tt.Stop() defer tmpfile.Close() acc := testutil.Accumulator{} require.NoError(t, tt.Start(&acc)) for _, tailer := range tt.tailers { for n, err := tailer.Tell(); err == nil && n == 0; n, err = tailer.Tell() { // wait for tailer to jump to end runtime.Gosched() } } _, err = tmpfile.WriteString("cpu,othertag=foo usage_idle=100\n") require.NoError(t, err) require.NoError(t, acc.GatherError(tt.Gather)) acc.Wait(1) acc.AssertContainsTaggedFields(t, "cpu", map[string]interface{}{ "usage_idle": float64(100), }, map[string]string{ "othertag": "foo", "path": tmpfile.Name(), }) assert.Len(t, acc.Metrics, 1) } func TestTailBadLine(t *testing.T) { tmpfile, err := ioutil.TempFile("", "") require.NoError(t, err) defer os.Remove(tmpfile.Name()) tt := NewTail() tt.FromBeginning = true tt.Files = []string{tmpfile.Name()} tt.SetParserFunc(parsers.NewInfluxParser) defer tt.Stop() defer tmpfile.Close() acc := testutil.Accumulator{} require.NoError(t, tt.Start(&acc)) require.NoError(t, acc.GatherError(tt.Gather)) _, err = tmpfile.WriteString("cpu mytag= foo usage_idle= 100\n") require.NoError(t, err) acc.WaitError(1) assert.Contains(t, acc.Errors[0].Error(), "E! Malformed log line") } func TestTailDosLineendings(t *testing.T) { tmpfile, err := ioutil.TempFile("", "") require.NoError(t, err) defer os.Remove(tmpfile.Name()) _, err = tmpfile.WriteString("cpu usage_idle=100\r\ncpu2 usage_idle=200\r\n") require.NoError(t, err) tt := NewTail() tt.FromBeginning = true tt.Files = []string{tmpfile.Name()} tt.SetParserFunc(parsers.NewInfluxParser) defer tt.Stop() defer tmpfile.Close() acc := testutil.Accumulator{} require.NoError(t, tt.Start(&acc)) require.NoError(t, acc.GatherError(tt.Gather)) acc.Wait(2) acc.AssertContainsFields(t, "cpu", map[string]interface{}{ "usage_idle": float64(100), }) acc.AssertContainsFields(t, "cpu2", map[string]interface{}{ "usage_idle": float64(200), }) }
[ "\"CIRCLE_PROJECT_REPONAME\"", "\"CIRCLE_PROJECT_REPONAME\"" ]
[]
[ "CIRCLE_PROJECT_REPONAME" ]
[]
["CIRCLE_PROJECT_REPONAME"]
go
1
0
ddl/ddl_test.go
// Copyright 2015 PingCAP, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // See the License for the specific language governing permissions and // limitations under the License. package ddl import ( "context" "os" "testing" "time" "github.com/coreos/etcd/clientv3" . "github.com/pingcap/check" "github.com/pingcap/log" "github.com/pingcap/parser/ast" "github.com/pingcap/parser/model" "github.com/pingcap/parser/terror" "github.com/pingcap/tidb/infoschema" "github.com/pingcap/tidb/kv" "github.com/pingcap/tidb/meta" "github.com/pingcap/tidb/meta/autoid" "github.com/pingcap/tidb/sessionctx" "github.com/pingcap/tidb/store/mockstore" "github.com/pingcap/tidb/types" "github.com/pingcap/tidb/util" "github.com/pingcap/tidb/util/logutil" "github.com/pingcap/tidb/util/mock" "github.com/pingcap/tidb/util/testleak" "go.uber.org/zap" ) type DDLForTest interface { // SetHook sets the hook. SetHook(h Callback) // SetInterceptoror sets the interceptor. SetInterceptoror(h Interceptor) } // SetHook implements DDL.SetHook interface. func (d *ddl) SetHook(h Callback) { d.mu.Lock() defer d.mu.Unlock() d.mu.hook = h } // SetInterceptoror implements DDL.SetInterceptoror interface. func (d *ddl) SetInterceptoror(i Interceptor) { d.mu.Lock() defer d.mu.Unlock() d.mu.interceptor = i } // generalWorker returns the general worker. func (d *ddl) generalWorker() *worker { return d.workers[generalWorker] } // restartWorkers is like the function of d.start. But it won't initialize the "workers" and create a new worker. // It only starts the original workers. func (d *ddl) restartWorkers(ctx context.Context) { d.quitCh = make(chan struct{}) if !RunWorker { return } err := d.ownerManager.CampaignOwner(ctx) terror.Log(err) for _, worker := range d.workers { worker.wg.Add(1) worker.quitCh = make(chan struct{}) w := worker go util.WithRecovery(func() { w.start(d.ddlCtx) }, func(r interface{}) { if r != nil { log.Error("[ddl] restart DDL worker meet panic", zap.String("worker", w.String()), zap.String("ID", d.uuid)) } }) asyncNotify(worker.ddlJobCh) } } func TestT(t *testing.T) { CustomVerboseFlag = true *CustomParallelSuiteFlag = true logLevel := os.Getenv("log_level") logutil.InitLogger(logutil.NewLogConfig(logLevel, "", "", logutil.EmptyFileLogConfig, false)) autoid.SetStep(5000) ReorgWaitTimeout = 30 * time.Millisecond testleak.BeforeTest() TestingT(t) testleak.AfterTestT(t)() } func testCreateStore(c *C, name string) kv.Storage { store, err := mockstore.NewMockTikvStore() c.Assert(err, IsNil) return store } func testNewContext(d *ddl) sessionctx.Context { ctx := mock.NewContext() ctx.Store = d.store return ctx } func testNewDDL(ctx context.Context, etcdCli *clientv3.Client, store kv.Storage, infoHandle *infoschema.Handle, hook Callback, lease time.Duration) *ddl { return newDDL(ctx, etcdCli, store, infoHandle, hook, lease, nil) } func getSchemaVer(c *C, ctx sessionctx.Context) int64 { err := ctx.NewTxn(context.Background()) c.Assert(err, IsNil) txn, err := ctx.Txn(true) c.Assert(err, IsNil) m := meta.NewMeta(txn) ver, err := m.GetSchemaVersion() c.Assert(err, IsNil) return ver } type historyJobArgs struct { ver int64 db *model.DBInfo tbl *model.TableInfo tblIDs map[int64]struct{} } func checkEqualTable(c *C, t1, t2 *model.TableInfo) { c.Assert(t1.ID, Equals, t2.ID) c.Assert(t1.Name, Equals, t2.Name) c.Assert(t1.Charset, Equals, t2.Charset) c.Assert(t1.Collate, Equals, t2.Collate) c.Assert(t1.PKIsHandle, DeepEquals, t2.PKIsHandle) c.Assert(t1.Comment, DeepEquals, t2.Comment) c.Assert(t1.AutoIncID, DeepEquals, t2.AutoIncID) } func checkHistoryJob(c *C, job *model.Job) { c.Assert(job.State, Equals, model.JobStateSynced) } func checkHistoryJobArgs(c *C, ctx sessionctx.Context, id int64, args *historyJobArgs) { txn, err := ctx.Txn(true) c.Assert(err, IsNil) t := meta.NewMeta(txn) historyJob, err := t.GetHistoryDDLJob(id) c.Assert(err, IsNil) c.Assert(historyJob.BinlogInfo.FinishedTS, Greater, uint64(0)) if args.tbl != nil { c.Assert(historyJob.BinlogInfo.SchemaVersion, Equals, args.ver) checkEqualTable(c, historyJob.BinlogInfo.TableInfo, args.tbl) return } // for handling schema job c.Assert(historyJob.BinlogInfo.SchemaVersion, Equals, args.ver) c.Assert(historyJob.BinlogInfo.DBInfo, DeepEquals, args.db) // only for creating schema job if args.db != nil && len(args.tblIDs) == 0 { return } } func buildCreateIdxJob(dbInfo *model.DBInfo, tblInfo *model.TableInfo, unique bool, indexName string, colName string) *model.Job { return &model.Job{ SchemaID: dbInfo.ID, TableID: tblInfo.ID, Type: model.ActionAddIndex, BinlogInfo: &model.HistoryInfo{}, Args: []interface{}{unique, model.NewCIStr(indexName), []*ast.IndexColName{{ Column: &ast.ColumnName{Name: model.NewCIStr(colName)}, Length: types.UnspecifiedLength}}}, } } func testCreateIndex(c *C, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, unique bool, indexName string, colName string) *model.Job { job := buildCreateIdxJob(dbInfo, tblInfo, unique, indexName, colName) err := d.doDDLJob(ctx, job) c.Assert(err, IsNil) v := getSchemaVer(c, ctx) checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) return job } func testAddColumn(c *C, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, args []interface{}) *model.Job { job := &model.Job{ SchemaID: dbInfo.ID, TableID: tblInfo.ID, Type: model.ActionAddColumn, Args: args, BinlogInfo: &model.HistoryInfo{}, } err := d.doDDLJob(ctx, job) c.Assert(err, IsNil) v := getSchemaVer(c, ctx) checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) return job } func buildDropIdxJob(dbInfo *model.DBInfo, tblInfo *model.TableInfo, indexName string) *model.Job { return &model.Job{ SchemaID: dbInfo.ID, TableID: tblInfo.ID, Type: model.ActionDropIndex, BinlogInfo: &model.HistoryInfo{}, Args: []interface{}{model.NewCIStr(indexName)}, } } func testDropIndex(c *C, ctx sessionctx.Context, d *ddl, dbInfo *model.DBInfo, tblInfo *model.TableInfo, indexName string) *model.Job { job := buildDropIdxJob(dbInfo, tblInfo, indexName) err := d.doDDLJob(ctx, job) c.Assert(err, IsNil) v := getSchemaVer(c, ctx) checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) return job } func buildRebaseAutoIDJobJob(dbInfo *model.DBInfo, tblInfo *model.TableInfo, newBaseID int64) *model.Job { return &model.Job{ SchemaID: dbInfo.ID, TableID: tblInfo.ID, Type: model.ActionRebaseAutoID, BinlogInfo: &model.HistoryInfo{}, Args: []interface{}{newBaseID}, } }
[ "\"log_level\"" ]
[]
[ "log_level" ]
[]
["log_level"]
go
1
0
testutils/source.go
package testutils import "github.com/securego/gosec/v2" // CodeSample encapsulates a snippet of source code that compiles, and how many errors should be detected type CodeSample struct { Code []string Errors int Config gosec.Config } var ( // SampleCodeG101 code snippets for hardcoded credentials SampleCodeG101 = []CodeSample{ {[]string{` package main import "fmt" func main() { username := "admin" password := "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" fmt.Println("Doing something with: ", username, password) }`}, 1, gosec.NewConfig()}, {[]string{` // Entropy check should not report this error by default package main import "fmt" func main() { username := "admin" password := "secret" fmt.Println("Doing something with: ", username, password) }`}, 0, gosec.NewConfig()}, {[]string{` package main import "fmt" var password = "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" func main() { username := "admin" fmt.Println("Doing something with: ", username, password) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" const password = "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" func main() { username := "admin" fmt.Println("Doing something with: ", username, password) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" const ( username = "user" password = "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" ) func main() { fmt.Println("Doing something with: ", username, password) }`}, 1, gosec.NewConfig()}, {[]string{` package main var password string func init() { password = "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" }`}, 1, gosec.NewConfig()}, {[]string{` package main const ( ATNStateSomethingElse = 1 ATNStateTokenStart = 42 ) func main() { println(ATNStateTokenStart) }`}, 0, gosec.NewConfig()}, {[]string{` package main const ( ATNStateTokenStart = "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" ) func main() { println(ATNStateTokenStart) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" func main() { var password string if password == "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" { fmt.Println("password equality") } }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" func main() { var password string if password != "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" { fmt.Println("password equality") } }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" func main() { var p string if p != "f62e5bcda4fae4f82370da0c6f20697b8f8447ef" { fmt.Println("password equality") } }`}, 0, gosec.NewConfig()}, {[]string{` package main import "fmt" const ( pw = "KjasdlkjapoIKLlka98098sdf012U/rL2sLdBqOHQUlt5Z6kCgKGDyCFA==" ) func main() { fmt.Println(pw) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" var ( pw string ) func main() { pw = "KjasdlkjapoIKLlka98098sdf012U/rL2sLdBqOHQUlt5Z6kCgKGDyCFA==" fmt.Println(pw) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" const ( cred = "KjasdlkjapoIKLlka98098sdf012U/rL2sLdBqOHQUlt5Z6kCgKGDyCFA==" ) func main() { fmt.Println(cred) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" var ( cred string ) func main() { cred = "KjasdlkjapoIKLlka98098sdf012U/rL2sLdBqOHQUlt5Z6kCgKGDyCFA==" fmt.Println(cred) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" const ( apiKey = "KjasdlkjapoIKLlka98098sdf012U" ) func main() { fmt.Println(apiKey) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" var ( apiKey string ) func main() { apiKey = "KjasdlkjapoIKLlka98098sdf012U" fmt.Println(apiKey) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" const ( bearer = "Bearer: 2lkjdfoiuwer092834kjdwf09" ) func main() { fmt.Println(bearer) }`}, 1, gosec.NewConfig()}, {[]string{` package main import "fmt" var ( bearer string ) func main() { bearer = "Bearer: 2lkjdfoiuwer092834kjdwf09" fmt.Println(bearer) }`}, 1, gosec.NewConfig()}, } // SampleCodeG102 code snippets for network binding SampleCodeG102 = []CodeSample{ // Bind to all networks explicitly {[]string{` package main import ( "log" "net" ) func main() { l, err := net.Listen("tcp", "0.0.0.0:2000") if err != nil { log.Fatal(err) } defer l.Close() }`}, 1, gosec.NewConfig()}, // Bind to all networks implicitly (default if host omitted) {[]string{` package main import ( "log" "net" ) func main() { l, err := net.Listen("tcp", ":2000") if err != nil { log.Fatal(err) } defer l.Close() }`}, 1, gosec.NewConfig()}, // Bind to all networks indirectly through a parsing function {[]string{` package main import ( "log" "net" ) func parseListenAddr(listenAddr string) (network string, addr string) { return "", "" } func main() { addr := ":2000" l, err := net.Listen(parseListenAddr(addr)) if err != nil { log.Fatal(err) } defer l.Close() }`}, 1, gosec.NewConfig()}, // Bind to all networks indirectly through a parsing function {[]string{` package main import ( "log" "net" ) const addr = ":2000" func parseListenAddr(listenAddr string) (network string, addr string) { return "", "" } func main() { l, err := net.Listen(parseListenAddr(addr)) if err != nil { log.Fatal(err) } defer l.Close() }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "log" "net" ) const addr = "0.0.0.0:2000" func main() { l, err := net.Listen("tcp", addr) if err != nil { log.Fatal(err) } defer l.Close() }`}, 1, gosec.NewConfig()}, } // SampleCodeG103 find instances of unsafe blocks for auditing purposes SampleCodeG103 = []CodeSample{ {[]string{` package main import ( "fmt" "unsafe" ) type Fake struct{} func (Fake) Good() {} func main() { unsafeM := Fake{} unsafeM.Good() intArray := [...]int{1, 2} fmt.Printf("\nintArray: %v\n", intArray) intPtr := &intArray[0] fmt.Printf("\nintPtr=%p, *intPtr=%d.\n", intPtr, *intPtr) addressHolder := uintptr(unsafe.Pointer(intPtr)) + unsafe.Sizeof(intArray[0]) intPtr = (*int)(unsafe.Pointer(addressHolder)) fmt.Printf("\nintPtr=%p, *intPtr=%d.\n\n", intPtr, *intPtr) }`}, 3, gosec.NewConfig()}, } // SampleCodeG104 finds errors that aren't being handled SampleCodeG104 = []CodeSample{ {[]string{` package main import "fmt" func test() (int,error) { return 0, nil } func main() { v, _ := test() fmt.Println(v) }`}, 0, gosec.NewConfig()}, {[]string{` package main import ( "io/ioutil" "os" "fmt" ) func a() error { return fmt.Errorf("This is an error") } func b() { fmt.Println("b") ioutil.WriteFile("foo.txt", []byte("bar"), os.ModeExclusive) } func c() string { return fmt.Sprintf("This isn't anything") } func main() { _ = a() a() b() c() }`}, 2, gosec.NewConfig()}, {[]string{` package main import "fmt" func test() error { return nil } func main() { e := test() fmt.Println(e) }`}, 0, gosec.NewConfig()}, {[]string{` // +build go1.10 package main import "strings" func main() { var buf strings.Builder _, err := buf.WriteString("test string") if err != nil { panic(err) } }`, ` package main func dummy(){} `}, 0, gosec.NewConfig()}, {[]string{` package main import ( "bytes" ) type a struct { buf *bytes.Buffer } func main() { a := &a{ buf: new(bytes.Buffer), } a.buf.Write([]byte{0}) } `}, 0, gosec.NewConfig()}, {[]string{` package main import ( "io/ioutil" "os" "fmt" ) func a() { fmt.Println("a") ioutil.WriteFile("foo.txt", []byte("bar"), os.ModeExclusive) } func main() { a() }`}, 0, gosec.Config{"G104": map[string]interface{}{"ioutil": []interface{}{"WriteFile"}}}}, {[]string{` package main import ( "bytes" "fmt" "io" "os" "strings" ) func createBuffer() *bytes.Buffer { return new(bytes.Buffer) } func main() { new(bytes.Buffer).WriteString("*bytes.Buffer") fmt.Fprintln(os.Stderr, "fmt") new(strings.Builder).WriteString("*strings.Builder") _, pw := io.Pipe() pw.CloseWithError(io.EOF) createBuffer().WriteString("*bytes.Buffer") b := createBuffer() b.WriteString("*bytes.Buffer") }`}, 0, gosec.NewConfig()}, } // it shoudn't return any errors because all method calls are whitelisted by default // SampleCodeG104Audit finds errors that aren't being handled in audit mode SampleCodeG104Audit = []CodeSample{ {[]string{` package main import "fmt" func test() (int,error) { return 0, nil } func main() { v, _ := test() fmt.Println(v) }`}, 1, gosec.Config{gosec.Globals: map[gosec.GlobalOption]string{gosec.Audit: "enabled"}}}, {[]string{` package main import ( "io/ioutil" "os" "fmt" ) func a() error { return fmt.Errorf("This is an error") } func b() { fmt.Println("b") ioutil.WriteFile("foo.txt", []byte("bar"), os.ModeExclusive) } func c() string { return fmt.Sprintf("This isn't anything") } func main() { _ = a() a() b() c() }`}, 3, gosec.Config{gosec.Globals: map[gosec.GlobalOption]string{gosec.Audit: "enabled"}}}, {[]string{` package main import "fmt" func test() error { return nil } func main() { e := test() fmt.Println(e) }`}, 0, gosec.Config{gosec.Globals: map[gosec.GlobalOption]string{gosec.Audit: "enabled"}}}, {[]string{` // +build go1.10 package main import "strings" func main() { var buf strings.Builder _, err := buf.WriteString("test string") if err != nil { panic(err) } }`, ` package main func dummy(){} `}, 0, gosec.Config{gosec.Globals: map[gosec.GlobalOption]string{gosec.Audit: "enabled"}}}, } // SampleCodeG106 - ssh InsecureIgnoreHostKey SampleCodeG106 = []CodeSample{{[]string{` package main import ( "golang.org/x/crypto/ssh" ) func main() { _ = ssh.InsecureIgnoreHostKey() }`}, 1, gosec.NewConfig()}} // SampleCodeG107 - SSRF via http requests with variable url SampleCodeG107 = []CodeSample{{[]string{` // Input from the std in is considered insecure package main import ( "net/http" "io/ioutil" "fmt" "os" "bufio" ) func main() { in := bufio.NewReader(os.Stdin) url, err := in.ReadString('\n') if err != nil { panic(err) } resp, err := http.Get(url) if err != nil { panic(err) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { panic(err) } fmt.Printf("%s", body) }`}, 1, gosec.NewConfig()}, {[]string{` // Variable defined a package level can be changed at any time // regardless of the initial value package main import ( "fmt" "io/ioutil" "net/http" ) var url string = "https://www.google.com" func main() { resp, err := http.Get(url) if err != nil { panic(err) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { panic(err) } fmt.Printf("%s", body) }`}, 1, gosec.NewConfig()}, {[]string{` // Environmental variables are not considered as secure source package main import ( "net/http" "io/ioutil" "fmt" "os" ) func main() { url := os.Getenv("tainted_url") resp, err := http.Get(url) if err != nil { panic(err) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { panic(err) } fmt.Printf("%s", body) }`}, 1, gosec.NewConfig()}, {[]string{` // Constant variables or hard-coded strings are secure package main import ( "fmt" "net/http" ) const url = "http://127.0.0.1" func main() { resp, err := http.Get(url) if err != nil { fmt.Println(err) } fmt.Println(resp.Status) }`}, 0, gosec.NewConfig()}, {[]string{` // A variable at function scope which is initialized to // a constant string is secure (e.g. cannot be changed concurrently) package main import ( "fmt" "net/http" ) func main() { var url string = "http://127.0.0.1" resp, err := http.Get(url) if err != nil { fmt.Println(err) } fmt.Println(resp.Status) }`}, 0, gosec.NewConfig()}, {[]string{` // A variable at function scope which is initialized to // a constant string is secure (e.g. cannot be changed concurrently) package main import ( "fmt" "net/http" ) func main() { url := "http://127.0.0.1" resp, err := http.Get(url) if err != nil { fmt.Println(err) } fmt.Println(resp.Status) }`}, 0, gosec.NewConfig()}, {[]string{` // A variable at function scope which is initialized to // a constant string is secure (e.g. cannot be changed concurrently) package main import ( "fmt" "net/http" ) func main() { url1 := "test" var url2 string = "http://127.0.0.1" url2 = url1 resp, err := http.Get(url2) if err != nil { fmt.Println(err) } fmt.Println(resp.Status) }`}, 0, gosec.NewConfig()}, {[]string{` // An exported variable declared a packaged scope is not secure // because it can changed at any time package main import ( "fmt" "net/http" ) var Url string func main() { resp, err := http.Get(Url) if err != nil { fmt.Println(err) } fmt.Println(resp.Status) }`}, 1, gosec.NewConfig()}, {[]string{` // An url provided as a function argument is not secure package main import ( "fmt" "net/http" ) func get(url string) { resp, err := http.Get(url) if err != nil { fmt.Println(err) } fmt.Println(resp.Status) } func main() { url := "http://127.0.0.1" get(url) }`}, 1, gosec.NewConfig()}} // SampleCodeG108 - pprof endpoint automatically exposed SampleCodeG108 = []CodeSample{{[]string{` package main import ( "fmt" "log" "net/http" _ "net/http/pprof" ) func main() { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello World!") }) log.Fatal(http.ListenAndServe(":8080", nil)) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "log" "net/http" ) func main() { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello World!") }) log.Fatal(http.ListenAndServe(":8080", nil)) }`}, 0, gosec.NewConfig()}} // SampleCodeG109 - Potential Integer OverFlow SampleCodeG109 = []CodeSample{ {[]string{` package main import ( "fmt" "strconv" ) func main() { bigValue, err := strconv.Atoi("2147483648") if err != nil { panic(err) } value := int32(bigValue) fmt.Println(value) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "strconv" ) func main() { bigValue, err := strconv.Atoi("32768") if err != nil { panic(err) } if int16(bigValue) < 0 { fmt.Println(bigValue) } }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "strconv" ) func main() { bigValue, err := strconv.Atoi("2147483648") if err != nil { panic(err) } fmt.Println(bigValue) }`}, 0, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "strconv" ) func main() { bigValue, err := strconv.Atoi("2147483648") if err != nil { panic(err) } fmt.Println(bigValue) test() } func test() { bigValue := 30 value := int32(bigValue) fmt.Println(value) }`}, 0, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "strconv" ) func main() { value := 10 if value == 10 { value, _ := strconv.Atoi("2147483648") fmt.Println(value) } v := int32(value) fmt.Println(v) }`}, 0, gosec.NewConfig()}, } // SampleCodeG110 - potential DoS vulnerability via decompression bomb SampleCodeG110 = []CodeSample{ {[]string{` package main import ( "bytes" "compress/zlib" "io" "os" ) func main() { buff := []byte{120, 156, 202, 72, 205, 201, 201, 215, 81, 40, 207, 47, 202, 73, 225, 2, 4, 0, 0, 255, 255, 33, 231, 4, 147} b := bytes.NewReader(buff) r, err := zlib.NewReader(b) if err != nil { panic(err) } _, err = io.Copy(os.Stdout, r) if err != nil { panic(err) } r.Close() }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "bytes" "compress/zlib" "io" "os" ) func main() { buff := []byte{120, 156, 202, 72, 205, 201, 201, 215, 81, 40, 207, 47, 202, 73, 225, 2, 4, 0, 0, 255, 255, 33, 231, 4, 147} b := bytes.NewReader(buff) r, err := zlib.NewReader(b) if err != nil { panic(err) } buf := make([]byte, 8) _, err = io.CopyBuffer(os.Stdout, r, buf) if err != nil { panic(err) } r.Close() }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "archive/zip" "io" "os" "strconv" ) func main() { r, err := zip.OpenReader("tmp.zip") if err != nil { panic(err) } defer r.Close() for i, f := range r.File { out, err := os.OpenFile("output" + strconv.Itoa(i), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode()) if err != nil { panic(err) } rc, err := f.Open() if err != nil { panic(err) } _, err = io.Copy(out, rc) out.Close() rc.Close() if err != nil { panic(err) } } }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "io" "os" ) func main() { s, err := os.Open("src") if err != nil { panic(err) } defer s.Close() d, err := os.Create("dst") if err != nil { panic(err) } defer d.Close() _, err = io.Copy(d, s) if err != nil { panic(err) } }`}, 0, gosec.NewConfig()}, } // SampleCodeG201 - SQL injection via format string SampleCodeG201 = []CodeSample{ {[]string{` // Format string without proper quoting package main import ( "database/sql" "fmt" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT * FROM foo where name = '%s'", os.Args[1]) rows, err := db.Query(q) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // Format string without proper quoting case insensitive package main import ( "database/sql" "fmt" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("select * from foo where name = '%s'", os.Args[1]) rows, err := db.Query(q) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // Format string without proper quoting with context package main import ( "context" "database/sql" "fmt" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("select * from foo where name = '%s'", os.Args[1]) rows, err := db.QueryContext(context.Background(), q) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // Format string without proper quoting with transaction package main import ( "context" "database/sql" "fmt" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } tx, err := db.Begin() if err != nil { panic(err) } defer tx.Rollback() q := fmt.Sprintf("select * from foo where name = '%s'", os.Args[1]) rows, err := tx.QueryContext(context.Background(), q) if err != nil { panic(err) } defer rows.Close() if err := tx.Commit(); err != nil { panic(err) } }`}, 1, gosec.NewConfig()}, {[]string{` // Format string false positive, safe string spec. package main import ( "database/sql" "fmt" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT * FROM foo where id = %d", os.Args[1]) rows, err := db.Query(q) if err != nil { panic(err) } defer rows.Close() }`}, 0, gosec.NewConfig()}, {[]string{` // Format string false positive package main import ( "database/sql" ) const staticQuery = "SELECT * FROM foo WHERE age < 32" func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.Query(staticQuery) if err != nil { panic(err) } defer rows.Close() }`}, 0, gosec.NewConfig()}, {[]string{` // Format string false positive, quoted formatter argument. package main import ( "database/sql" "fmt" "os" "github.com/lib/pq" ) func main(){ db, err := sql.Open("postgres", "localhost") if err != nil { panic(err) } q := fmt.Sprintf("SELECT * FROM %s where id = 1", pq.QuoteIdentifier(os.Args[1])) rows, err := db.Query(q) if err != nil { panic(err) } defer rows.Close() }`}, 0, gosec.NewConfig()}, {[]string{` // false positive package main import ( "database/sql" "fmt" ) const Table = "foo" func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT * FROM %s where id = 1", Table) rows, err := db.Query(q) if err != nil { panic(err) } defer rows.Close() }`}, 0, gosec.NewConfig()}, {[]string{` package main import ( "fmt" ) func main(){ fmt.Sprintln() }`}, 0, gosec.NewConfig()}, {[]string{` // Format string with \n\r package main import ( "database/sql" "fmt" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT * FROM foo where\n name = '%s'", os.Args[1]) rows, err := db.Query(q) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // Format string with \n\r package main import ( "database/sql" "fmt" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT * FROM foo where\nname = '%s'", os.Args[1]) rows, err := db.Query(q) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // SQLI by db.Query(some).Scan(&other) package main import ( "database/sql" "fmt" "os" ) func main() { var name string db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT name FROM users where id = '%s'", os.Args[1]) row := db.QueryRow(q) err = row.Scan(&name) if err != nil { panic(err) } defer db.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // SQLI by db.Query(some).Scan(&other) package main import ( "database/sql" "fmt" "os" ) func main() { var name string db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT name FROM users where id = '%s'", os.Args[1]) err = db.QueryRow(q).Scan(&name) if err != nil { panic(err) } defer db.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // SQLI by db.Prepare(some) package main import ( "database/sql" "fmt" "log" "os" ) const Table = "foo" func main() { var album string db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT name FROM users where '%s' = ?", os.Args[1]) stmt, err := db.Prepare(q) if err != nil { log.Fatal(err) } stmt.QueryRow(fmt.Sprintf("%s", os.Args[2])).Scan(&album) if err != nil { if err == sql.ErrNoRows { log.Fatal(err) } } defer stmt.Close() } `}, 1, gosec.NewConfig()}, {[]string{` // SQLI by db.PrepareContext(some) package main import ( "context" "database/sql" "fmt" "log" "os" ) const Table = "foo" func main() { var album string db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } q := fmt.Sprintf("SELECT name FROM users where '%s' = ?", os.Args[1]) stmt, err := db.PrepareContext(context.Background(), q) if err != nil { log.Fatal(err) } stmt.QueryRow(fmt.Sprintf("%s", os.Args[2])).Scan(&album) if err != nil { if err == sql.ErrNoRows { log.Fatal(err) } } defer stmt.Close() } `}, 1, gosec.NewConfig()}, {[]string{` // false positive package main import ( "database/sql" "fmt" "log" "os" ) const Table = "foo" func main() { var album string db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } stmt, err := db.Prepare("SELECT * FROM album WHERE id = ?") if err != nil { log.Fatal(err) } stmt.QueryRow(fmt.Sprintf("%s", os.Args[1])).Scan(&album) if err != nil { if err == sql.ErrNoRows { log.Fatal(err) } } defer stmt.Close() } `}, 0, gosec.NewConfig()}, } // SampleCodeG202 - SQL query string building via string concatenation SampleCodeG202 = []CodeSample{ {[]string{` package main import ( "database/sql" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.Query("SELECT * FROM foo WHERE name = " + os.Args[1]) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // case insensitive match package main import ( "database/sql" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.Query("select * from foo where name = " + os.Args[1]) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // context match package main import ( "context" "database/sql" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.QueryContext(context.Background(), "select * from foo where name = " + os.Args[1]) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // DB transaction check package main import ( "context" "database/sql" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } tx, err := db.Begin() if err != nil { panic(err) } defer tx.Rollback() rows, err := tx.QueryContext(context.Background(), "select * from foo where name = " + os.Args[1]) if err != nil { panic(err) } defer rows.Close() if err := tx.Commit(); err != nil { panic(err) } }`}, 1, gosec.NewConfig()}, {[]string{` // multiple string concatenation package main import ( "database/sql" "os" ) func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.Query("SELECT * FROM foo" + "WHERE name = " + os.Args[1]) if err != nil { panic(err) } defer rows.Close() }`}, 1, gosec.NewConfig()}, {[]string{` // false positive package main import ( "database/sql" ) var staticQuery = "SELECT * FROM foo WHERE age < " func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.Query(staticQuery + "32") if err != nil { panic(err) } defer rows.Close() }`}, 0, gosec.NewConfig()}, {[]string{` package main import ( "database/sql" ) const age = "32" var staticQuery = "SELECT * FROM foo WHERE age < " func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.Query(staticQuery + age) if err != nil { panic(err) } defer rows.Close() } `}, 0, gosec.NewConfig()}, {[]string{` package main const gender = "M" `, ` package main import ( "database/sql" ) const age = "32" var staticQuery = "SELECT * FROM foo WHERE age < " func main(){ db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } rows, err := db.Query("SELECT * FROM foo WHERE gender = " + gender) if err != nil { panic(err) } defer rows.Close() } `}, 0, gosec.NewConfig()}, {[]string{` // ExecContext match package main import ( "context" "database/sql" "fmt" "os" ) func main() { db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } result, err := db.ExecContext(context.Background(), "select * from foo where name = "+os.Args[1]) if err != nil { panic(err) } fmt.Println(result) }`}, 1, gosec.NewConfig()}, {[]string{` // Exec match package main import ( "database/sql" "fmt" "os" ) func main() { db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } result, err := db.Exec("select * from foo where name = " + os.Args[1]) if err != nil { panic(err) } fmt.Println(result) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "database/sql" "fmt" ) const gender = "M" const age = "32" var staticQuery = "SELECT * FROM foo WHERE age < " func main() { db, err := sql.Open("sqlite3", ":memory:") if err != nil { panic(err) } result, err := db.Exec("SELECT * FROM foo WHERE gender = " + gender) if err != nil { panic(err) } fmt.Println(result) } `}, 0, gosec.NewConfig()}, } // SampleCodeG203 - Template checks SampleCodeG203 = []CodeSample{ {[]string{` // We assume that hardcoded template strings are safe as the programmer would // need to be explicitly shooting themselves in the foot (as below) package main import ( "html/template" "os" ) const tmpl = "" func main() { t := template.Must(template.New("ex").Parse(tmpl)) v := map[string]interface{}{ "Title": "Test <b>World</b>", "Body": template.HTML("<script>alert(1)</script>"), } t.Execute(os.Stdout, v) }`}, 0, gosec.NewConfig()}, {[]string{ ` // Using a variable to initialize could potentially be dangerous. Under the // current model this will likely produce some false positives. package main import ( "html/template" "os" ) const tmpl = "" func main() { a := "something from another place" t := template.Must(template.New("ex").Parse(tmpl)) v := map[string]interface{}{ "Title": "Test <b>World</b>", "Body": template.HTML(a), } t.Execute(os.Stdout, v) }`, }, 1, gosec.NewConfig()}, {[]string{ ` package main import ( "html/template" "os" ) const tmpl = "" func main() { a := "something from another place" t := template.Must(template.New("ex").Parse(tmpl)) v := map[string]interface{}{ "Title": "Test <b>World</b>", "Body": template.JS(a), } t.Execute(os.Stdout, v) }`, }, 1, gosec.NewConfig()}, {[]string{ ` package main import ( "html/template" "os" ) const tmpl = "" func main() { a := "something from another place" t := template.Must(template.New("ex").Parse(tmpl)) v := map[string]interface{}{ "Title": "Test <b>World</b>", "Body": template.URL(a), } t.Execute(os.Stdout, v) }`, }, 1, gosec.NewConfig()}, } // SampleCodeG204 - Subprocess auditing SampleCodeG204 = []CodeSample{ {[]string{` package main import ( "log" "os/exec" "context" ) func main() { err := exec.CommandContext(context.Background(), "git", "rev-parse", "--show-toplavel").Run() if err != nil { log.Fatal(err) } log.Printf("Command finished with error: %v", err) }`}, 0, gosec.NewConfig()}, {[]string{` // Calling any function which starts a new process with using // command line arguments as it's arguments is considered dangerous package main import ( "context" "log" "os" "os/exec" ) func main() { err := exec.CommandContext(context.Background(), os.Args[0], "5").Run() if err != nil { log.Fatal(err) } log.Printf("Command finished with error: %v", err) }`}, 1, gosec.NewConfig()}, {[]string{` // Initializing a local variable using a environmental // variable is consider as a dangerous user input package main import ( "log" "os" "os/exec" ) func main() { run := "sleep" + os.Getenv("SOMETHING") cmd := exec.Command(run, "5") err := cmd.Start() if err != nil { log.Fatal(err) } log.Printf("Waiting for command to finish...") err = cmd.Wait() log.Printf("Command finished with error: %v", err) }`}, 1, gosec.NewConfig()}, {[]string{` // gosec doesn't have enough context to decide that the // command argument of the RunCmd function is harcoded string // and that's why it's better to warn the user so he can audit it package main import ( "log" "os/exec" ) func RunCmd(command string) { cmd := exec.Command(command, "5") err := cmd.Start() if err != nil { log.Fatal(err) } log.Printf("Waiting for command to finish...") err = cmd.Wait() } func main() { RunCmd("sleep") }`}, 0, gosec.NewConfig()}, {[]string{` package main import ( "log" "os/exec" ) func RunCmd(a string, c string) { cmd := exec.Command(c) err := cmd.Start() if err != nil { log.Fatal(err) } log.Printf("Waiting for command to finish...") err = cmd.Wait() cmd = exec.Command(a) err = cmd.Start() if err != nil { log.Fatal(err) } log.Printf("Waiting for command to finish...") err = cmd.Wait() } func main() { RunCmd("ll", "ls") }`}, 0, gosec.NewConfig()}, {[]string{` // syscall.Exec function called with harcoded arguments // shouldn't be consider as a command injection package main import ( "fmt" "syscall" ) func main() { err := syscall.Exec("/bin/cat", []string{"/etc/passwd"}, nil) if err != nil { fmt.Printf("Error: %v\n", err) } }`}, 0, gosec.NewConfig()}, { []string{` package main import ( "fmt" "syscall" ) func RunCmd(command string) { _, err := syscall.ForkExec(command, []string{}, nil) if err != nil { fmt.Printf("Error: %v\n", err) } } func main() { RunCmd("sleep") }`}, 1, gosec.NewConfig(), }, { []string{` package main import ( "fmt" "syscall" ) func RunCmd(command string) { _, _, err := syscall.StartProcess(command, []string{}, nil) if err != nil { fmt.Printf("Error: %v\n", err) } } func main() { RunCmd("sleep") }`}, 1, gosec.NewConfig(), }, {[]string{` // starting a process with a variable as an argument // even if not constant is not considered as dangerous // because it has harcoded value package main import ( "log" "os/exec" ) func main() { run := "sleep" cmd := exec.Command(run, "5") err := cmd.Start() if err != nil { log.Fatal(err) } log.Printf("Waiting for command to finish...") err = cmd.Wait() log.Printf("Command finished with error: %v", err) }`}, 0, gosec.NewConfig()}, {[]string{` // exec.Command from supplemental package sys/execabs // using variable arguments package main import ( "context" "log" "os" exec "golang.org/x/sys/execabs" ) func main() { err := exec.CommandContext(context.Background(), os.Args[0], "5").Run() if err != nil { log.Fatal(err) } log.Printf("Command finished with error: %v", err) } `}, 1, gosec.NewConfig()}, } // SampleCodeG301 - mkdir permission check SampleCodeG301 = []CodeSample{{[]string{` package main import ( "fmt" "os" ) func main() { err := os.Mkdir("/tmp/mydir", 0777) if err != nil { fmt.Println("Error when creating a directory!") return } }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "os" ) func main() { err := os.MkdirAll("/tmp/mydir", 0777) if err != nil { fmt.Println("Error when creating a directory!") return } }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "os" ) func main() { err := os.Mkdir("/tmp/mydir", 0600) if err != nil { fmt.Println("Error when creating a directory!") return } }`}, 0, gosec.NewConfig()}} // SampleCodeG302 - file create / chmod permissions check SampleCodeG302 = []CodeSample{{[]string{` package main import ( "fmt" "os" ) func main() { err := os.Chmod("/tmp/somefile", 0777) if err != nil { fmt.Println("Error when changing file permissions!") return } }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "os" ) func main() { _, err := os.OpenFile("/tmp/thing", os.O_CREATE|os.O_WRONLY, 0666) if err != nil { fmt.Println("Error opening a file!") return } }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "os" ) func main() { err := os.Chmod("/tmp/mydir", 0400) if err != nil { fmt.Println("Error") return } }`}, 0, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "os" ) func main() { _, err := os.OpenFile("/tmp/thing", os.O_CREATE|os.O_WRONLY, 0600) if err != nil { fmt.Println("Error opening a file!") return } } `}, 0, gosec.NewConfig()}} // SampleCodeG303 - bad tempfile permissions & hardcoded shared path SampleCodeG303 = []CodeSample{{[]string{` package samples import ( "fmt" "io/ioutil" "os" "path" "path/filepath" ) func main() { err := ioutil.WriteFile("/tmp/demo2", []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } f, err := os.Create("/tmp/demo2") if err != nil { fmt.Println("Error while writing!") } else if err = f.Close(); err != nil { fmt.Println("Error while closing!") } err = os.WriteFile("/tmp/demo2", []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } err = os.WriteFile("/usr/tmp/demo2", []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } err = os.WriteFile("/tmp/" + "demo2", []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } err = os.WriteFile(os.TempDir() + "/demo2", []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } err = os.WriteFile(path.Join("/var/tmp", "demo2"), []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } err = os.WriteFile(path.Join(os.TempDir(), "demo2"), []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } err = os.WriteFile(filepath.Join(os.TempDir(), "demo2"), []byte("This is some data"), 0644) if err != nil { fmt.Println("Error while writing!") } }`}, 9, gosec.NewConfig()}} // SampleCodeG304 - potential file inclusion vulnerability SampleCodeG304 = []CodeSample{ {[]string{` package main import ( "os" "io/ioutil" "log" ) func main() { f := os.Getenv("tainted_file") body, err := ioutil.ReadFile(f) if err != nil { log.Printf("Error: %v\n", err) } log.Print(body) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "os" "log" ) func main() { f := os.Getenv("tainted_file") body, err := os.ReadFile(f) if err != nil { log.Printf("Error: %v\n", err) } log.Print(body) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "log" "net/http" "os" ) func main() { http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) { title := r.URL.Query().Get("title") f, err := os.Open(title) if err != nil { fmt.Printf("Error: %v\n", err) } body := make([]byte, 5) if _, err = f.Read(body); err != nil { fmt.Printf("Error: %v\n", err) } fmt.Fprintf(w, "%s", body) }) log.Fatal(http.ListenAndServe(":3000", nil)) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "fmt" "log" "net/http" "os" ) func main() { http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) { title := r.URL.Query().Get("title") f, err := os.OpenFile(title, os.O_RDWR|os.O_CREATE, 0755) if err != nil { fmt.Printf("Error: %v\n", err) } body := make([]byte, 5) if _, err = f.Read(body); err != nil { fmt.Printf("Error: %v\n", err) } fmt.Fprintf(w, "%s", body) }) log.Fatal(http.ListenAndServe(":3000", nil)) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "log" "os" "io/ioutil" ) func main() { f2 := os.Getenv("tainted_file2") body, err := ioutil.ReadFile("/tmp/" + f2) if err != nil { log.Printf("Error: %v\n", err) } log.Print(body) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "bufio" "fmt" "os" "path/filepath" ) func main() { reader := bufio.NewReader(os.Stdin) fmt.Print("Please enter file to read: ") file, _ := reader.ReadString('\n') file = file[:len(file)-1] f, err := os.Open(filepath.Join("/tmp/service/", file)) if err != nil { fmt.Printf("Error: %v\n", err) } contents := make([]byte, 15) if _, err = f.Read(contents); err != nil { fmt.Printf("Error: %v\n", err) } fmt.Println(string(contents)) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "log" "os" "io/ioutil" "path/filepath" ) func main() { dir := os.Getenv("server_root") f3 := os.Getenv("tainted_file3") // edge case where both a binary expression and file Join are used. body, err := ioutil.ReadFile(filepath.Join("/var/"+dir, f3)) if err != nil { log.Printf("Error: %v\n", err) } log.Print(body) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "os" "path/filepath" ) func main() { repoFile := "path_of_file" cleanRepoFile := filepath.Clean(repoFile) _, err := os.OpenFile(cleanRepoFile, os.O_RDONLY, 0600) if err != nil { panic(err) } } `}, 0, gosec.NewConfig()}, {[]string{` package main import ( "os" "path/filepath" ) func openFile(filePath string) { _, err := os.OpenFile(filepath.Clean(filePath), os.O_RDONLY, 0600) if err != nil { panic(err) } } func main() { repoFile := "path_of_file" openFile(repoFile) } `}, 0, gosec.NewConfig()}, {[]string{` package main import ( "os" "path/filepath" ) func main() { repoFile := "path_of_file" relFile, err := filepath.Rel("./", repoFile) if err != nil { panic(err) } _, err = os.OpenFile(relFile, os.O_RDONLY, 0600) if err != nil { panic(err) } } `}, 0, gosec.NewConfig()}, {[]string{` package main import ( "io" "os" ) func createFile(file string) *os.File { f, err := os.Create(file) if err != nil { panic(err) } return f } func main() { s, err := os.Open("src") if err != nil { panic(err) } defer s.Close() d := createFile("dst") defer d.Close() _, err = io.Copy(d, s) if err != nil { panic(err) } }`}, 1, gosec.NewConfig()}, } // SampleCodeG305 - File path traversal when extracting zip/tar archives SampleCodeG305 = []CodeSample{{[]string{` package unzip import ( "archive/zip" "io" "os" "path/filepath" ) func unzip(archive, target string) error { reader, err := zip.OpenReader(archive) if err != nil { return err } if err := os.MkdirAll(target, 0750); err != nil { return err } for _, file := range reader.File { path := filepath.Join(target, file.Name) if file.FileInfo().IsDir() { os.MkdirAll(path, file.Mode()) //#nosec continue } fileReader, err := file.Open() if err != nil { return err } defer fileReader.Close() targetFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode()) if err != nil { return err } defer targetFile.Close() if _, err := io.Copy(targetFile, fileReader); err != nil { return err } } return nil }`}, 1, gosec.NewConfig()}, {[]string{` package unzip import ( "archive/zip" "io" "os" "path/filepath" ) func unzip(archive, target string) error { reader, err := zip.OpenReader(archive) if err != nil { return err } if err := os.MkdirAll(target, 0750); err != nil { return err } for _, file := range reader.File { archiveFile := file.Name path := filepath.Join(target, archiveFile) if file.FileInfo().IsDir() { os.MkdirAll(path, file.Mode()) //#nosec continue } fileReader, err := file.Open() if err != nil { return err } defer fileReader.Close() targetFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode()) if err != nil { return err } defer targetFile.Close() if _, err := io.Copy(targetFile, fileReader); err != nil { return err } } return nil }`}, 1, gosec.NewConfig()}, {[]string{` package zip import ( "archive/zip" "io" "os" "path" ) func extractFile(f *zip.File, destPath string) error { filePath := path.Join(destPath, f.Name) os.MkdirAll(path.Dir(filePath), os.ModePerm) rc, err := f.Open() if err != nil { return err } defer rc.Close() fw, err := os.Create(filePath) if err != nil { return err } defer fw.Close() if _, err = io.Copy(fw, rc); err != nil { return err } if f.FileInfo().Mode()&os.ModeSymlink != 0 { return nil } if err = os.Chtimes(filePath, f.ModTime(), f.ModTime()); err != nil { return err } return os.Chmod(filePath, f.FileInfo().Mode()) }`}, 1, gosec.NewConfig()}, {[]string{` package tz import ( "archive/tar" "io" "os" "path" ) func extractFile(f *tar.Header, tr *tar.Reader, destPath string) error { filePath := path.Join(destPath, f.Name) os.MkdirAll(path.Dir(filePath), os.ModePerm) fw, err := os.Create(filePath) if err != nil { return err } defer fw.Close() if _, err = io.Copy(fw, tr); err != nil { return err } if f.FileInfo().Mode()&os.ModeSymlink != 0 { return nil } if err = os.Chtimes(filePath, f.FileInfo().ModTime(), f.FileInfo().ModTime()); err != nil { return err } return os.Chmod(filePath, f.FileInfo().Mode()) }`}, 1, gosec.NewConfig()}} // SampleCodeG306 - Poor permissions for WriteFile SampleCodeG306 = []CodeSample{ {[]string{`package main import ( "bufio" "fmt" "io/ioutil" "os" ) func check(e error) { if e != nil { panic(e) } } func main() { d1 := []byte("hello\ngo\n") err := ioutil.WriteFile("/tmp/dat1", d1, 0744) check(err) allowed := ioutil.WriteFile("/tmp/dat1", d1, 0600) check(allowed) f, err := os.Create("/tmp/dat2") check(err) defer f.Close() d2 := []byte{115, 111, 109, 101, 10} n2, err := f.Write(d2) defer check(err) fmt.Printf("wrote %d bytes\n", n2) n3, err := f.WriteString("writes\n") fmt.Printf("wrote %d bytes\n", n3) f.Sync() w := bufio.NewWriter(f) n4, err := w.WriteString("buffered\n") fmt.Printf("wrote %d bytes\n", n4) w.Flush() }`}, 1, gosec.NewConfig()}, } // SampleCodeG307 - Unsafe defer of os.Close SampleCodeG307 = []CodeSample{ {[]string{`package main import ( "bufio" "fmt" "io/ioutil" "os" ) func check(e error) { if e != nil { panic(e) } } func main() { d1 := []byte("hello\ngo\n") err := ioutil.WriteFile("/tmp/dat1", d1, 0744) check(err) allowed := ioutil.WriteFile("/tmp/dat1", d1, 0600) check(allowed) f, err := os.Create("/tmp/dat2") check(err) defer f.Close() d2 := []byte{115, 111, 109, 101, 10} n2, err := f.Write(d2) defer check(err) fmt.Printf("wrote %d bytes\n", n2) n3, err := f.WriteString("writes\n") fmt.Printf("wrote %d bytes\n", n3) f.Sync() w := bufio.NewWriter(f) n4, err := w.WriteString("buffered\n") fmt.Printf("wrote %d bytes\n", n4) w.Flush() }`}, 1, gosec.NewConfig()}, } // SampleCodeG401 - Use of weak crypto MD5 SampleCodeG401 = []CodeSample{ {[]string{` package main import ( "crypto/md5" "fmt" "io" "log" "os" ) func main() { f, err := os.Open("file.txt") if err != nil { log.Fatal(err) } defer f.Close() defer func() { err := f.Close() if err != nil { log.Printf("error closing the file: %s", err) } }() h := md5.New() if _, err := io.Copy(h, f); err != nil { log.Fatal(err) } fmt.Printf("%x", h.Sum(nil)) }`}, 1, gosec.NewConfig()}, } // SampleCodeG401b - Use of weak crypto SHA1 SampleCodeG401b = []CodeSample{ {[]string{` package main import ( "crypto/sha1" "fmt" "io" "log" "os" ) func main() { f, err := os.Open("file.txt") if err != nil { log.Fatal(err) } defer f.Close() h := sha1.New() if _, err := io.Copy(h, f); err != nil { log.Fatal(err) } fmt.Printf("%x", h.Sum(nil)) }`}, 1, gosec.NewConfig()}, } // SampleCodeG402 - TLS settings SampleCodeG402 = []CodeSample{ {[]string{` // InsecureSkipVerify package main import ( "crypto/tls" "fmt" "net/http" ) func main() { tr := &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } client := &http.Client{Transport: tr} _, err := client.Get("https://golang.org/") if err != nil { fmt.Println(err) } }`}, 1, gosec.NewConfig()}, {[]string{ ` // Insecure minimum version package main import ( "crypto/tls" "fmt" "net/http" ) func main() { tr := &http.Transport{ TLSClientConfig: &tls.Config{MinVersion: 0}, } client := &http.Client{Transport: tr} _, err := client.Get("https://golang.org/") if err != nil { fmt.Println(err) } }`, }, 1, gosec.NewConfig()}, {[]string{ ` // Insecure minimum version package main import ( "crypto/tls" "fmt" ) func CaseNotError() *tls.Config { var v uint16 = tls.VersionTLS13 return &tls.Config{ MinVersion: v, } } func main() { a := CaseNotError() fmt.Printf("Debug: %v\n", a.MinVersion) }`, }, 0, gosec.NewConfig()}, {[]string{ ` // Insecure minimum version package main import ( "crypto/tls" "fmt" ) func CaseNotError() *tls.Config { return &tls.Config{ MinVersion: tls.VersionTLS13, } } func main() { a := CaseNotError() fmt.Printf("Debug: %v\n", a.MinVersion) }`, }, 0, gosec.NewConfig()}, {[]string{ ` // Insecure minimum version package main import ( "crypto/tls" "fmt" ) func CaseError() *tls.Config { var v = &tls.Config{ MinVersion: 0, } return v } func main() { a := CaseError() fmt.Printf("Debug: %v\n", a.MinVersion) }`, }, 1, gosec.NewConfig()}, {[]string{ ` // Insecure minimum version package main import ( "crypto/tls" "fmt" ) func CaseError() *tls.Config { var v = &tls.Config{ MinVersion: getVersion(), } return v } func getVersion() uint16 { return tls.VersionTLS12 } func main() { a := CaseError() fmt.Printf("Debug: %v\n", a.MinVersion) }`, }, 1, gosec.NewConfig()}, {[]string{ ` // Insecure minimum version package main import ( "crypto/tls" "fmt" "net/http" ) var theValue uint16 = 0x0304 func main() { tr := &http.Transport{ TLSClientConfig: &tls.Config{MinVersion: theValue}, } client := &http.Client{Transport: tr} _, err := client.Get("https://golang.org/") if err != nil { fmt.Println(err) } } `, }, 0, gosec.NewConfig()}, {[]string{` // Insecure max version package main import ( "crypto/tls" "fmt" "net/http" ) func main() { tr := &http.Transport{ TLSClientConfig: &tls.Config{MaxVersion: 0}, } client := &http.Client{Transport: tr} _, err := client.Get("https://golang.org/") if err != nil { fmt.Println(err) } } `}, 1, gosec.NewConfig()}, { []string{` // Insecure ciphersuite selection package main import ( "crypto/tls" "fmt" "net/http" ) func main() { tr := &http.Transport{ TLSClientConfig: &tls.Config{CipherSuites: []uint16{ tls.TLS_RSA_WITH_AES_128_GCM_SHA256, tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, },}, } client := &http.Client{Transport: tr} _, err := client.Get("https://golang.org/") if err != nil { fmt.Println(err) } }`}, 1, gosec.NewConfig(), }, {[]string{` // secure max version when min version is specified package main import ( "crypto/tls" "fmt" "net/http" ) func main() { tr := &http.Transport{ TLSClientConfig: &tls.Config{MaxVersion: 0, MinVersion: tls.VersionTLS13}, } client := &http.Client{Transport: tr} _, err := client.Get("https://golang.org/") if err != nil { fmt.Println(err) } }`}, 0, gosec.NewConfig()}, {[]string{` package p0 import "crypto/tls" func TlsConfig0() *tls.Config { var v uint16 = 0 return &tls.Config{MinVersion: v} } `, ` package p0 import "crypto/tls" func TlsConfig1() *tls.Config { return &tls.Config{MinVersion: 0x0304} } `}, 1, gosec.NewConfig()}, } // SampleCodeG403 - weak key strength SampleCodeG403 = []CodeSample{ {[]string{` package main import ( "crypto/rand" "crypto/rsa" "fmt" ) func main() { //Generate Private Key pvk, err := rsa.GenerateKey(rand.Reader, 1024) if err != nil { fmt.Println(err) } fmt.Println(pvk) }`}, 1, gosec.NewConfig()}, } // SampleCodeG404 - weak random number SampleCodeG404 = []CodeSample{ {[]string{` package main import "crypto/rand" func main() { good, _ := rand.Read(nil) println(good) }`}, 0, gosec.NewConfig()}, {[]string{` package main import "math/rand" func main() { bad := rand.Int() println(bad) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "crypto/rand" mrand "math/rand" ) func main() { good, _ := rand.Read(nil) println(good) bad := mrand.Int31() println(bad) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "math/rand" ) func main() { gen := rand.New(rand.NewSource(10)) bad := gen.Int() println(bad) }`}, 1, gosec.NewConfig()}, {[]string{` package main import ( "math/rand" ) func main() { bad := rand.Intn(10) println(bad) }`}, 1, gosec.NewConfig()}, } // SampleCodeG501 - Blocklisted import MD5 SampleCodeG501 = []CodeSample{ {[]string{` package main import ( "crypto/md5" "fmt" "os" ) func main() { for _, arg := range os.Args { fmt.Printf("%x - %s\n", md5.Sum([]byte(arg)), arg) } }`}, 1, gosec.NewConfig()}, } // SampleCodeG502 - Blocklisted import DES SampleCodeG502 = []CodeSample{ {[]string{` package main import ( "crypto/cipher" "crypto/des" "crypto/rand" "encoding/hex" "fmt" "io" ) func main() { block, err := des.NewCipher([]byte("sekritz")) if err != nil { panic(err) } plaintext := []byte("I CAN HAZ SEKRIT MSG PLZ") ciphertext := make([]byte, des.BlockSize+len(plaintext)) iv := ciphertext[:des.BlockSize] if _, err := io.ReadFull(rand.Reader, iv); err != nil { panic(err) } stream := cipher.NewCFBEncrypter(block, iv) stream.XORKeyStream(ciphertext[des.BlockSize:], plaintext) fmt.Println("Secret message is: %s", hex.EncodeToString(ciphertext)) }`}, 1, gosec.NewConfig()}, } // SampleCodeG503 - Blocklisted import RC4 SampleCodeG503 = []CodeSample{{[]string{` package main import ( "crypto/rc4" "encoding/hex" "fmt" ) func main() { cipher, err := rc4.NewCipher([]byte("sekritz")) if err != nil { panic(err) } plaintext := []byte("I CAN HAZ SEKRIT MSG PLZ") ciphertext := make([]byte, len(plaintext)) cipher.XORKeyStream(ciphertext, plaintext) fmt.Println("Secret message is: %s", hex.EncodeToString(ciphertext)) }`}, 1, gosec.NewConfig()}} // SampleCodeG504 - Blocklisted import CGI SampleCodeG504 = []CodeSample{{[]string{` package main import ( "net/http/cgi" "net/http" ) func main() { cgi.Serve(http.FileServer(http.Dir("/usr/share/doc"))) }`}, 1, gosec.NewConfig()}} // SampleCodeG505 - Blocklisted import SHA1 SampleCodeG505 = []CodeSample{ {[]string{` package main import ( "crypto/sha1" "fmt" "os" ) func main() { for _, arg := range os.Args { fmt.Printf("%x - %s\n", sha1.Sum([]byte(arg)), arg) } }`}, 1, gosec.NewConfig()}, } // SampleCodeG601 - Implicit aliasing over range statement SampleCodeG601 = []CodeSample{ {[]string{ ` package main import "fmt" var vector []*string func appendVector(s *string) { vector = append(vector, s) } func printVector() { for _, item := range vector { fmt.Printf("%s", *item) } fmt.Println() } func foo() (int, **string, *string) { for _, item := range vector { return 0, &item, item } return 0, nil, nil } func main() { for _, item := range []string{"A", "B", "C"} { appendVector(&item) } printVector() zero, c_star, c := foo() fmt.Printf("%d %v %s", zero, c_star, c) }`, }, 1, gosec.NewConfig()}, {[]string{` // see: github.com/securego/gosec/issues/475 package main import ( "fmt" ) func main() { sampleMap := map[string]string{} sampleString := "A string" for sampleString, _ = range sampleMap { fmt.Println(sampleString) } }`}, 0, gosec.NewConfig()}, } // SampleCodeBuildTag - G601 build tags SampleCodeBuildTag = []CodeSample{{[]string{` // +build tag package main func main() { fmt.Println("no package imported error") }`}, 1, gosec.NewConfig()}} // SampleCodeCgo - Cgo file sample SampleCodeCgo = []CodeSample{{[]string{` package main import ( "fmt" "unsafe" ) /* #include <stdlib.h> #include <stdio.h> #include <string.h> int printData(unsigned char *data) { return printf("cData: %lu \"%s\"\n", (long unsigned int)strlen(data), data); } */ import "C" func main() { // Allocate C data buffer. width, height := 8, 2 lenData := width * height // add string terminating null byte cData := (*C.uchar)(C.calloc(C.size_t(lenData+1), C.sizeof_uchar)) // When no longer in use, free C allocations. defer C.free(unsafe.Pointer(cData)) // Go slice reference to C data buffer, // minus string terminating null byte gData := (*[1 << 30]byte)(unsafe.Pointer(cData))[:lenData:lenData] // Write and read cData via gData. for i := range gData { gData[i] = '.' } copy(gData[0:], "Data") gData[len(gData)-1] = 'X' fmt.Printf("gData: %d %q\n", len(gData), gData) C.printData(cData) } `}, 0, gosec.NewConfig()}} )
[ "\"tainted_url\"", "\"SOMETHING\"", "\"tainted_file\"", "\"tainted_file\"", "\"tainted_file2\"", "\"server_root\"", "\"tainted_file3\"" ]
[]
[ "tainted_url", "tainted_file", "tainted_file3", "tainted_file2", "SOMETHING", "server_root" ]
[]
["tainted_url", "tainted_file", "tainted_file3", "tainted_file2", "SOMETHING", "server_root"]
go
6
0
src/beacons.py
import _bleio import adafruit_ble import board import digitalio import binascii import math from adafruit_ble import BLERadio from adafruit_ble.advertising import * from _bleio import adapter from math import floor # CircuitPython packages used. # specifically written for the Adafruit nRF52840 Bluefruit Feather # 0x01 => flags # 0x02 => incomplete list of 16-bit UUIDs # 0x03 => complete list of 16-bit UUIDs # 0x04 => incomplete list of 32-bit UUIDs # 0x05 => complete list of 32-bit UUIDs # 0x06 => incomplete list of 128-bit UUIDs # 0x07 => complete list of 128-bit UUIDs # 0x08 => shortened local name # 0x09 => complete local name # 0x0A => Tx power level of packet (1 byte) (-127 to +127 dBm) # 0xFF => manufacturer specific payload class AD: # make your own Advertising Data packet. def __init__(self, length, dtype, payload, endian='little'): """ length: The length (in base 16) of the AD packet including the type byte. dtype: A 1-byte string representing one the datatype of the payload as documented in the Bluetooth Generic Access Profile (GAP) payload: The actual payload. The length of this should be equal to (length - 1). endian: Endianness of the datatype. Specify if 'big' or 'little'. Default 'little'. All of these should be in String format. For example, if your dtype is a flag, which would be 0x01, dtype='01'. Similarly for others too. """ self.length = bytes(length, 'utf-8') self.dtype = bytes(dtype, 'utf-8') self.payload = bytes(payload, 'utf-8') # convert all these to byte format self.l = int(self.length, 16) # integer length of (payload + dtype) in bytes if endian not in ['big', 'litle']: self.endian = 'little' else: self.endian = endian def parse(self): p_len = binascii.unhexlify(self.length) p_dtype = binascii.unhexlify(self.dtype) p_pload = binascii.unhexlify(self.payload) return p_len, p_dtype, p_pload def join(self): l, dt, pl = self.parse() # in pure hex byte representation # convert from little to big endian if needed. if self.endian != 'little': pl = b''.join([pl[i: i+1] for i in range(len(pl)-1, -1, -1)]) if len(pl) > (self.l - 1): pl = pl[:self.l - 1] if len(pl) < (self.l - 1) and self.endian == 'little': pl = '\x00' * (self.l - 1 - len(pl)) + pl if len(pl) < (self.l - 1) and self.endian == 'big': pl = pl + '\x00' * (self.l - 1 - len(pl)) return (l + dt + pl) def get_AD(self): return self.join() def Flag(flag='0x06'): """ Get the AD for the Flag. Default: 0x06 """ l = '02' dt = '01' f = flag.split('0x')[1] return AD(l, dt, f, 'little').join() def ShortName(ShortName): """ Get AD for the short name of device. """ l = binascii.hexlify((len(ShortName)+1).to_bytes(1, 'little')).decode('utf-8') # converts the length to a hex representation in a byte in String format pl = '' for i in to_hex(bytes(ShortName, 'utf-8')).split(' '): pl += i return AD(l, '08', pl, 'little').join() def CompleteName(fullName): """ Get AD for the complete name of the device. """ l = binascii.hexlify((len(fullName)+1).to_bytes(1, 'little')).decode('utf-8') # converts the length to a hex representation in a byte in String format pl = '' for i in to_hex(bytes(fullName, 'utf-8')).split(' '): pl += i return AD(l, '09', pl, 'little').join() def UUID_16(uuid, complete=True): """ Get AD packet for in/complete list of 16-bit UUIDs. `uuid` should be a string representing the hex, like '0x7e2f' => '7e2f'. stored in big endian format. """ l = '03' dt = '03' if complete else '02' pl = uuid return AD(l, dt, pl, 'big').join() def UUID_128(uuid, complete=True): """ Get AD packet for in/complete list of 128-bit UUIDs. `uuid` should be a string representing the hex, like '07f75536-cf60-4289-bb1c-6f50f8daf622'. stored in big endian format. """ l = '11' dt = '07' if complete else '06' pl = ''.join(uuid.split('-')) return AD(l, dt, pl, 'big').join()
[]
[]
[]
[]
[]
python
null
null
null
election/example/main.go
/* Copyright 2015 The Kubernetes Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package main import ( "encoding/json" "fmt" "net/http" "os" "io" "time" election "k8s.io/contrib/election/lib" "github.com/golang/glog" flag "github.com/spf13/pflag" "k8s.io/kubernetes/pkg/api" // "k8s.io/kubernetes/pkg/apimachinery/types" "k8s.io/kubernetes/pkg/client/restclient" client "k8s.io/kubernetes/pkg/client/unversioned" kubectl_util "k8s.io/kubernetes/pkg/kubectl/cmd/util" ) var ( flags = flag.NewFlagSet( `elector --election=<name>`, flag.ExitOnError) name = flags.String("election", "", "The name of the election") id = flags.String("id", "", "The id of this participant") namespace = flags.String("election-namespace", api.NamespaceDefault, "The Kubernetes namespace for this election") ttl = flags.Duration("ttl", 10*time.Second, "The TTL for this election") inCluster = flags.Bool("use-cluster-credentials", false, "Should this request use cluster credentials?") addr = flags.String("http", "", "If non-empty, stand up a simple webserver that reports the leader state") leader = &LeaderData{} ) type patchStringValue struct { Op string `json:"op"` Path string `json:"path"` Value string `json:"value"` } func makeClient() (*client.Client, error) { var cfg *restclient.Config var err error if *inCluster { if cfg, err = restclient.InClusterConfig(); err != nil { return nil, err } } else { clientConfig := kubectl_util.DefaultClientConfig(flags) if cfg, err = clientConfig.ClientConfig(); err != nil { return nil, err } } return client.New(cfg) } // LeaderData represents information about the current leader type LeaderData struct { Name string `json:"name"` } func webHandler(res http.ResponseWriter, req *http.Request) { data, err := json.Marshal(leader) if err != nil { res.WriteHeader(http.StatusInternalServerError) res.Write([]byte(err.Error())) return } res.WriteHeader(http.StatusOK) res.Write(data) } func webHealthHandler(res http.ResponseWriter, _ *http.Request) { if leader == nil || leader.Name == "" { res.WriteHeader(http.StatusInternalServerError) io.WriteString(res, fmt.Sprintf("Invalid leader set: %v", leader)) return } res.WriteHeader(http.StatusOK) io.WriteString(res, fmt.Sprintf("Valid leader set: %v", leader)) } func webLeaderHandler(res http.ResponseWriter, _ *http.Request) { if leader == nil || leader.Name == "" { res.WriteHeader(http.StatusInternalServerError) io.WriteString(res, fmt.Sprintf("Invalid leader set: %v", leader)) return } if(leader.Name == *id){ res.WriteHeader(http.StatusOK) io.WriteString(res, fmt.Sprintf("Valid leader set: %v", leader)) return } res.WriteHeader(http.StatusGone) } func validateFlags() { if len(*id) == 0 { *id = os.Getenv("HOSTNAME") if len(*id) == 0 { glog.Fatal("--id cannot be empty") } } if len(*name) == 0 { glog.Fatal("--election cannot be empty") } } func main() { flags.Parse(os.Args) validateFlags() kubeClient, err := makeClient() if err != nil { glog.Fatalf("error connecting to the client: %v", err) } fn := func(str string) { var payload [] patchStringValue if(*id == str){ payload = []patchStringValue{{ Op: "add", Path: "/metadata/labels/leader", Value: "yes", }} } else { payload = []patchStringValue{{ Op: "remove", Path: "/metadata/labels/leader", }} } // var updateErr error payloadBytes, _ := json.Marshal(payload) _, updateErr := kubeClient.Pods(*namespace).Patch(*id, "application/json-patch+json", payloadBytes) if updateErr == nil { fmt.Println(fmt.Sprintf("Pod %s labelled successfully.", *id)) } else { fmt.Println(updateErr) } leader.Name = str fmt.Printf("%s is the leader\n", leader.Name) } e, err := election.NewElection(*name, *id, *namespace, *ttl, fn, kubeClient) if err != nil { glog.Fatalf("failed to create election: %v", err) } go election.RunElection(e) if len(*addr) > 0 { http.HandleFunc("/health", webHealthHandler) http.HandleFunc("/leader", webLeaderHandler) http.HandleFunc("/", webHandler) http.ListenAndServe(*addr, nil) } else { select {} } }
[ "\"HOSTNAME\"" ]
[]
[ "HOSTNAME" ]
[]
["HOSTNAME"]
go
1
0
website/settings/defaults.py
# -*- coding: utf-8 -*- """ Base settings file, common to all environments. These settings can be overridden in local.py. """ import datetime import os import json import hashlib import logging from datetime import timedelta from collections import OrderedDict os_env = os.environ def parent_dir(path): '''Return the parent of a directory.''' return os.path.abspath(os.path.join(path, os.pardir)) HERE = os.path.dirname(os.path.abspath(__file__)) BASE_PATH = parent_dir(HERE) # website/ directory APP_PATH = parent_dir(BASE_PATH) ADDON_PATH = os.path.join(APP_PATH, 'addons') STATIC_FOLDER = os.path.join(BASE_PATH, 'static') STATIC_URL_PATH = '/static' ASSET_HASH_PATH = os.path.join(APP_PATH, 'webpack-assets.json') ROOT = os.path.join(BASE_PATH, '..') BCRYPT_LOG_ROUNDS = 12 LOG_LEVEL = logging.INFO TEST_ENV = False with open(os.path.join(APP_PATH, 'package.json'), 'r') as fobj: VERSION = json.load(fobj)['version'] # Expiration time for verification key EXPIRATION_TIME_DICT = { 'password': 24 * 60, # 24 hours in minutes for forgot and reset password 'confirm': 24 * 60, # 24 hours in minutes for confirm account and email 'claim': 30 * 24 * 60 # 30 days in minutes for claim contributor-ship } CITATION_STYLES_PATH = os.path.join(BASE_PATH, 'static', 'vendor', 'bower_components', 'styles') # Minimum seconds between forgot password email attempts SEND_EMAIL_THROTTLE = 30 # Minimum seconds between attempts to change password CHANGE_PASSWORD_THROTTLE = 30 # Number of incorrect password attempts allowed before throttling. INCORRECT_PASSWORD_ATTEMPTS_ALLOWED = 3 # Seconds that must elapse before updating a user's date_last_login field DATE_LAST_LOGIN_THROTTLE = 60 # Seconds that must elapse before change password attempts are reset(currently 1 hour) TIME_RESET_CHANGE_PASSWORD_ATTEMPTS = 3600 # Hours before pending embargo/retraction/registration automatically becomes active RETRACTION_PENDING_TIME = datetime.timedelta(days=2) EMBARGO_PENDING_TIME = datetime.timedelta(days=2) EMBARGO_TERMINATION_PENDING_TIME = datetime.timedelta(days=2) REGISTRATION_APPROVAL_TIME = datetime.timedelta(days=2) # Date range for embargo periods EMBARGO_END_DATE_MIN = datetime.timedelta(days=2) EMBARGO_END_DATE_MAX = datetime.timedelta(days=1460) # Four years # Question titles to be reomved for anonymized VOL ANONYMIZED_TITLES = ['Authors'] LOAD_BALANCER = False # May set these to True in local.py for development DEV_MODE = False DEBUG_MODE = False SECURE_MODE = not DEBUG_MODE # Set secure cookie PROTOCOL = 'https://' if SECURE_MODE else 'http://' DOMAIN = PROTOCOL + 'localhost:5000/' INTERNAL_DOMAIN = DOMAIN API_DOMAIN = PROTOCOL + 'localhost:8000/' PREPRINT_PROVIDER_DOMAINS = { 'enabled': False, 'prefix': PROTOCOL, 'suffix': '/' } # External Ember App Local Development USE_EXTERNAL_EMBER = False PROXY_EMBER_APPS = False # http://docs.python-requests.org/en/master/user/advanced/#timeouts EXTERNAL_EMBER_SERVER_TIMEOUT = 3.05 EXTERNAL_EMBER_APPS = {} LOG_PATH = os.path.join(APP_PATH, 'logs') TEMPLATES_PATH = os.path.join(BASE_PATH, 'templates') # User management & registration CONFIRM_REGISTRATIONS_BY_EMAIL = True ALLOW_LOGIN = True SEARCH_ENGINE = 'elastic' # Can be 'elastic', or None ELASTIC_URI = '127.0.0.1:9200' ELASTIC_TIMEOUT = 10 ELASTIC_INDEX = 'website' ELASTIC_KWARGS = { # 'use_ssl': False, # 'verify_certs': True, # 'ca_certs': None, # 'client_cert': None, # 'client_key': None } # Sessions COOKIE_NAME = 'osf' # TODO: Override OSF_COOKIE_DOMAIN in local.py in production OSF_COOKIE_DOMAIN = None # server-side verification timeout OSF_SESSION_TIMEOUT = 30 * 24 * 60 * 60 # 30 days in seconds # TODO: Override SECRET_KEY in local.py in production SECRET_KEY = 'CHANGEME' SESSION_COOKIE_SECURE = SECURE_MODE SESSION_COOKIE_HTTPONLY = True # local path to private key and cert for local development using https, overwrite in local.py OSF_SERVER_KEY = None OSF_SERVER_CERT = None # External services USE_CDN_FOR_CLIENT_LIBS = True USE_EMAIL = True FROM_EMAIL = '[email protected]' # support email OSF_SUPPORT_EMAIL = '[email protected]' # contact email OSF_CONTACT_EMAIL = '[email protected]' # prereg email PREREG_EMAIL = '[email protected]' # Default settings for fake email address generation FAKE_EMAIL_NAME = 'freddiemercury' FAKE_EMAIL_DOMAIN = 'cos.io' # SMTP Settings MAIL_SERVER = 'smtp.sendgrid.net' MAIL_USERNAME = 'osf-smtp' MAIL_PASSWORD = '' # Set this in local.py # OR, if using Sendgrid's API # WARNING: If `SENDGRID_WHITELIST_MODE` is True, # `tasks.send_email` would only email recipients included in `SENDGRID_EMAIL_WHITELIST` SENDGRID_API_KEY = None SENDGRID_WHITELIST_MODE = False SENDGRID_EMAIL_WHITELIST = [] # Mailchimp MAILCHIMP_API_KEY = None MAILCHIMP_WEBHOOK_SECRET_KEY = 'CHANGEME' # OSF secret key to ensure webhook is secure ENABLE_EMAIL_SUBSCRIPTIONS = True MAILCHIMP_GENERAL_LIST = 'Open Science Framework General' #Triggered emails OSF_HELP_LIST = 'Open Science Framework Help' PREREG_AGE_LIMIT = timedelta(weeks=12) PREREG_WAIT_TIME = timedelta(weeks=2) WAIT_BETWEEN_MAILS = timedelta(days=7) NO_ADDON_WAIT_TIME = timedelta(weeks=8) NO_LOGIN_WAIT_TIME = timedelta(weeks=4) WELCOME_OSF4M_WAIT_TIME = timedelta(weeks=2) NO_LOGIN_OSF4M_WAIT_TIME = timedelta(weeks=6) NEW_PUBLIC_PROJECT_WAIT_TIME = timedelta(hours=24) WELCOME_OSF4M_WAIT_TIME_GRACE = timedelta(days=12) # TODO: Override in local.py MAILGUN_API_KEY = None # Use Celery for file rendering USE_CELERY = True # TODO: Override in local.py in production DB_HOST = 'localhost' DB_PORT = os_env.get('OSF_DB_PORT', 27017) # TODO: Configuration should not change between deploys - this should be dynamic. COOKIE_DOMAIN = '.openscienceframework.org' # Beaker # TODO: Combine Python and JavaScript config # If you change COMMENT_MAXLENGTH, make sure you create a corresponding migration. COMMENT_MAXLENGTH = 1000 # Profile image options PROFILE_IMAGE_LARGE = 70 PROFILE_IMAGE_MEDIUM = 40 # Currently (8/21/2017) only gravatar supported. PROFILE_IMAGE_PROVIDER = 'gravatar' # Conference options CONFERENCE_MIN_COUNT = 5 WIKI_WHITELIST = { 'tags': [ 'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'blockquote', 'br', 'center', 'cite', 'code', 'dd', 'del', 'dfn', 'div', 'dl', 'dt', 'em', 'embed', 'font', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'ins', 'kbd', 'li', 'object', 'ol', 'param', 'pre', 'p', 'q', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'table', 'tbody', 'td', 'th', 'thead', 'tr', 'tt', 'ul', 'u', 'var', 'wbr', ], 'attributes': [ 'align', 'alt', 'border', 'cite', 'class', 'dir', 'height', 'href', 'id', 'src', 'style', 'title', 'type', 'width', 'face', 'size', # font tags 'salign', 'align', 'wmode', 'target', ], # Styles currently used in Reproducibility Project wiki pages 'styles': [ 'top', 'left', 'width', 'height', 'position', 'background', 'font-size', 'text-align', 'z-index', 'list-style', ] } # Maps category identifier => Human-readable representation for use in # titles, menus, etc. # Use an OrderedDict so that menu items show in the correct order NODE_CATEGORY_MAP = OrderedDict([ ('analysis', 'Analysis'), ('communication', 'Communication'), ('data', 'Data'), ('hypothesis', 'Hypothesis'), ('instrumentation', 'Instrumentation'), ('methods and measures', 'Methods and Measures'), ('procedure', 'Procedure'), ('project', 'Project'), ('software', 'Software'), ('other', 'Other'), ('', 'Uncategorized') ]) # Add-ons # Load addons from addons.json with open(os.path.join(ROOT, 'addons.json')) as fp: addon_settings = json.load(fp) ADDONS_REQUESTED = addon_settings['addons'] ADDONS_ARCHIVABLE = addon_settings['addons_archivable'] ADDONS_COMMENTABLE = addon_settings['addons_commentable'] ADDONS_BASED_ON_IDS = addon_settings['addons_based_on_ids'] ADDONS_DEFAULT = addon_settings['addons_default'] SYSTEM_ADDED_ADDONS = { 'user': [], 'node': [], } KEEN = { 'public': { 'project_id': None, 'master_key': 'changeme', 'write_key': '', 'read_key': '', }, 'private': { 'project_id': '', 'write_key': '', 'read_key': '', }, } SENTRY_DSN = None SENTRY_DSN_JS = None MISSING_FILE_NAME = 'untitled' # Most Popular and New and Noteworthy Nodes POPULAR_LINKS_NODE = None # TODO Override in local.py in production. POPULAR_LINKS_REGISTRATIONS = None # TODO Override in local.py in production. NEW_AND_NOTEWORTHY_LINKS_NODE = None # TODO Override in local.py in production. MAX_POPULAR_PROJECTS = 10 NEW_AND_NOTEWORTHY_CONTRIBUTOR_BLACKLIST = [] # TODO Override in local.py in production. # FOR EMERGENCIES ONLY: Setting this to True will disable forks, registrations, # and uploads in order to save disk space. DISK_SAVING_MODE = False # Seconds before another notification email can be sent to a contributor when added to a project CONTRIBUTOR_ADDED_EMAIL_THROTTLE = 24 * 3600 # Google Analytics GOOGLE_ANALYTICS_ID = None GOOGLE_SITE_VERIFICATION = None DEFAULT_HMAC_SECRET = 'changeme' DEFAULT_HMAC_ALGORITHM = hashlib.sha256 WATERBUTLER_URL = 'http://localhost:7777' WATERBUTLER_INTERNAL_URL = WATERBUTLER_URL #################### # Identifiers # ################### DOI_URL_PREFIX = 'https://doi.org/' # General Format for DOIs DOI_FORMAT = '{prefix}/osf.io/{guid}' # ezid EZID_DOI_NAMESPACE = 'doi:10.5072' EZID_ARK_NAMESPACE = 'ark:99999' # datacite DATACITE_USERNAME = None DATACITE_PASSWORD = None DATACITE_URL = None DATACITE_PREFIX = '10.5072' # Datacite's test DOI prefix -- update in production # Minting DOIs only works on Datacite's production server, so # disable minting on staging and development environments by default DATACITE_MINT_DOIS = not DEV_MODE # crossref CROSSREF_USERNAME = None CROSSREF_PASSWORD = None CROSSREF_URL = None # Location to POST crossref data. In production, change this to the production CrossRef API endpoint CROSSREF_DEPOSITOR_EMAIL = 'None' # This email will receive confirmation/error messages from CrossRef on submission ECSARXIV_CROSSREF_USERNAME = None ECSARXIV_CROSSREF_PASSWORD = None # Leave as `None` for production, test/staging/local envs must set SHARE_PREPRINT_PROVIDER_PREPEND = None SHARE_REGISTRATION_URL = '' SHARE_URL = None SHARE_API_TOKEN = None # Required to send project updates to SHARE CAS_SERVER_URL = 'http://localhost:8080' MFR_SERVER_URL = 'http://localhost:7778' ###### ARCHIVER ########### ARCHIVE_PROVIDER = 'osfstorage' MAX_ARCHIVE_SIZE = 5 * 1024 ** 3 # == math.pow(1024, 3) == 1 GB ARCHIVE_TIMEOUT_TIMEDELTA = timedelta(1) # 24 hours ENABLE_ARCHIVER = True JWT_SECRET = 'changeme' JWT_ALGORITHM = 'HS256' ##### CELERY ##### # Default RabbitMQ broker RABBITMQ_USERNAME = os.environ.get('RABBITMQ_USERNAME', 'guest') RABBITMQ_PASSWORD = os.environ.get('RABBITMQ_PASSWORD', 'guest') RABBITMQ_HOST = os.environ.get('RABBITMQ_HOST', 'localhost') RABBITMQ_PORT = os.environ.get('RABBITMQ_PORT', '5672') RABBITMQ_VHOST = os.environ.get('RABBITMQ_VHOST', '/') # Seconds, not an actual celery setting CELERY_RETRY_BACKOFF_BASE = 5 class CeleryConfig: """ Celery Configuration http://docs.celeryproject.org/en/latest/userguide/configuration.html """ timezone = 'UTC' task_default_queue = 'celery' task_low_queue = 'low' task_med_queue = 'med' task_high_queue = 'high' low_pri_modules = { 'framework.analytics.tasks', 'framework.celery_tasks', 'scripts.osfstorage.usage_audit', 'scripts.stuck_registration_audit', 'scripts.analytics.tasks', 'scripts.populate_new_and_noteworthy_projects', 'scripts.populate_popular_projects_and_registrations', 'scripts.remind_draft_preregistrations', 'website.search.elastic_search', 'scripts.generate_sitemap', 'scripts.generate_prereg_csv', 'scripts.analytics.run_keen_summaries', 'scripts.analytics.run_keen_snapshots', 'scripts.analytics.run_keen_events', 'scripts.clear_sessions', } med_pri_modules = { 'framework.email.tasks', 'scripts.send_queued_mails', 'scripts.triggered_mails', 'website.mailchimp_utils', 'website.notifications.tasks', } high_pri_modules = { 'scripts.approve_embargo_terminations', 'scripts.approve_registrations', 'scripts.embargo_registrations', 'scripts.premigrate_created_modified', 'scripts.refresh_addon_tokens', 'scripts.retract_registrations', 'website.archiver.tasks', 'scripts.add_missing_identifiers_to_preprints' } try: from kombu import Queue, Exchange except ImportError: pass else: task_queues = ( Queue(task_low_queue, Exchange(task_low_queue), routing_key=task_low_queue, consumer_arguments={'x-priority': -1}), Queue(task_default_queue, Exchange(task_default_queue), routing_key=task_default_queue, consumer_arguments={'x-priority': 0}), Queue(task_med_queue, Exchange(task_med_queue), routing_key=task_med_queue, consumer_arguments={'x-priority': 1}), Queue(task_high_queue, Exchange(task_high_queue), routing_key=task_high_queue, consumer_arguments={'x-priority': 10}), ) task_default_exchange_type = 'direct' task_routes = ('framework.celery_tasks.routers.CeleryRouter', ) task_ignore_result = True task_store_errors_even_if_ignored = True broker_url = os.environ.get('BROKER_URL', 'amqp://{}:{}@{}:{}/{}'.format(RABBITMQ_USERNAME, RABBITMQ_PASSWORD, RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_VHOST)) broker_use_ssl = False # Default RabbitMQ backend result_backend = 'django-db' # django-celery-results beat_scheduler = 'django_celery_beat.schedulers:DatabaseScheduler' # Modules to import when celery launches imports = ( 'framework.celery_tasks', 'framework.email.tasks', 'website.mailchimp_utils', 'website.notifications.tasks', 'website.archiver.tasks', 'website.search.search', 'website.project.tasks', 'scripts.populate_new_and_noteworthy_projects', 'scripts.populate_popular_projects_and_registrations', 'scripts.refresh_addon_tokens', 'scripts.remind_draft_preregistrations', 'scripts.retract_registrations', 'scripts.embargo_registrations', 'scripts.approve_registrations', 'scripts.approve_embargo_terminations', 'scripts.triggered_mails', 'scripts.clear_sessions', 'scripts.send_queued_mails', 'scripts.analytics.run_keen_summaries', 'scripts.analytics.run_keen_snapshots', 'scripts.analytics.run_keen_events', 'scripts.generate_sitemap', 'scripts.premigrate_created_modified', 'scripts.generate_prereg_csv', 'scripts.add_missing_identifiers_to_preprints', ) # Modules that need metrics and release requirements # imports += ( # 'scripts.osfstorage.usage_audit', # 'scripts.stuck_registration_audit', # 'scripts.analytics.tasks', # 'scripts.analytics.upload', # ) # celery.schedule will not be installed when running invoke requirements the first time. try: from celery.schedules import crontab except ImportError: pass else: # Setting up a scheduler, essentially replaces an independent cron job # Note: these times must be in UTC beat_schedule = { '5-minute-emails': { 'task': 'website.notifications.tasks.send_users_email', 'schedule': crontab(minute='*/5'), 'args': ('email_transactional',), }, 'daily-emails': { 'task': 'website.notifications.tasks.send_users_email', 'schedule': crontab(minute=0, hour=5), # Daily at 12 a.m. EST 'args': ('email_digest',), }, 'refresh_addons': { 'task': 'scripts.refresh_addon_tokens', 'schedule': crontab(minute=0, hour=7), # Daily 2:00 a.m 'kwargs': {'dry_run': False, 'addons': { 'box': 60, # https://docs.box.com/docs/oauth-20#section-6-using-the-access-and-refresh-tokens 'googledrive': 14, # https://developers.google.com/identity/protocols/OAuth2#expiration 'mendeley': 14 # http://dev.mendeley.com/reference/topics/authorization_overview.html }}, }, 'retract_registrations': { 'task': 'scripts.retract_registrations', 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m 'kwargs': {'dry_run': False}, }, 'embargo_registrations': { 'task': 'scripts.embargo_registrations', 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m 'kwargs': {'dry_run': False}, }, 'add_missing_identifiers_to_preprints': { 'task': 'scripts.add_missing_identifiers_to_preprints', 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m 'kwargs': {'dry_run': False}, }, 'approve_registrations': { 'task': 'scripts.approve_registrations', 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m 'kwargs': {'dry_run': False}, }, 'approve_embargo_terminations': { 'task': 'scripts.approve_embargo_terminations', 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m 'kwargs': {'dry_run': False}, }, 'triggered_mails': { 'task': 'scripts.triggered_mails', 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m 'kwargs': {'dry_run': False}, }, 'clear_sessions': { 'task': 'scripts.clear_sessions', 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m 'kwargs': {'dry_run': False}, }, 'send_queued_mails': { 'task': 'scripts.send_queued_mails', 'schedule': crontab(minute=0, hour=17), # Daily 12 p.m. 'kwargs': {'dry_run': False}, }, 'prereg_reminder': { 'task': 'scripts.remind_draft_preregistrations', 'schedule': crontab(minute=0, hour=12), # Daily 12 p.m. 'kwargs': {'dry_run': False}, }, 'new-and-noteworthy': { 'task': 'scripts.populate_new_and_noteworthy_projects', 'schedule': crontab(minute=0, hour=7, day_of_week=6), # Saturday 2:00 a.m. 'kwargs': {'dry_run': False} }, 'update_popular_nodes': { 'task': 'scripts.populate_popular_projects_and_registrations', 'schedule': crontab(minute=0, hour=7), # Daily 2:00 a.m. 'kwargs': {'dry_run': False} }, 'run_keen_summaries': { 'task': 'scripts.analytics.run_keen_summaries', 'schedule': crontab(minute=0, hour=6), # Daily 1:00 a.m. 'kwargs': {'yesterday': True} }, 'run_keen_snapshots': { 'task': 'scripts.analytics.run_keen_snapshots', 'schedule': crontab(minute=0, hour=8), # Daily 3:00 a.m. }, 'run_keen_events': { 'task': 'scripts.analytics.run_keen_events', 'schedule': crontab(minute=0, hour=9), # Daily 4:00 a.m. 'kwargs': {'yesterday': True} }, 'generate_sitemap': { 'task': 'scripts.generate_sitemap', 'schedule': crontab(minute=0, hour=5), # Daily 12:00 a.m. }, 'generate_prereg_csv': { 'task': 'scripts.generate_prereg_csv', 'schedule': crontab(minute=0, hour=10, day_of_week=0), # Sunday 5:00 a.m. }, } # Tasks that need metrics and release requirements # beat_schedule.update({ # 'usage_audit': { # 'task': 'scripts.osfstorage.usage_audit', # 'schedule': crontab(minute=0, hour=5), # Daily 12 a.m # 'kwargs': {'send_mail': True}, # }, # 'stuck_registration_audit': { # 'task': 'scripts.stuck_registration_audit', # 'schedule': crontab(minute=0, hour=11), # Daily 6 a.m # 'kwargs': {}, # }, # }) WATERBUTLER_JWE_SALT = 'yusaltydough' WATERBUTLER_JWE_SECRET = 'CirclesAre4Squares' WATERBUTLER_JWT_SECRET = 'ILiekTrianglesALot' WATERBUTLER_JWT_ALGORITHM = 'HS256' WATERBUTLER_JWT_EXPIRATION = 15 SENSITIVE_DATA_SALT = 'yusaltydough' SENSITIVE_DATA_SECRET = 'TrainglesAre5Squares' DRAFT_REGISTRATION_APPROVAL_PERIOD = datetime.timedelta(days=10) assert (DRAFT_REGISTRATION_APPROVAL_PERIOD > EMBARGO_END_DATE_MIN), 'The draft registration approval period should be more than the minimum embargo end date.' # TODO: Remove references to this flag ENABLE_INSTITUTIONS = True ENABLE_VARNISH = False ENABLE_ESI = False VARNISH_SERVERS = [] # This should be set in local.py or cache invalidation won't work ESI_MEDIA_TYPES = {'application/vnd.api+json', 'application/json'} # Used for gathering meta information about the current build GITHUB_API_TOKEN = None # switch for disabling things that shouldn't happen during # the modm to django migration RUNNING_MIGRATION = False # External Identity Provider EXTERNAL_IDENTITY_PROFILE = { 'OrcidProfile': 'ORCID', } # Source: https://github.com/maxd/fake_email_validator/blob/master/config/fake_domains.list BLACKLISTED_DOMAINS = [ '0-mail.com', '0815.ru', '0815.su', '0clickemail.com', '0wnd.net', '0wnd.org', '10mail.org', '10minut.com.pl', '10minutemail.cf', '10minutemail.co.uk', '10minutemail.co.za', '10minutemail.com', '10minutemail.de', '10minutemail.eu', '10minutemail.ga', '10minutemail.gq', '10minutemail.info', '10minutemail.ml', '10minutemail.net', '10minutemail.org', '10minutemail.ru', '10minutemail.us', '10minutesmail.co.uk', '10minutesmail.com', '10minutesmail.eu', '10minutesmail.net', '10minutesmail.org', '10minutesmail.ru', '10minutesmail.us', '123-m.com', '15qm-mail.red', '15qm.com', '1chuan.com', '1mail.ml', '1pad.de', '1usemail.com', '1zhuan.com', '20mail.in', '20mail.it', '20minutemail.com', '2prong.com', '30minutemail.com', '30minutesmail.com', '33mail.com', '3d-painting.com', '3mail.ga', '4mail.cf', '4mail.ga', '4warding.com', '4warding.net', '4warding.org', '5mail.cf', '5mail.ga', '60minutemail.com', '675hosting.com', '675hosting.net', '675hosting.org', '6ip.us', '6mail.cf', '6mail.ga', '6mail.ml', '6paq.com', '6url.com', '75hosting.com', '75hosting.net', '75hosting.org', '7mail.ga', '7mail.ml', '7mail7.com', '7tags.com', '8mail.cf', '8mail.ga', '8mail.ml', '99experts.com', '9mail.cf', '9ox.net', 'a-bc.net', 'a45.in', 'abcmail.email', 'abusemail.de', 'abyssmail.com', 'acentri.com', 'advantimo.com', 'afrobacon.com', 'agedmail.com', 'ajaxapp.net', 'alivance.com', 'ama-trade.de', 'amail.com', 'amail4.me', 'amilegit.com', 'amiri.net', 'amiriindustries.com', 'anappthat.com', 'ano-mail.net', 'anobox.ru', 'anonbox.net', 'anonmails.de', 'anonymail.dk', 'anonymbox.com', 'antichef.com', 'antichef.net', 'antireg.ru', 'antispam.de', 'antispammail.de', 'appixie.com', 'armyspy.com', 'artman-conception.com', 'asdasd.ru', 'azmeil.tk', 'baxomale.ht.cx', 'beddly.com', 'beefmilk.com', 'beerolympics.se', 'bestemailaddress.net', 'bigprofessor.so', 'bigstring.com', 'binkmail.com', 'bio-muesli.net', 'bladesmail.net', 'bloatbox.com', 'bobmail.info', 'bodhi.lawlita.com', 'bofthew.com', 'bootybay.de', 'bossmail.de', 'boun.cr', 'bouncr.com', 'boxformail.in', 'boximail.com', 'boxtemp.com.br', 'breakthru.com', 'brefmail.com', 'brennendesreich.de', 'broadbandninja.com', 'bsnow.net', 'bspamfree.org', 'buffemail.com', 'bugmenot.com', 'bumpymail.com', 'bund.us', 'bundes-li.ga', 'burnthespam.info', 'burstmail.info', 'buymoreplays.com', 'buyusedlibrarybooks.org', 'byom.de', 'c2.hu', 'cachedot.net', 'card.zp.ua', 'casualdx.com', 'cbair.com', 'cdnqa.com', 'cek.pm', 'cellurl.com', 'cem.net', 'centermail.com', 'centermail.net', 'chammy.info', 'cheatmail.de', 'chewiemail.com', 'childsavetrust.org', 'chogmail.com', 'choicemail1.com', 'chong-mail.com', 'chong-mail.net', 'chong-mail.org', 'clixser.com', 'clrmail.com', 'cmail.net', 'cmail.org', 'coldemail.info', 'consumerriot.com', 'cool.fr.nf', 'correo.blogos.net', 'cosmorph.com', 'courriel.fr.nf', 'courrieltemporaire.com', 'crapmail.org', 'crazymailing.com', 'cubiclink.com', 'curryworld.de', 'cust.in', 'cuvox.de', 'd3p.dk', 'dacoolest.com', 'daintly.com', 'dandikmail.com', 'dayrep.com', 'dbunker.com', 'dcemail.com', 'deadaddress.com', 'deadfake.cf', 'deadfake.ga', 'deadfake.ml', 'deadfake.tk', 'deadspam.com', 'deagot.com', 'dealja.com', 'delikkt.de', 'despam.it', 'despammed.com', 'devnullmail.com', 'dfgh.net', 'digitalsanctuary.com', 'dingbone.com', 'dingfone.com', 'discard.cf', 'discard.email', 'discard.ga', 'discard.gq', 'discard.ml', 'discard.tk', 'discardmail.com', 'discardmail.de', 'dispomail.eu', 'disposable-email.ml', 'disposable.cf', 'disposable.ga', 'disposable.ml', 'disposableaddress.com', 'disposableemailaddresses.com', 'disposableinbox.com', 'dispose.it', 'disposeamail.com', 'disposemail.com', 'dispostable.com', 'divermail.com', 'dodgeit.com', 'dodgemail.de', 'dodgit.com', 'dodgit.org', 'dodsi.com', 'doiea.com', 'domozmail.com', 'donemail.ru', 'dontmail.net', 'dontreg.com', 'dontsendmespam.de', 'dotmsg.com', 'drdrb.com', 'drdrb.net', 'droplar.com', 'dropmail.me', 'duam.net', 'dudmail.com', 'dump-email.info', 'dumpandjunk.com', 'dumpmail.de', 'dumpyemail.com', 'duskmail.com', 'e-mail.com', 'e-mail.org', 'e4ward.com', 'easytrashmail.com', 'ee1.pl', 'ee2.pl', 'eelmail.com', 'einmalmail.de', 'einrot.com', 'einrot.de', 'eintagsmail.de', 'email-fake.cf', 'email-fake.com', 'email-fake.ga', 'email-fake.gq', 'email-fake.ml', 'email-fake.tk', 'email60.com', 'email64.com', 'emailage.cf', 'emailage.ga', 'emailage.gq', 'emailage.ml', 'emailage.tk', 'emaildienst.de', 'emailgo.de', 'emailias.com', 'emailigo.de', 'emailinfive.com', 'emaillime.com', 'emailmiser.com', 'emailproxsy.com', 'emails.ga', 'emailsensei.com', 'emailspam.cf', 'emailspam.ga', 'emailspam.gq', 'emailspam.ml', 'emailspam.tk', 'emailtemporanea.com', 'emailtemporanea.net', 'emailtemporar.ro', 'emailtemporario.com.br', 'emailthe.net', 'emailtmp.com', 'emailto.de', 'emailwarden.com', 'emailx.at.hm', 'emailxfer.com', 'emailz.cf', 'emailz.ga', 'emailz.gq', 'emailz.ml', 'emeil.in', 'emeil.ir', 'emeraldwebmail.com', 'emil.com', 'emkei.cf', 'emkei.ga', 'emkei.gq', 'emkei.ml', 'emkei.tk', 'emz.net', 'enterto.com', 'ephemail.net', 'ero-tube.org', 'etranquil.com', 'etranquil.net', 'etranquil.org', 'evopo.com', 'example.com', 'explodemail.com', 'express.net.ua', 'eyepaste.com', 'facebook-email.cf', 'facebook-email.ga', 'facebook-email.ml', 'facebookmail.gq', 'facebookmail.ml', 'fake-box.com', 'fake-mail.cf', 'fake-mail.ga', 'fake-mail.ml', 'fakeinbox.cf', 'fakeinbox.com', 'fakeinbox.ga', 'fakeinbox.ml', 'fakeinbox.tk', 'fakeinformation.com', 'fakemail.fr', 'fakemailgenerator.com', 'fakemailz.com', 'fammix.com', 'fansworldwide.de', 'fantasymail.de', 'fastacura.com', 'fastchevy.com', 'fastchrysler.com', 'fastkawasaki.com', 'fastmazda.com', 'fastmitsubishi.com', 'fastnissan.com', 'fastsubaru.com', 'fastsuzuki.com', 'fasttoyota.com', 'fastyamaha.com', 'fatflap.com', 'fdfdsfds.com', 'fightallspam.com', 'fiifke.de', 'filzmail.com', 'fivemail.de', 'fixmail.tk', 'fizmail.com', 'fleckens.hu', 'flurre.com', 'flurred.com', 'flurred.ru', 'flyspam.com', 'footard.com', 'forgetmail.com', 'forward.cat', 'fr33mail.info', 'frapmail.com', 'free-email.cf', 'free-email.ga', 'freemails.cf', 'freemails.ga', 'freemails.ml', 'freundin.ru', 'friendlymail.co.uk', 'front14.org', 'fuckingduh.com', 'fudgerub.com', 'fux0ringduh.com', 'fyii.de', 'garliclife.com', 'gehensiemirnichtaufdensack.de', 'gelitik.in', 'germanmails.biz', 'get-mail.cf', 'get-mail.ga', 'get-mail.ml', 'get-mail.tk', 'get1mail.com', 'get2mail.fr', 'getairmail.cf', 'getairmail.com', 'getairmail.ga', 'getairmail.gq', 'getairmail.ml', 'getairmail.tk', 'getmails.eu', 'getonemail.com', 'getonemail.net', 'gfcom.com', 'ghosttexter.de', 'giantmail.de', 'girlsundertheinfluence.com', 'gishpuppy.com', 'gmial.com', 'goemailgo.com', 'gorillaswithdirtyarmpits.com', 'gotmail.com', 'gotmail.net', 'gotmail.org', 'gowikibooks.com', 'gowikicampus.com', 'gowikicars.com', 'gowikifilms.com', 'gowikigames.com', 'gowikimusic.com', 'gowikinetwork.com', 'gowikitravel.com', 'gowikitv.com', 'grandmamail.com', 'grandmasmail.com', 'great-host.in', 'greensloth.com', 'grr.la', 'gsrv.co.uk', 'guerillamail.biz', 'guerillamail.com', 'guerillamail.de', 'guerillamail.net', 'guerillamail.org', 'guerillamailblock.com', 'guerrillamail.biz', 'guerrillamail.com', 'guerrillamail.de', 'guerrillamail.info', 'guerrillamail.net', 'guerrillamail.org', 'guerrillamailblock.com', 'gustr.com', 'h8s.org', 'hacccc.com', 'haltospam.com', 'haqed.com', 'harakirimail.com', 'hartbot.de', 'hat-geld.de', 'hatespam.org', 'headstrong.de', 'hellodream.mobi', 'herp.in', 'hidemail.de', 'hideme.be', 'hidzz.com', 'hiru-dea.com', 'hmamail.com', 'hochsitze.com', 'hopemail.biz', 'hot-mail.cf', 'hot-mail.ga', 'hot-mail.gq', 'hot-mail.ml', 'hot-mail.tk', 'hotpop.com', 'hulapla.de', 'hushmail.com', 'ieatspam.eu', 'ieatspam.info', 'ieh-mail.de', 'ihateyoualot.info', 'iheartspam.org', 'ikbenspamvrij.nl', 'imails.info', 'imgof.com', 'imgv.de', 'imstations.com', 'inbax.tk', 'inbox.si', 'inboxalias.com', 'inboxclean.com', 'inboxclean.org', 'inboxproxy.com', 'incognitomail.com', 'incognitomail.net', 'incognitomail.org', 'ineec.net', 'infocom.zp.ua', 'inoutmail.de', 'inoutmail.eu', 'inoutmail.info', 'inoutmail.net', 'insorg-mail.info', 'instant-mail.de', 'instantemailaddress.com', 'instantlyemail.com', 'ip6.li', 'ipoo.org', 'irish2me.com', 'iwi.net', 'jetable.com', 'jetable.fr.nf', 'jetable.net', 'jetable.org', 'jnxjn.com', 'jourrapide.com', 'junk1e.com', 'junkmail.com', 'junkmail.ga', 'junkmail.gq', 'jupimail.com', 'kasmail.com', 'kaspop.com', 'keepmymail.com', 'killmail.com', 'killmail.net', 'kimsdisk.com', 'kingsq.ga', 'kiois.com', 'kir.ch.tc', 'klassmaster.com', 'klassmaster.net', 'klzlk.com', 'kook.ml', 'koszmail.pl', 'kulturbetrieb.info', 'kurzepost.de', 'l33r.eu', 'labetteraverouge.at', 'lackmail.net', 'lags.us', 'landmail.co', 'lastmail.co', 'lawlita.com', 'lazyinbox.com', 'legitmail.club', 'letthemeatspam.com', 'lhsdv.com', 'libox.fr', 'lifebyfood.com', 'link2mail.net', 'litedrop.com', 'loadby.us', 'login-email.cf', 'login-email.ga', 'login-email.ml', 'login-email.tk', 'lol.ovpn.to', 'lolfreak.net', 'lookugly.com', 'lopl.co.cc', 'lortemail.dk', 'lovemeleaveme.com', 'lr78.com', 'lroid.com', 'lukop.dk', 'm21.cc', 'm4ilweb.info', 'maboard.com', 'mail-filter.com', 'mail-temporaire.fr', 'mail.by', 'mail.mezimages.net', 'mail.zp.ua', 'mail114.net', 'mail1a.de', 'mail21.cc', 'mail2rss.org', 'mail333.com', 'mail4trash.com', 'mailbidon.com', 'mailbiz.biz', 'mailblocks.com', 'mailblog.biz', 'mailbucket.org', 'mailcat.biz', 'mailcatch.com', 'mailde.de', 'mailde.info', 'maildrop.cc', 'maildrop.cf', 'maildrop.ga', 'maildrop.gq', 'maildrop.ml', 'maildu.de', 'maildx.com', 'maileater.com', 'mailed.ro', 'maileimer.de', 'mailexpire.com', 'mailfa.tk', 'mailforspam.com', 'mailfree.ga', 'mailfree.gq', 'mailfree.ml', 'mailfreeonline.com', 'mailfs.com', 'mailguard.me', 'mailhazard.com', 'mailhazard.us', 'mailhz.me', 'mailimate.com', 'mailin8r.com', 'mailinater.com', 'mailinator.com', 'mailinator.gq', 'mailinator.net', 'mailinator.org', 'mailinator.us', 'mailinator2.com', 'mailinator2.net', 'mailincubator.com', 'mailismagic.com', 'mailjunk.cf', 'mailjunk.ga', 'mailjunk.gq', 'mailjunk.ml', 'mailjunk.tk', 'mailmate.com', 'mailme.gq', 'mailme.ir', 'mailme.lv', 'mailme24.com', 'mailmetrash.com', 'mailmoat.com', 'mailms.com', 'mailnator.com', 'mailnesia.com', 'mailnull.com', 'mailorg.org', 'mailpick.biz', 'mailproxsy.com', 'mailquack.com', 'mailrock.biz', 'mailscrap.com', 'mailshell.com', 'mailsiphon.com', 'mailslapping.com', 'mailslite.com', 'mailspeed.ru', 'mailtemp.info', 'mailtome.de', 'mailtothis.com', 'mailtrash.net', 'mailtv.net', 'mailtv.tv', 'mailzilla.com', 'mailzilla.org', 'mailzilla.orgmbx.cc', 'makemetheking.com', 'mallinator.com', 'manifestgenerator.com', 'manybrain.com', 'mbx.cc', 'mciek.com', 'mega.zik.dj', 'meinspamschutz.de', 'meltmail.com', 'messagebeamer.de', 'mezimages.net', 'mfsa.ru', 'mierdamail.com', 'migmail.pl', 'migumail.com', 'mindless.com', 'ministry-of-silly-walks.de', 'mintemail.com', 'misterpinball.de', 'mjukglass.nu', 'moakt.com', 'mobi.web.id', 'mobileninja.co.uk', 'moburl.com', 'mohmal.com', 'moncourrier.fr.nf', 'monemail.fr.nf', 'monmail.fr.nf', 'monumentmail.com', 'msa.minsmail.com', 'mt2009.com', 'mt2014.com', 'mt2015.com', 'mx0.wwwnew.eu', 'my10minutemail.com', 'myalias.pw', 'mycard.net.ua', 'mycleaninbox.net', 'myemailboxy.com', 'mymail-in.net', 'mymailoasis.com', 'mynetstore.de', 'mypacks.net', 'mypartyclip.de', 'myphantomemail.com', 'mysamp.de', 'myspaceinc.com', 'myspaceinc.net', 'myspaceinc.org', 'myspacepimpedup.com', 'myspamless.com', 'mytemp.email', 'mytempemail.com', 'mytempmail.com', 'mytrashmail.com', 'nabuma.com', 'neomailbox.com', 'nepwk.com', 'nervmich.net', 'nervtmich.net', 'netmails.com', 'netmails.net', 'netzidiot.de', 'neverbox.com', 'nice-4u.com', 'nincsmail.com', 'nincsmail.hu', 'nmail.cf', 'nnh.com', 'no-spam.ws', 'noblepioneer.com', 'nobulk.com', 'noclickemail.com', 'nogmailspam.info', 'nomail.pw', 'nomail.xl.cx', 'nomail2me.com', 'nomorespamemails.com', 'nonspam.eu', 'nonspammer.de', 'noref.in', 'nospam.ze.tc', 'nospam4.us', 'nospamfor.us', 'nospammail.net', 'nospamthanks.info', 'notmailinator.com', 'notsharingmy.info', 'nowhere.org', 'nowmymail.com', 'nurfuerspam.de', 'nwldx.com', 'objectmail.com', 'obobbo.com', 'odaymail.com', 'odnorazovoe.ru', 'one-time.email', 'oneoffemail.com', 'oneoffmail.com', 'onewaymail.com', 'onlatedotcom.info', 'online.ms', 'oopi.org', 'opayq.com', 'opentrash.com', 'ordinaryamerican.net', 'otherinbox.com', 'ourklips.com', 'outlawspam.com', 'ovpn.to', 'owlpic.com', 'pancakemail.com', 'paplease.com', 'pepbot.com', 'pfui.ru', 'pimpedupmyspace.com', 'pjjkp.com', 'plexolan.de', 'poczta.onet.pl', 'politikerclub.de', 'poofy.org', 'pookmail.com', 'pop3.xyz', 'postalmail.biz', 'privacy.net', 'privatdemail.net', 'privy-mail.com', 'privymail.de', 'proxymail.eu', 'prtnx.com', 'prtz.eu', 'pubmail.io', 'punkass.com', 'putthisinyourspamdatabase.com', 'pwrby.com', 'q314.net', 'qisdo.com', 'qisoa.com', 'qoika.com', 'quickinbox.com', 'quickmail.nl', 'rainmail.biz', 'rcpt.at', 're-gister.com', 'reallymymail.com', 'realtyalerts.ca', 'recode.me', 'reconmail.com', 'recursor.net', 'recyclemail.dk', 'regbypass.com', 'regbypass.comsafe-mail.net', 'rejectmail.com', 'reliable-mail.com', 'remail.cf', 'remail.ga', 'renraku.in', 'rhyta.com', 'rklips.com', 'rmqkr.net', 'royal.net', 'rppkn.com', 'rtrtr.com', 's0ny.net', 'safe-mail.net', 'safersignup.de', 'safetymail.info', 'safetypost.de', 'sandelf.de', 'sayawaka-dea.info', 'saynotospams.com', 'scatmail.com', 'schafmail.de', 'schrott-email.de', 'secretemail.de', 'secure-mail.biz', 'secure-mail.cc', 'selfdestructingmail.com', 'selfdestructingmail.org', 'sendspamhere.com', 'senseless-entertainment.com', 'services391.com', 'sharedmailbox.org', 'sharklasers.com', 'shieldedmail.com', 'shieldemail.com', 'shiftmail.com', 'shitmail.me', 'shitmail.org', 'shitware.nl', 'shmeriously.com', 'shortmail.net', 'showslow.de', 'sibmail.com', 'sinnlos-mail.de', 'siteposter.net', 'skeefmail.com', 'slapsfromlastnight.com', 'slaskpost.se', 'slipry.net', 'slopsbox.com', 'slowslow.de', 'slushmail.com', 'smashmail.de', 'smellfear.com', 'smellrear.com', 'smoug.net', 'snakemail.com', 'sneakemail.com', 'sneakmail.de', 'snkmail.com', 'sofimail.com', 'sofort-mail.de', 'softpls.asia', 'sogetthis.com', 'soisz.com', 'solvemail.info', 'soodonims.com', 'spam.la', 'spam.su', 'spam4.me', 'spamail.de', 'spamarrest.com', 'spamavert.com', 'spambob.com', 'spambob.net', 'spambob.org', 'spambog.com', 'spambog.de', 'spambog.net', 'spambog.ru', 'spambooger.com', 'spambox.info', 'spambox.irishspringrealty.com', 'spambox.us', 'spambpg.com', 'spamcannon.com', 'spamcannon.net', 'spamcero.com', 'spamcon.org', 'spamcorptastic.com', 'spamcowboy.com', 'spamcowboy.net', 'spamcowboy.org', 'spamday.com', 'spamex.com', 'spamfighter.cf', 'spamfighter.ga', 'spamfighter.gq', 'spamfighter.ml', 'spamfighter.tk', 'spamfree.eu', 'spamfree24.com', 'spamfree24.de', 'spamfree24.eu', 'spamfree24.info', 'spamfree24.net', 'spamfree24.org', 'spamgoes.in', 'spamgourmet.com', 'spamgourmet.net', 'spamgourmet.org', 'spamherelots.com', 'spamhereplease.com', 'spamhole.com', 'spamify.com', 'spaminator.de', 'spamkill.info', 'spaml.com', 'spaml.de', 'spammotel.com', 'spamobox.com', 'spamoff.de', 'spamsalad.in', 'spamslicer.com', 'spamsphere.com', 'spamspot.com', 'spamstack.net', 'spamthis.co.uk', 'spamthisplease.com', 'spamtrail.com', 'spamtroll.net', 'speed.1s.fr', 'spikio.com', 'spoofmail.de', 'spybox.de', 'squizzy.de', 'ssoia.com', 'startkeys.com', 'stexsy.com', 'stinkefinger.net', 'stop-my-spam.cf', 'stop-my-spam.com', 'stop-my-spam.ga', 'stop-my-spam.ml', 'stop-my-spam.tk', 'streetwisemail.com', 'stuffmail.de', 'super-auswahl.de', 'supergreatmail.com', 'supermailer.jp', 'superrito.com', 'superstachel.de', 'suremail.info', 'sute.jp', 'svk.jp', 'sweetxxx.de', 'tafmail.com', 'tagyourself.com', 'talkinator.com', 'tapchicuoihoi.com', 'teewars.org', 'teleworm.com', 'teleworm.us', 'temp-mail.com', 'temp-mail.net', 'temp-mail.org', 'temp-mail.ru', 'temp15qm.com', 'tempail.com', 'tempalias.com', 'tempe-mail.com', 'tempemail.biz', 'tempemail.co.za', 'tempemail.com', 'tempemail.net', 'tempemail.org', 'tempinbox.co.uk', 'tempinbox.com', 'tempmail.de', 'tempmail.eu', 'tempmail.it', 'tempmail2.com', 'tempmaildemo.com', 'tempmailer.com', 'tempmailer.de', 'tempomail.fr', 'temporarily.de', 'temporarioemail.com.br', 'temporaryemail.net', 'temporaryemail.us', 'temporaryforwarding.com', 'temporaryinbox.com', 'temporarymailaddress.com', 'tempsky.com', 'tempthe.net', 'tempymail.com', 'test.com', 'thanksnospam.info', 'thankyou2010.com', 'thc.st', 'thecloudindex.com', 'thisisnotmyrealemail.com', 'thismail.net', 'thismail.ru', 'throam.com', 'throwam.com', 'throwawayemailaddress.com', 'throwawaymail.com', 'tilien.com', 'tittbit.in', 'tizi.com', 'tmail.ws', 'tmailinator.com', 'tmpeml.info', 'toiea.com', 'tokenmail.de', 'toomail.biz', 'topranklist.de', 'tormail.net', 'tormail.org', 'tradermail.info', 'trash-amil.com', 'trash-mail.at', 'trash-mail.cf', 'trash-mail.com', 'trash-mail.de', 'trash-mail.ga', 'trash-mail.gq', 'trash-mail.ml', 'trash-mail.tk', 'trash-me.com', 'trash2009.com', 'trash2010.com', 'trash2011.com', 'trashdevil.com', 'trashdevil.de', 'trashemail.de', 'trashmail.at', 'trashmail.com', 'trashmail.de', 'trashmail.me', 'trashmail.net', 'trashmail.org', 'trashmail.ws', 'trashmailer.com', 'trashymail.com', 'trashymail.net', 'trayna.com', 'trbvm.com', 'trialmail.de', 'trickmail.net', 'trillianpro.com', 'tryalert.com', 'turual.com', 'twinmail.de', 'twoweirdtricks.com', 'tyldd.com', 'ubismail.net', 'uggsrock.com', 'umail.net', 'unlimit.com', 'unmail.ru', 'upliftnow.com', 'uplipht.com', 'uroid.com', 'us.af', 'valemail.net', 'venompen.com', 'vermutlich.net', 'veryrealemail.com', 'vidchart.com', 'viditag.com', 'viewcastmedia.com', 'viewcastmedia.net', 'viewcastmedia.org', 'viralplays.com', 'vmail.me', 'voidbay.com', 'vomoto.com', 'vpn.st', 'vsimcard.com', 'vubby.com', 'w3internet.co.uk', 'walala.org', 'walkmail.net', 'watchever.biz', 'webemail.me', 'webm4il.info', 'webuser.in', 'wee.my', 'weg-werf-email.de', 'wegwerf-email-addressen.de', 'wegwerf-email.at', 'wegwerf-emails.de', 'wegwerfadresse.de', 'wegwerfemail.com', 'wegwerfemail.de', 'wegwerfmail.de', 'wegwerfmail.info', 'wegwerfmail.net', 'wegwerfmail.org', 'wem.com', 'wetrainbayarea.com', 'wetrainbayarea.org', 'wh4f.org', 'whatiaas.com', 'whatpaas.com', 'whatsaas.com', 'whopy.com', 'whyspam.me', 'wickmail.net', 'wilemail.com', 'willhackforfood.biz', 'willselfdestruct.com', 'winemaven.info', 'wmail.cf', 'writeme.com', 'wronghead.com', 'wuzup.net', 'wuzupmail.net', 'wwwnew.eu', 'wzukltd.com', 'xagloo.com', 'xemaps.com', 'xents.com', 'xmaily.com', 'xoxy.net', 'xww.ro', 'xyzfree.net', 'yapped.net', 'yep.it', 'yogamaven.com', 'yomail.info', 'yopmail.com', 'yopmail.fr', 'yopmail.gq', 'yopmail.net', 'yopmail.org', 'yoru-dea.com', 'you-spam.com', 'youmail.ga', 'yourdomain.com', 'ypmail.webarnak.fr.eu.org', 'yuurok.com', 'yyhmail.com', 'z1p.biz', 'za.com', 'zebins.com', 'zebins.eu', 'zehnminuten.de', 'zehnminutenmail.de', 'zetmail.com', 'zippymail.info', 'zoaxe.com', 'zoemail.com', 'zoemail.net', 'zoemail.org', 'zomg.info', 'zxcv.com', 'zxcvbnm.com', 'zzz.com', ] # reCAPTCHA API # NOTE: Using the recaptcha.net domain h/t https://github.com/google/recaptcha/issues/87#issuecomment-368252094 RECAPTCHA_SITE_KEY = None RECAPTCHA_SECRET_KEY = None RECAPTCHA_VERIFY_URL = 'https://recaptcha.net/recaptcha/api/siteverify' # akismet spam check AKISMET_APIKEY = None SPAM_CHECK_ENABLED = False SPAM_CHECK_PUBLIC_ONLY = True SPAM_ACCOUNT_SUSPENSION_ENABLED = False SPAM_ACCOUNT_SUSPENSION_THRESHOLD = timedelta(hours=24) SPAM_FLAGGED_MAKE_NODE_PRIVATE = False SPAM_FLAGGED_REMOVE_FROM_SEARCH = False SHARE_API_TOKEN = None # refresh campaign every 5 minutes CAMPAIGN_REFRESH_THRESHOLD = 5 * 60 # 5 minutes in seconds AWS_ACCESS_KEY_ID = None AWS_SECRET_ACCESS_KEY = None # sitemap default settings SITEMAP_TO_S3 = False SITEMAP_AWS_BUCKET = None SITEMAP_URL_MAX = 25000 SITEMAP_INDEX_MAX = 50000 SITEMAP_STATIC_URLS = [ OrderedDict([('loc', ''), ('changefreq', 'yearly'), ('priority', '0.5')]), OrderedDict([('loc', 'preprints'), ('changefreq', 'yearly'), ('priority', '0.5')]), OrderedDict([('loc', 'prereg'), ('changefreq', 'yearly'), ('priority', '0.5')]), OrderedDict([('loc', 'meetings'), ('changefreq', 'yearly'), ('priority', '0.5')]), OrderedDict([('loc', 'registries'), ('changefreq', 'yearly'), ('priority', '0.5')]), OrderedDict([('loc', 'reviews'), ('changefreq', 'yearly'), ('priority', '0.5')]), OrderedDict([('loc', 'explore/activity'), ('changefreq', 'weekly'), ('priority', '0.5')]), OrderedDict([('loc', 'support'), ('changefreq', 'yearly'), ('priority', '0.5')]), OrderedDict([('loc', 'faq'), ('changefreq', 'yearly'), ('priority', '0.5')]), ] SITEMAP_USER_CONFIG = OrderedDict([('loc', ''), ('changefreq', 'yearly'), ('priority', '0.5')]) SITEMAP_NODE_CONFIG = OrderedDict([('loc', ''), ('lastmod', ''), ('changefreq', 'monthly'), ('priority', '0.5')]) SITEMAP_PREPRINT_CONFIG = OrderedDict([('loc', ''), ('lastmod', ''), ('changefreq', 'yearly'), ('priority', '0.5')]) SITEMAP_PREPRINT_FILE_CONFIG = OrderedDict([('loc', ''), ('lastmod', ''), ('changefreq', 'yearly'), ('priority', '0.5')]) # For preventing indexing of QA nodes by Elastic and SHARE DO_NOT_INDEX_LIST = { 'tags': ['qatest', 'qa test'], 'titles': ['Bulk stress 201', 'Bulk stress 202', 'OSF API Registration test'], } CUSTOM_CITATIONS = { 'bluebook-law-review': 'bluebook', 'bluebook2': 'bluebook', 'bluebook-inline': 'bluebook' } #Email templates logo OSF_LOGO = 'osf_logo' OSF_PREPRINTS_LOGO = 'osf_preprints' OSF_MEETINGS_LOGO = 'osf_meetings' OSF_PREREG_LOGO = 'osf_prereg' OSF_REGISTRIES_LOGO = 'osf_registries' OSF_LOGO_LIST = [OSF_LOGO, OSF_PREPRINTS_LOGO, OSF_MEETINGS_LOGO, OSF_PREREG_LOGO, OSF_REGISTRIES_LOGO] FOOTER_LINKS = { 'terms': 'https://github.com/CenterForOpenScience/centerforopenscience.org/blob/master/TERMS_OF_USE.md', 'privacyPolicy': 'https://github.com/CenterForOpenScience/centerforopenscience.org/blob/master/PRIVACY_POLICY.md', 'cookies': 'https://github.com/CenterForOpenScience/centerforopenscience.org/blob/master/PRIVACY_POLICY.md#f-cookies', 'cos': 'https://cos.io', 'statusPage': 'https://status.cos.io/', 'apiDocs': 'https://developer.osf.io/', 'topGuidelines': 'http://cos.io/top/', 'rpp': 'https://osf.io/ezcuj/wiki/home/', 'rpcb': 'https://osf.io/e81xl/wiki/home/', 'twitter': 'http://twitter.com/OSFramework', 'facebook': 'https://www.facebook.com/CenterForOpenScience/', 'googleGroup': 'https://groups.google.com/forum/#!forum/openscienceframework', 'github': 'https://www.github.com/centerforopenscience', }
[]
[]
[ "RABBITMQ_VHOST", "RABBITMQ_HOST", "BROKER_URL", "RABBITMQ_USERNAME", "RABBITMQ_PORT", "RABBITMQ_PASSWORD" ]
[]
["RABBITMQ_VHOST", "RABBITMQ_HOST", "BROKER_URL", "RABBITMQ_USERNAME", "RABBITMQ_PORT", "RABBITMQ_PASSWORD"]
python
6
0
db/events/purge.go
package events import ( "context" "database/sql" "os" "strconv" "strings" "time" "github.com/packethost/pkg/log" "github.com/pkg/errors" ) const defaultEventsTTL = "60m" // Purge periodically checks the events table and // purges the events that have passed the defined EVENTS_TTL func Purge(db *sql.DB, logger log.Logger) error { env := os.Getenv("EVENTS_TTL") if env == "" { env = defaultEventsTTL } val := strings.TrimRight(env, "m") ttl, err := strconv.Atoi(val) if err != nil { return err } ticker := time.NewTicker(time.Duration(ttl) * time.Minute) for range ticker.C { then := time.Now().Local().Add(time.Duration(int64(-ttl) * int64(time.Minute))) tx, err := db.BeginTx(context.Background(), &sql.TxOptions{Isolation: sql.LevelSerializable}) if err != nil { return errors.Wrap(err, "BEGIN transaction") } _, err = tx.Exec("DELETE FROM events WHERE created_at <= $1;", then) if err != nil { return errors.Wrap(err, "DELETE") } logger.Info("purging events") err = tx.Commit() if err != nil { return errors.Wrap(err, "COMMIT") } } return nil }
[ "\"EVENTS_TTL\"" ]
[]
[ "EVENTS_TTL" ]
[]
["EVENTS_TTL"]
go
1
0
src/sasctl/utils/cli.py
#!/usr/bin/env python # encoding: utf-8 # # Copyright © 2019, SAS Institute Inc., Cary, NC, USA. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 import argparse import inspect import json import logging import os import pkgutil import warnings from collections import namedtuple, defaultdict from importlib import import_module from pprint import pprint ArgInfo = namedtuple('ArgInfo', ['name', 'type', 'required', 'default', 'doc']) def sasctl_command(name, subname=None): """Decorator that tags the function as being usable from the command line. Parameters ---------- name : str the name of the command that will be shown on the command line. subname : str the name of the service that the command will be listed under Returns ------- function Examples -------- Define a command called 'cmd' not associated with a service >>> @sasctl_command('cmd') >>> def func(): ... Define a command called 'cmd' associated with the 'svc' service >>> @sasctl_command('svc', 'cmd') >>> def func(): ... Define a command and allow it's name and service to be auto-assigned >>> @sasctl_command >>> def func(): ... """ def decorator(func): if isinstance(name, str): if isinstance(subname, str): command_name = subname service_name = name else: command_name = name service_name = subname else: command_name = func.__name__ if any( command_name.startswith(x) for x in ['list_', 'update_', 'get_', 'create_', 'delete_'] ): parts = command_name.split('_') command_name = parts[0] service_name = parts[-1] else: service_name = subname def parse_args(): """Retrieve argument metadata from function signature and docstring.""" arg_spec = inspect.getargspec(func) defaults = list(arg_spec.defaults) if arg_spec.defaults is not None else [] required = [True] * (len(arg_spec.args) - len(defaults)) + [False] * len( defaults ) defaults = [None] * (len(arg_spec.args) - len(defaults)) + defaults types = [] help_doc = [] doc = inspect.getdoc(func) if doc and doc.find('Parameters\n'): doc_lines = doc[doc.find('Parameters\n') :].splitlines() doc_lines.pop(0) # First line is "Parameters" if doc_lines and doc_lines[0].startswith('---'): doc_lines.pop( 0 ) # Discard ----------- line under "Parameters" heading while doc_lines: var = doc_lines.pop(0) if var.startswith('Returns') or var.strip() == '': break if ':' in var: types.append(var.split(':')[-1].strip()) else: types.append('str') if doc_lines and doc_lines[0].startswith(' '): help_doc.append(doc_lines.pop(0).strip()) else: help_doc.append('') else: types = ['str'] * len(arg_spec.args) help_doc = [None] * len(arg_spec.args) return [ ArgInfo(n, t, r, d, o) for n, t, r, d, o in zip( arg_spec.args, types, required, defaults, help_doc ) ] func._cli_command = command_name func._cli_service = service_name func._cli_arguments = parse_args return func if callable(name): # allow direct decoration without arguments return decorator(name) return decorator def _find_services(module='sasctl'): """Recursively find all functions in all modules that have been decorated as CLI commands.""" m = __import__(module, fromlist=['']) # returns a module def find_recurse(module, services): for obj in dir(module): obj = getattr(module, obj) source_module = getattr(obj, '__module__', type(obj).__module__) # Module-level functions that are tagged as commands if hasattr(obj, '_cli_command') and hasattr(obj, '_cli_service'): services[obj._cli_service][obj._cli_command] = obj # Check methods on service classes elif source_module.startswith('sasctl._services'): for atr in dir(obj): atr = getattr(obj, atr) if hasattr(atr, '_cli_command') and hasattr(atr, '_cli_service'): services[atr._cli_service][atr._cli_command] = atr # recurse into submodules submodules = pkgutil.iter_modules(getattr(module, '__path__', [])) for submodule in submodules: # ModuleInfo returned py 3.6 has .name # Tuple of (module_loader, name, ispkg) returned by older versions submodule_name = getattr(submodule, 'name', submodule[1]) # TODO: Temporary until pzmm fully merged with sasctl if submodule_name == 'pzmm': continue submodule = import_module('.' + submodule_name, package=module.__name__) # if hasattr(submodule, 'name'): # # ModuleInfo returned py 3.6 # submodule = import_module('.' + submodule.name, package=module.__name__) # else: # # Tuple of (module_loader, name, ispkg) returned by older versions # submodule = import_module('.' + submodule[1], package=module.__name__) services = find_recurse(submodule, services) return services services = find_recurse(m, defaultdict(dict)) return services def _get_func_description(func): description = getattr(func, '__doc__', '') lines = description.split('\n') if lines: return lines[0] def _build_parser(services): from sasctl import __version__ # TODO: Set command docstring # Create standard, top-level arguments parser = argparse.ArgumentParser( prog='sasctl', description='sasctl interacts with a SAS Viya environment.' ) parser.add_argument( '-k', '--insecure', action='store_true', help='skip SSL verification' ) parser.add_argument( '-f', '--format', choices=['json'], default='json', help='output format' ) parser.add_argument('-v', '--verbose', action='count') parser.add_argument( '--version', action='version', version='%(prog)s ' + __version__ ) subparsers = parser.add_subparsers(title='service', dest='service') subparsers.required = True for service, commands in services.items(): service_parser = subparsers.add_parser(service) service_subparser = service_parser.add_subparsers( title='command', dest='command' ) service_subparser.required = True # Add the command and arguments for each command for command in commands: func = services[service][command] cmd_parser = service_subparser.add_parser( command, help=_get_func_description(func) ) for arg in func._cli_arguments(): if arg.name in ('self', 'cls'): continue if arg.required: cmd_parser.add_argument(arg.name, help=arg.doc) else: cmd_parser.add_argument( '--' + arg.name, required=arg.required, default=arg.default, help=arg.doc, ) return parser def main(args=None): """Main entry point when executed as a command line utility.""" from sasctl import Session, current_session # Find all services and associated commands services = _find_services() parser = _build_parser(services) args = parser.parse_args(args) if args.verbose is None or args.verbose == 0: lvl = logging.WARNING elif args.verbose == 1: lvl = logging.INFO else: lvl = logging.DEBUG handler = logging.StreamHandler() handler.setLevel(lvl) logging.getLogger('sasctl.core').addHandler(handler) logging.getLogger('sasctl.core').setLevel(lvl) warnings.simplefilter('ignore') func = services[args.service][args.command] kwargs = vars(args).copy() # Remove args that shouldn't be passed to the underlying command for k in ['command', 'service', 'insecure', 'verbose', 'format']: kwargs.pop(k, None) username = os.environ.get('SASCTL_USER_NAME') password = os.environ.get('SASCTL_PASSWORD') server = os.environ.get('SASCTL_SERVER_NAME') if server is None: parser.error( "Hostname must be specified in the 'SASCTL_SERVER_NAME' environment variable." ) verify_ssl = not args.insecure try: # current_session() should never be set when executing from the # command line but it allows us to provide a pre-created session # during testing with current_session() or Session( server, username, password, verify_ssl=verify_ssl ): result = func(**kwargs) if isinstance(result, list): pprint([str(x) for x in result]) elif isinstance(result, dict) and args.format == 'json': print(json.dumps(result, indent=2)) else: pprint(result) except RuntimeError as e: parser.error(e)
[]
[]
[ "SASCTL_SERVER_NAME", "SASCTL_USER_NAME", "SASCTL_PASSWORD" ]
[]
["SASCTL_SERVER_NAME", "SASCTL_USER_NAME", "SASCTL_PASSWORD"]
python
3
0
cmd/agi/main.go
// Copyright (C) 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // The gapid command launches the GAPID UI. It looks for the JVM (bundled or // from the system), the GAPIC JAR (bundled or from the build output) and // launches GAPIC with the correct JVM flags and environment variables. package main import ( "fmt" "os" "os/exec" "path/filepath" "runtime" "strconv" "strings" ) const ( versionPrefix = `version "` googleInfix = "-google-" minJavaMajor = 1 minJavaMinor = 8 ) type config struct { cwd string vm string vmArgs []string gapic string args []string help bool console bool verbose bool } func main() { os.Exit(run()) } func run() int { c := newConfig() if c.console { createConsole() if runtime.GOOS == "windows" { defer func() { fmt.Println() fmt.Println("Press enter to continue") os.Stdin.Read(make([]byte, 1)) }() } } if c.help { defer func() { fmt.Println() fmt.Println("Launcher Flags:") fmt.Println(" --jar Path to the gapic JAR to use") fmt.Println(" --vm Path to the JVM to use") fmt.Println(" --vmarg Extra argument for the JVM (repeatable)") fmt.Println(" --console Run AGI inside a terminal console") fmt.Println(" --verbose-startup Log verbosely in the launcher") }() } if err := c.locateCWD(); err != nil { fmt.Println(err) return 1 } if err := c.locateVM(); err != nil { fmt.Println(err) if !c.verbose { fmt.Println("Use --verbose-startup for additional details") } return 1 } if err := c.locateGAPIC(); err != nil { fmt.Println(err) return 1 } fmt.Println("Starting", c.vm, c.gapic) cmd := exec.Command(c.vm, append(append(c.vmArgs, "-jar", c.gapic), c.args...)...) cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr cmd.Env = append(os.Environ(), "GAPID="+c.cwd) if runtime.GOOS == "linux" { cmd.Env = append(cmd.Env, "LIBOVERLAY_SCROLLBAR=0") cmd.Env = append(cmd.Env, "GTK_OVERLAY_SCROLLING=0") } // If run via 'bazel run', use the shell's CWD, not bazel's. if cwd := os.Getenv("BUILD_WORKING_DIRECTORY"); cwd != "" { cmd.Dir = cwd } if err := cmd.Run(); err != nil { if _, ok := err.(*exec.ExitError); !ok { fmt.Println("Failed to start GAPIC:", err) } return 1 } return 0 } func newConfig() *config { c := &config{} // Doing our own flag handling (rather than using go's flag package) to avoid // it attempting to parse the GAPIC flags, which may be in a different format. // This loop simply looks for the launcher flags, but hands everything else to // GAPIC verbatim. args := os.Args[1:] for i := 0; i < len(args); i++ { switch { case args[i] == "--jar" && i < len(args)-1: i++ c.gapic = args[i] case args[i] == "--vm" && i < len(args)-1: i++ c.vm = args[i] case args[i] == "--vmarg" && i < len(args)-1: i++ c.vmArgs = append(c.vmArgs, args[i]) case args[i] == "--console": c.console = true case args[i] == "--verbose-startup": c.verbose = true default: c.help = c.help || args[i] == "--help" || args[i] == "--fullhelp" c.args = append(c.args, args[i]) } } c.console = c.console || c.help if runtime.GOOS == "darwin" { c.vmArgs = append(c.vmArgs, "-XstartOnFirstThread") } return c } func (c *config) logIfVerbose(args ...interface{}) { if c.verbose { fmt.Println(args...) } } func (c *config) locateCWD() error { cwd, err := os.Executable() if err != nil { return err } cwd, err = filepath.EvalSymlinks(cwd) if err == nil { c.cwd = filepath.Dir(cwd) c.logIfVerbose("CWD:", c.cwd) } return err } func (c *config) locateVM() error { if c.vm != "" { if c.checkVM(c.vm, false) { return nil } if runtime.GOOS == "windows" && c.checkVM(c.vm+".exe", false) { c.vm += ".exe" return nil } if java := c.javaInHome(c.vm); c.checkVM(java, false) { c.vm = java return nil } return fmt.Errorf("JVM '%s' not found/usable", c.vm) } if java := c.javaInHome(filepath.Join(c.cwd, "jre")); c.checkVM(java, true) { c.vm = java return nil } if runtime.GOOS == "linux" { if java := "/usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java"; c.checkVM(java, true) { c.vm = java return nil } } if home := os.Getenv("JAVA_HOME"); home != "" { if java := c.javaInHome(home); c.checkVM(java, true) { c.vm = java return nil } } if java, err := exec.LookPath(c.javaExecutable()); err == nil && c.checkVM(java, true) { c.vm = java return nil } return fmt.Errorf("No suitable JVM found. A JRE >= %d.%d is required.", minJavaMajor, minJavaMinor) } func (c *config) javaExecutable() string { if runtime.GOOS == "windows" { if c.console { return "java.exe" } return "javaw.exe" } return "java" } func (c *config) javaInHome(home string) string { return filepath.Join(home, "bin", c.javaExecutable()) } func (c *config) checkVM(java string, checkVersion bool) bool { if stat, err := os.Stat(java); err != nil || stat.IsDir() { c.logIfVerbose("Not using " + java + ": not a file") return false } if !checkVersion { return true } version, err := exec.Command(java, "-version").CombinedOutput() if err != nil { c.logIfVerbose("Not using " + java + ": failed to get version info") return false } versionStr := string(version) // Blacklist the Google custom JDKs. if p := strings.Index(versionStr, googleInfix); p >= 0 { c.logIfVerbose("Not using " + java + ": is a Google JDK (go/gapid-jdk)") return false } // Looks for the pattern: <product> version "<major>.<minor>.<micro><build>" // Not using regular expressions to avoid binary bloat. if p := strings.Index(versionStr, versionPrefix); p >= 0 { p += len(versionPrefix) if q := strings.Index(versionStr[p:], "."); q > 0 { if r := strings.Index(versionStr[p+q+1:], "."); r > 0 { major, _ := strconv.Atoi(versionStr[p : p+q]) minor, _ := strconv.Atoi(versionStr[p+q+1 : p+q+r+1]) useIt := major > minJavaMajor || (major == minJavaMajor && minor >= minJavaMinor) if !useIt { c.logIfVerbose("Not using " + java + ": unsupported version") } return useIt } } } c.logIfVerbose("Not using " + java + ": failed to parse version") return false } func (c *config) locateGAPIC() error { gapic := c.gapic if gapic == "" { gapic = filepath.Join(c.cwd, "lib", "gapic.jar") } if abs, err := filepath.Abs(gapic); err == nil { gapic = abs } if _, err := os.Stat(gapic); !os.IsNotExist(err) { c.gapic = gapic return nil } return fmt.Errorf("GAPIC JAR '%s' not found", gapic) }
[ "\"BUILD_WORKING_DIRECTORY\"", "\"JAVA_HOME\"" ]
[]
[ "JAVA_HOME", "BUILD_WORKING_DIRECTORY" ]
[]
["JAVA_HOME", "BUILD_WORKING_DIRECTORY"]
go
2
0
cmd/newmanExecute_generated.go
// Code generated by piper's step-generator. DO NOT EDIT. package cmd import ( "fmt" "os" "path/filepath" "time" "github.com/SAP/jenkins-library/pkg/config" "github.com/SAP/jenkins-library/pkg/log" "github.com/SAP/jenkins-library/pkg/piperenv" "github.com/SAP/jenkins-library/pkg/splunk" "github.com/SAP/jenkins-library/pkg/telemetry" "github.com/spf13/cobra" ) type newmanExecuteOptions struct { NewmanCollection string `json:"newmanCollection,omitempty"` NewmanRunCommand string `json:"newmanRunCommand,omitempty"` RunOptions []string `json:"runOptions,omitempty"` NewmanInstallCommand string `json:"newmanInstallCommand,omitempty"` NewmanEnvironment string `json:"newmanEnvironment,omitempty"` NewmanGlobals string `json:"newmanGlobals,omitempty"` FailOnError bool `json:"failOnError,omitempty"` CfAppsWithSecrets []string `json:"cfAppsWithSecrets,omitempty"` } type newmanExecuteInflux struct { step_data struct { fields struct { newman bool } tags struct { } } } func (i *newmanExecuteInflux) persist(path, resourceName string) { measurementContent := []struct { measurement string valType string name string value interface{} }{ {valType: config.InfluxField, measurement: "step_data", name: "newman", value: i.step_data.fields.newman}, } errCount := 0 for _, metric := range measurementContent { err := piperenv.SetResourceParameter(path, resourceName, filepath.Join(metric.measurement, fmt.Sprintf("%vs", metric.valType), metric.name), metric.value) if err != nil { log.Entry().WithError(err).Error("Error persisting influx environment.") errCount++ } } if errCount > 0 { log.Entry().Fatal("failed to persist Influx environment") } } // NewmanExecuteCommand Installs newman and executes specified newman collections. func NewmanExecuteCommand() *cobra.Command { const STEP_NAME = "newmanExecute" metadata := newmanExecuteMetadata() var stepConfig newmanExecuteOptions var startTime time.Time var influx newmanExecuteInflux var logCollector *log.CollectorHook var createNewmanExecuteCmd = &cobra.Command{ Use: STEP_NAME, Short: "Installs newman and executes specified newman collections.", Long: `This script executes [Postman](https://www.getpostman.com) tests from a collection via the [Newman](https://www.getpostman.com/docs/v6/postman/collection_runs/command_line_integration_with_newman) command line tool.`, PreRunE: func(cmd *cobra.Command, _ []string) error { startTime = time.Now() log.SetStepName(STEP_NAME) log.SetVerbose(GeneralConfig.Verbose) GeneralConfig.GitHubAccessTokens = ResolveAccessTokens(GeneralConfig.GitHubTokens) path, _ := os.Getwd() fatalHook := &log.FatalHook{CorrelationID: GeneralConfig.CorrelationID, Path: path} log.RegisterHook(fatalHook) err := PrepareConfig(cmd, &metadata, STEP_NAME, &stepConfig, config.OpenPiperFile) if err != nil { log.SetErrorCategory(log.ErrorConfiguration) return err } if len(GeneralConfig.HookConfig.SentryConfig.Dsn) > 0 { sentryHook := log.NewSentryHook(GeneralConfig.HookConfig.SentryConfig.Dsn, GeneralConfig.CorrelationID) log.RegisterHook(&sentryHook) } if len(GeneralConfig.HookConfig.SplunkConfig.Dsn) > 0 { logCollector = &log.CollectorHook{CorrelationID: GeneralConfig.CorrelationID} log.RegisterHook(logCollector) } return nil }, Run: func(_ *cobra.Command, _ []string) { telemetryData := telemetry.CustomData{} telemetryData.ErrorCode = "1" handler := func() { config.RemoveVaultSecretFiles() influx.persist(GeneralConfig.EnvRootPath, "influx") telemetryData.Duration = fmt.Sprintf("%v", time.Since(startTime).Milliseconds()) telemetryData.ErrorCategory = log.GetErrorCategory().String() telemetry.Send(&telemetryData) if len(GeneralConfig.HookConfig.SplunkConfig.Dsn) > 0 { splunk.Send(&telemetryData, logCollector) } } log.DeferExitHandler(handler) defer handler() telemetry.Initialize(GeneralConfig.NoTelemetry, STEP_NAME) if len(GeneralConfig.HookConfig.SplunkConfig.Dsn) > 0 { splunk.Initialize(GeneralConfig.CorrelationID, GeneralConfig.HookConfig.SplunkConfig.Dsn, GeneralConfig.HookConfig.SplunkConfig.Token, GeneralConfig.HookConfig.SplunkConfig.Index, GeneralConfig.HookConfig.SplunkConfig.SendLogs) } newmanExecute(stepConfig, &telemetryData, &influx) telemetryData.ErrorCode = "0" log.Entry().Info("SUCCESS") }, } addNewmanExecuteFlags(createNewmanExecuteCmd, &stepConfig) return createNewmanExecuteCmd } func addNewmanExecuteFlags(cmd *cobra.Command, stepConfig *newmanExecuteOptions) { cmd.Flags().StringVar(&stepConfig.NewmanCollection, "newmanCollection", `**/*.postman_collection.json`, "The test collection that should be executed. This could also be a file pattern.") cmd.Flags().StringVar(&stepConfig.NewmanRunCommand, "newmanRunCommand", os.Getenv("PIPER_newmanRunCommand"), "+++ Deprecated +++ Please use list parameter `runOptions` instead.") cmd.Flags().StringSliceVar(&stepConfig.RunOptions, "runOptions", []string{`run`, `{{.NewmanCollection}}`, `--reporters`, `cli,junit,html`, `--reporter-junit-export`, `target/newman/TEST-{{.CollectionDisplayName}}.xml`, `--reporter-html-export`, `target/newman/TEST-{{.CollectionDisplayName}}.html`}, "The newman command that will be executed inside the docker container.") cmd.Flags().StringVar(&stepConfig.NewmanInstallCommand, "newmanInstallCommand", `npm install newman newman-reporter-html --global --quiet`, "The shell command that will be executed inside the docker container to install Newman.") cmd.Flags().StringVar(&stepConfig.NewmanEnvironment, "newmanEnvironment", os.Getenv("PIPER_newmanEnvironment"), "Specify an environment file path or URL. Environments provide a set of variables that one can use within collections.") cmd.Flags().StringVar(&stepConfig.NewmanGlobals, "newmanGlobals", os.Getenv("PIPER_newmanGlobals"), "Specify the file path or URL for global variables. Global variables are similar to environment variables but have a lower precedence and can be overridden by environment variables having the same name.") cmd.Flags().BoolVar(&stepConfig.FailOnError, "failOnError", true, "Defines the behavior, in case tests fail.") cmd.Flags().StringSliceVar(&stepConfig.CfAppsWithSecrets, "cfAppsWithSecrets", []string{}, "List of CloudFoundry apps with secrets") } // retrieve step metadata func newmanExecuteMetadata() config.StepData { var theMetaData = config.StepData{ Metadata: config.StepMetadata{ Name: "newmanExecute", Aliases: []config.Alias{}, Description: "Installs newman and executes specified newman collections.", }, Spec: config.StepSpec{ Inputs: config.StepInputs{ Resources: []config.StepResources{ {Name: "tests", Type: "stash"}, }, Parameters: []config.StepParameters{ { Name: "newmanCollection", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "string", Mandatory: false, Aliases: []config.Alias{}, Default: `**/*.postman_collection.json`, }, { Name: "newmanRunCommand", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "string", Mandatory: false, Aliases: []config.Alias{}, Default: os.Getenv("PIPER_newmanRunCommand"), }, { Name: "runOptions", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "[]string", Mandatory: false, Aliases: []config.Alias{}, Default: []string{`run`, `{{.NewmanCollection}}`, `--reporters`, `cli,junit,html`, `--reporter-junit-export`, `target/newman/TEST-{{.CollectionDisplayName}}.xml`, `--reporter-html-export`, `target/newman/TEST-{{.CollectionDisplayName}}.html`}, }, { Name: "newmanInstallCommand", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "string", Mandatory: false, Aliases: []config.Alias{}, Default: `npm install newman newman-reporter-html --global --quiet`, }, { Name: "newmanEnvironment", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "string", Mandatory: false, Aliases: []config.Alias{}, Default: os.Getenv("PIPER_newmanEnvironment"), }, { Name: "newmanGlobals", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "string", Mandatory: false, Aliases: []config.Alias{}, Default: os.Getenv("PIPER_newmanGlobals"), }, { Name: "failOnError", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "bool", Mandatory: false, Aliases: []config.Alias{}, Default: true, }, { Name: "cfAppsWithSecrets", ResourceRef: []config.ResourceReference{}, Scope: []string{"PARAMETERS", "STAGES", "STEPS"}, Type: "[]string", Mandatory: false, Aliases: []config.Alias{}, Default: []string{}, }, }, }, Containers: []config.Container{ {Name: "newman", Image: "node:lts-stretch", WorkingDir: "/home/node"}, }, Outputs: config.StepOutputs{ Resources: []config.StepResources{ { Name: "influx", Type: "influx", Parameters: []map[string]interface{}{ {"Name": "step_data"}, {"fields": []map[string]string{{"name": "newman"}}}, }, }, }, }, }, } return theMetaData }
[ "\"PIPER_newmanRunCommand\"", "\"PIPER_newmanEnvironment\"", "\"PIPER_newmanGlobals\"", "\"PIPER_newmanRunCommand\"", "\"PIPER_newmanEnvironment\"", "\"PIPER_newmanGlobals\"" ]
[]
[ "PIPER_newmanRunCommand", "PIPER_newmanGlobals", "PIPER_newmanEnvironment" ]
[]
["PIPER_newmanRunCommand", "PIPER_newmanGlobals", "PIPER_newmanEnvironment"]
go
3
0
frontend/src/web.py
#!/usr/bin/env python # -*- coding: utf-8 -*- import cherrypy import os import collections import api import monitorfrontend import tablesfrontend import sprocsfrontend import indexesfrontend import report import performance import hosts import export import hostsfrontend import welcomefrontend import datadb import tplE import yaml from argparse import ArgumentParser from cherrypy._cpdispatch import Dispatcher class Healthcheck(object): def default(self, *args, **kwargs): return {} default.exposed = True class HostIdAndShortnameDispatcher(Dispatcher): def __call__(self, path_info): splits = path_info.split('/') if len(splits) > 1 and splits[1]: if splits[1].isdigit() or splits[1] in hosts.getAllHostUinamesSorted(): return Dispatcher.__call__(self, '/host' + path_info) return Dispatcher.__call__(self, path_info.lower()) def main(): parser = ArgumentParser(description='PGObserver Frontend') parser.add_argument('-c', '--config', help='Path to yaml config file with datastore connect details. See pgobserver_frontend.example.yaml for a sample file. \ Certain values can be overridden by ENV vars PGOBS_HOST, PGOBS_DBNAME, PGOBS_USER, PGOBS_PASSWORD [, PGOBS_PORT]') parser.add_argument('--s3-config-path', help='Path style S3 URL to a key that holds the config file. Or PGOBS_CONFIG_S3_BUCKET env. var', metavar='https://s3-region.amazonaws.com/x/y/file.yaml', default=os.getenv('PGOBS_CONFIG_S3_BUCKET')) parser.add_argument('-p', '--port', help='Web server port. Overrides value from config file', type=int) args = parser.parse_args() settings = collections.defaultdict(dict) if args.s3_config_path: # S3 has precedence if specified import aws_s3_configreader settings = aws_s3_configreader.get_config_as_dict_from_s3_file(args.s3_config_path) elif args.config: args.config = os.path.expanduser(args.config) if not os.path.exists(args.config): print 'WARNING. Config file {} not found! exiting...'.format(args.config) return print "trying to read config file from {}".format(args.config) with open(args.config, 'rb') as fd: settings = yaml.load(fd) # Make env vars overwrite yaml file, to run via docker without changing config file settings['database']['host'] = (os.getenv('PGOBS_HOST') or settings['database'].get('host')) settings['database']['port'] = (os.getenv('PGOBS_PORT') or settings['database'].get('port') or 5432) settings['database']['name'] = (os.getenv('PGOBS_DATABASE') or settings['database'].get('name')) settings['database']['frontend_user'] = (os.getenv('PGOBS_USER') or settings['database'].get('frontend_user')) settings['database']['frontend_password'] = (os.getenv('PGOBS_PASSWORD') or settings['database'].get('frontend_password')) if not (settings['database'].get('host') and settings['database'].get('name') and settings['database'].get('frontend_user')): print 'Mandatory datastore connect details missing!' print 'Check --config input or environment variables: PGOBS_HOST, PGOBS_DATABASE, PGOBS_USER, PGOBS_PASSWORD [, PGOBS_PORT]' print '' parser.print_help() return conn_string = ' '.join(( 'dbname=' + settings['database']['name'], 'host=' + settings['database']['host'], 'user=' + settings['database']['frontend_user'], 'port=' + str(settings['database']['port']), )) print 'Setting connection string to ... ' + conn_string # finished print conn_string to the world, password can be added conn_string = conn_string + ' password=' + settings['database']['frontend_password'] datadb.setConnectionString(conn_string) current_dir = os.path.dirname(os.path.abspath(__file__)) conf = { 'global': {'server.socket_host': '0.0.0.0', 'server.socket_port': args.port or settings.get('frontend', {}).get('port') or 8080}, '/': {'tools.staticdir.root': current_dir, 'request.dispatch': HostIdAndShortnameDispatcher()}, '/healthcheck': {'tools.sessions.on': False}, '/static': {'tools.staticdir.dir': 'static', 'tools.staticdir.on': True, 'tools.sessions.on': False}, '/manifest.info': {'tools.staticfile.on': True, 'tools.staticfile.filename': os.path.join(current_dir, '..', 'MANIFEST.MF'), 'tools.auth_basic.on': False, 'tools.sessions.on': False}, } tplE.setup(settings) # setup of global variables and host data for usage in views root = welcomefrontend.WelcomeFrontend() root.host = monitorfrontend.MonitorFrontend() root.report = report.Report() root.export = export.Export() root.perftables = performance.PerfTables() root.perfapi = performance.PerfApi() root.perfindexes = performance.PerfIndexes() root.perfschemas = performance.PerfUnusedSchemas() root.perflocks = performance.PerfLocksReport() root.perfstatstatements = performance.PerfStatStatementsReport() root.perfbloat = performance.PerfBloat() root.sprocs = sprocsfrontend.SprocFrontend() root.tables = tablesfrontend.TableFrontend() root.indexes = indexesfrontend.IndexesFrontend() root.hosts = hostsfrontend.HostsFrontend() root.api = api.Root(root) # JSON api exposure, enabling integration with other monitoring tools root.healthcheck = Healthcheck() if settings.get('oauth', {}).get('enable_oauth', False): print 'switching on oauth ...' import oauth root.oauth = oauth.Oauth(settings['oauth']) cherrypy.config.update({'tools.oauthtool.on': True, 'tools.sessions.on': True, 'tools.sessions.timeout': settings['oauth'].get('session_timeout', 43200)}) cherrypy.quickstart(root, config=conf) if __name__ == '__main__': main()
[]
[]
[ "PGOBS_HOST", "PGOBS_PASSWORD", "PGOBS_PORT", "PGOBS_DATABASE", "PGOBS_CONFIG_S3_BUCKET", "PGOBS_USER" ]
[]
["PGOBS_HOST", "PGOBS_PASSWORD", "PGOBS_PORT", "PGOBS_DATABASE", "PGOBS_CONFIG_S3_BUCKET", "PGOBS_USER"]
python
6
0
webhook_test.go
// © Copyright 2016 GREAT BEYOND AB // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package mailchimp import ( "context" "os" check "gopkg.in/check.v1" t "github.com/greatbeyond/mailchimp/testing" ) var _ = check.Suite(&WebhookTestSuite{}) type WebhookTestSuite struct { client *Client server *t.MockServer ctx context.Context } func (s *WebhookTestSuite) SetUpSuite(c *check.C) {} func (s *WebhookTestSuite) SetUpTest(c *check.C) { s.server = t.NewMockServer() s.server.SetChecker(c) s.client = NewClient() s.client.HTTPClient = s.server.HTTPClient s.ctx = NewContextWithToken(context.Background(), os.Getenv("MAILCHIMP_TEST_TOKEN")) // We need http to use the mock server s.ctx = NewContextWithURL(s.ctx, "http://us13.api.mailchimp.com/3.0/") } func (s *WebhookTestSuite) TearDownTest(c *check.C) {} func (s *WebhookTestSuite) Skip_CreateWebhook(c *check.C) { createWebhookResponse, err := s.client.CreateWebhook(s.ctx, &CreateWebhook{ ListID: "1", URL: "http://test.url/webhook", Events: &WebhookEvents{ Subscribe: true, Unsubscribe: true, }, Sources: &WebhookSources{ User: true, }, }) c.Assert(err, check.IsNil) c.Assert(createWebhookResponse, check.NotNil) } func (s *WebhookTestSuite) Skip_GetWebhook(c *check.C) { getWebhookResponse, err := s.client.GetWebhook(s.ctx, "1", "2") c.Assert(err, check.IsNil) c.Assert(getWebhookResponse, check.NotNil) } func (s *WebhookTestSuite) Skip_GetWebhooks(c *check.C) { getWebhooksResponse, err := s.client.GetWebhooks(s.ctx, "1") c.Assert(err, check.IsNil) c.Assert(getWebhooksResponse, check.NotNil) } func (s *WebhookTestSuite) Skip_DeleteWebhook(c *check.C) { getWebhookResponse, err := s.client.GetWebhook(s.ctx, "1", "2") c.Assert(err, check.IsNil) c.Assert(getWebhookResponse, check.NotNil) err = getWebhookResponse.DeleteWebhook(s.ctx) c.Assert(err, check.IsNil) }
[ "\"MAILCHIMP_TEST_TOKEN\"" ]
[]
[ "MAILCHIMP_TEST_TOKEN" ]
[]
["MAILCHIMP_TEST_TOKEN"]
go
1
0
clients/google-api-services-cloudfunctions/v1/1.31.0/com/google/api/services/cloudfunctions/v1/CloudFunctions.java
/* * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except * in compliance with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express * or implied. See the License for the specific language governing permissions and limitations under * the License. */ /* * This code was generated by https://github.com/googleapis/google-api-java-client-services/ * Modify at your own risk. */ package com.google.api.services.cloudfunctions.v1; /** * Service definition for CloudFunctions (v1). * * <p> * Manages lightweight user-provided functions executed in response to events. * </p> * * <p> * For more information about this service, see the * <a href="https://cloud.google.com/functions" target="_blank">API Documentation</a> * </p> * * <p> * This service uses {@link CloudFunctionsRequestInitializer} to initialize global parameters via its * {@link Builder}. * </p> * * @since 1.3 * @author Google, Inc. */ @SuppressWarnings("javadoc") public class CloudFunctions extends com.google.api.client.googleapis.services.json.AbstractGoogleJsonClient { // Note: Leave this static initializer at the top of the file. static { com.google.api.client.util.Preconditions.checkState( com.google.api.client.googleapis.GoogleUtils.MAJOR_VERSION == 1 && (com.google.api.client.googleapis.GoogleUtils.MINOR_VERSION >= 32 || (com.google.api.client.googleapis.GoogleUtils.MINOR_VERSION == 31 && com.google.api.client.googleapis.GoogleUtils.BUGFIX_VERSION >= 1)), "You are currently running with version %s of google-api-client. " + "You need at least version 1.31.1 of google-api-client to run version " + "1.31.0 of the Cloud Functions API library.", com.google.api.client.googleapis.GoogleUtils.VERSION); } /** * The default encoded root URL of the service. This is determined when the library is generated * and normally should not be changed. * * @since 1.7 */ public static final String DEFAULT_ROOT_URL = "https://cloudfunctions.googleapis.com/"; /** * The default encoded mTLS root URL of the service. This is determined when the library is generated * and normally should not be changed. * * @since 1.31 */ public static final String DEFAULT_MTLS_ROOT_URL = "https://cloudfunctions.mtls.googleapis.com/"; /** * The default encoded service path of the service. This is determined when the library is * generated and normally should not be changed. * * @since 1.7 */ public static final String DEFAULT_SERVICE_PATH = ""; /** * The default encoded batch path of the service. This is determined when the library is * generated and normally should not be changed. * * @since 1.23 */ public static final String DEFAULT_BATCH_PATH = "batch"; /** * The default encoded base URL of the service. This is determined when the library is generated * and normally should not be changed. */ public static final String DEFAULT_BASE_URL = DEFAULT_ROOT_URL + DEFAULT_SERVICE_PATH; /** * Constructor. * * <p> * Use {@link Builder} if you need to specify any of the optional parameters. * </p> * * @param transport HTTP transport, which should normally be: * <ul> * <li>Google App Engine: * {@code com.google.api.client.extensions.appengine.http.UrlFetchTransport}</li> * <li>Android: {@code newCompatibleTransport} from * {@code com.google.api.client.extensions.android.http.AndroidHttp}</li> * <li>Java: {@link com.google.api.client.googleapis.javanet.GoogleNetHttpTransport#newTrustedTransport()} * </li> * </ul> * @param jsonFactory JSON factory, which may be: * <ul> * <li>Jackson: {@code com.google.api.client.json.jackson2.JacksonFactory}</li> * <li>Google GSON: {@code com.google.api.client.json.gson.GsonFactory}</li> * <li>Android Honeycomb or higher: * {@code com.google.api.client.extensions.android.json.AndroidJsonFactory}</li> * </ul> * @param httpRequestInitializer HTTP request initializer or {@code null} for none * @since 1.7 */ public CloudFunctions(com.google.api.client.http.HttpTransport transport, com.google.api.client.json.JsonFactory jsonFactory, com.google.api.client.http.HttpRequestInitializer httpRequestInitializer) { this(new Builder(transport, jsonFactory, httpRequestInitializer)); } /** * @param builder builder */ CloudFunctions(Builder builder) { super(builder); } @Override protected void initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest<?> httpClientRequest) throws java.io.IOException { super.initialize(httpClientRequest); } /** * An accessor for creating requests from the Operations collection. * * <p>The typical use is:</p> * <pre> * {@code CloudFunctions cloudfunctions = new CloudFunctions(...);} * {@code CloudFunctions.Operations.List request = cloudfunctions.operations().list(parameters ...)} * </pre> * * @return the resource collection */ public Operations operations() { return new Operations(); } /** * The "operations" collection of methods. */ public class Operations { /** * Gets the latest state of a long-running operation. Clients can use this method to poll the * operation result at intervals as recommended by the API service. * * Create a request for the method "operations.get". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link Get#execute()} method to invoke the remote operation. * * @param name The name of the operation resource. * @return the request */ public Get get(java.lang.String name) throws java.io.IOException { Get result = new Get(name); initialize(result); return result; } public class Get extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.Operation> { private static final String REST_PATH = "v1/{+name}"; private final java.util.regex.Pattern NAME_PATTERN = java.util.regex.Pattern.compile("^operations/[^/]+$"); /** * Gets the latest state of a long-running operation. Clients can use this method to poll the * operation result at intervals as recommended by the API service. * * Create a request for the method "operations.get". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p> * {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @param name The name of the operation resource. * @since 1.13 */ protected Get(java.lang.String name) { super(CloudFunctions.this, "GET", REST_PATH, null, com.google.api.services.cloudfunctions.v1.model.Operation.class); this.name = com.google.api.client.util.Preconditions.checkNotNull(name, "Required parameter name must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^operations/[^/]+$"); } } @Override public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException { return super.executeUsingHead(); } @Override public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException { return super.buildHttpRequestUsingHead(); } @Override public Get set$Xgafv(java.lang.String $Xgafv) { return (Get) super.set$Xgafv($Xgafv); } @Override public Get setAccessToken(java.lang.String accessToken) { return (Get) super.setAccessToken(accessToken); } @Override public Get setAlt(java.lang.String alt) { return (Get) super.setAlt(alt); } @Override public Get setCallback(java.lang.String callback) { return (Get) super.setCallback(callback); } @Override public Get setFields(java.lang.String fields) { return (Get) super.setFields(fields); } @Override public Get setKey(java.lang.String key) { return (Get) super.setKey(key); } @Override public Get setOauthToken(java.lang.String oauthToken) { return (Get) super.setOauthToken(oauthToken); } @Override public Get setPrettyPrint(java.lang.Boolean prettyPrint) { return (Get) super.setPrettyPrint(prettyPrint); } @Override public Get setQuotaUser(java.lang.String quotaUser) { return (Get) super.setQuotaUser(quotaUser); } @Override public Get setUploadType(java.lang.String uploadType) { return (Get) super.setUploadType(uploadType); } @Override public Get setUploadProtocol(java.lang.String uploadProtocol) { return (Get) super.setUploadProtocol(uploadProtocol); } /** The name of the operation resource. */ @com.google.api.client.util.Key private java.lang.String name; /** The name of the operation resource. */ public java.lang.String getName() { return name; } /** The name of the operation resource. */ public Get setName(java.lang.String name) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^operations/[^/]+$"); } this.name = name; return this; } @Override public Get set(String parameterName, Object value) { return (Get) super.set(parameterName, value); } } /** * Lists operations that match the specified filter in the request. If the server doesn't support * this method, it returns `UNIMPLEMENTED`. NOTE: the `name` binding allows API services to override * the binding to use different resource name schemes, such as `users/operations`. To override the * binding, API services can add a binding such as `"/v1/{name=users}/operations"` to their service * configuration. For backwards compatibility, the default name includes the operations collection * id, however overriding users must ensure the name binding is the parent resource, without the * operations collection id. * * Create a request for the method "operations.list". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link List#execute()} method to invoke the remote operation. * * @return the request */ public List list() throws java.io.IOException { List result = new List(); initialize(result); return result; } public class List extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.ListOperationsResponse> { private static final String REST_PATH = "v1/operations"; /** * Lists operations that match the specified filter in the request. If the server doesn't support * this method, it returns `UNIMPLEMENTED`. NOTE: the `name` binding allows API services to * override the binding to use different resource name schemes, such as `users/operations`. To * override the binding, API services can add a binding such as `"/v1/{name=users}/operations"` to * their service configuration. For backwards compatibility, the default name includes the * operations collection id, however overriding users must ensure the name binding is the parent * resource, without the operations collection id. * * Create a request for the method "operations.list". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p> * {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @since 1.13 */ protected List() { super(CloudFunctions.this, "GET", REST_PATH, null, com.google.api.services.cloudfunctions.v1.model.ListOperationsResponse.class); } @Override public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException { return super.executeUsingHead(); } @Override public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException { return super.buildHttpRequestUsingHead(); } @Override public List set$Xgafv(java.lang.String $Xgafv) { return (List) super.set$Xgafv($Xgafv); } @Override public List setAccessToken(java.lang.String accessToken) { return (List) super.setAccessToken(accessToken); } @Override public List setAlt(java.lang.String alt) { return (List) super.setAlt(alt); } @Override public List setCallback(java.lang.String callback) { return (List) super.setCallback(callback); } @Override public List setFields(java.lang.String fields) { return (List) super.setFields(fields); } @Override public List setKey(java.lang.String key) { return (List) super.setKey(key); } @Override public List setOauthToken(java.lang.String oauthToken) { return (List) super.setOauthToken(oauthToken); } @Override public List setPrettyPrint(java.lang.Boolean prettyPrint) { return (List) super.setPrettyPrint(prettyPrint); } @Override public List setQuotaUser(java.lang.String quotaUser) { return (List) super.setQuotaUser(quotaUser); } @Override public List setUploadType(java.lang.String uploadType) { return (List) super.setUploadType(uploadType); } @Override public List setUploadProtocol(java.lang.String uploadProtocol) { return (List) super.setUploadProtocol(uploadProtocol); } /** * Required. A filter for matching the requested operations. The supported formats of *filter* * are: To query for a specific function: project:*,location:*,function:* To query for all of * the latest operations for a project: project:*,latest:true */ @com.google.api.client.util.Key private java.lang.String filter; /** Required. A filter for matching the requested operations. The supported formats of *filter* are: To query for a specific function: project:*,location:*,function:* To query for all of the latest operations for a project: project:*,latest:true */ public java.lang.String getFilter() { return filter; } /** * Required. A filter for matching the requested operations. The supported formats of *filter* * are: To query for a specific function: project:*,location:*,function:* To query for all of * the latest operations for a project: project:*,latest:true */ public List setFilter(java.lang.String filter) { this.filter = filter; return this; } /** Must not be set. */ @com.google.api.client.util.Key private java.lang.String name; /** Must not be set. */ public java.lang.String getName() { return name; } /** Must not be set. */ public List setName(java.lang.String name) { this.name = name; return this; } /** * The maximum number of records that should be returned. Requested page size cannot exceed * 100. If not set, the default page size is 100. Pagination is only supported when querying * for a specific function. */ @com.google.api.client.util.Key private java.lang.Integer pageSize; /** The maximum number of records that should be returned. Requested page size cannot exceed 100. If not set, the default page size is 100. Pagination is only supported when querying for a specific function. */ public java.lang.Integer getPageSize() { return pageSize; } /** * The maximum number of records that should be returned. Requested page size cannot exceed * 100. If not set, the default page size is 100. Pagination is only supported when querying * for a specific function. */ public List setPageSize(java.lang.Integer pageSize) { this.pageSize = pageSize; return this; } /** * Token identifying which result to start with, which is returned by a previous list call. * Pagination is only supported when querying for a specific function. */ @com.google.api.client.util.Key private java.lang.String pageToken; /** Token identifying which result to start with, which is returned by a previous list call. Pagination is only supported when querying for a specific function. */ public java.lang.String getPageToken() { return pageToken; } /** * Token identifying which result to start with, which is returned by a previous list call. * Pagination is only supported when querying for a specific function. */ public List setPageToken(java.lang.String pageToken) { this.pageToken = pageToken; return this; } @Override public List set(String parameterName, Object value) { return (List) super.set(parameterName, value); } } } /** * An accessor for creating requests from the Projects collection. * * <p>The typical use is:</p> * <pre> * {@code CloudFunctions cloudfunctions = new CloudFunctions(...);} * {@code CloudFunctions.Projects.List request = cloudfunctions.projects().list(parameters ...)} * </pre> * * @return the resource collection */ public Projects projects() { return new Projects(); } /** * The "projects" collection of methods. */ public class Projects { /** * An accessor for creating requests from the Locations collection. * * <p>The typical use is:</p> * <pre> * {@code CloudFunctions cloudfunctions = new CloudFunctions(...);} * {@code CloudFunctions.Locations.List request = cloudfunctions.locations().list(parameters ...)} * </pre> * * @return the resource collection */ public Locations locations() { return new Locations(); } /** * The "locations" collection of methods. */ public class Locations { /** * Lists information about the supported locations for this service. * * Create a request for the method "locations.list". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link List#execute()} method to invoke the remote operation. * * @param name The resource that owns the locations collection, if applicable. * @return the request */ public List list(java.lang.String name) throws java.io.IOException { List result = new List(name); initialize(result); return result; } public class List extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.ListLocationsResponse> { private static final String REST_PATH = "v1/{+name}/locations"; private final java.util.regex.Pattern NAME_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+$"); /** * Lists information about the supported locations for this service. * * Create a request for the method "locations.list". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p> * {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @param name The resource that owns the locations collection, if applicable. * @since 1.13 */ protected List(java.lang.String name) { super(CloudFunctions.this, "GET", REST_PATH, null, com.google.api.services.cloudfunctions.v1.model.ListLocationsResponse.class); this.name = com.google.api.client.util.Preconditions.checkNotNull(name, "Required parameter name must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+$"); } } @Override public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException { return super.executeUsingHead(); } @Override public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException { return super.buildHttpRequestUsingHead(); } @Override public List set$Xgafv(java.lang.String $Xgafv) { return (List) super.set$Xgafv($Xgafv); } @Override public List setAccessToken(java.lang.String accessToken) { return (List) super.setAccessToken(accessToken); } @Override public List setAlt(java.lang.String alt) { return (List) super.setAlt(alt); } @Override public List setCallback(java.lang.String callback) { return (List) super.setCallback(callback); } @Override public List setFields(java.lang.String fields) { return (List) super.setFields(fields); } @Override public List setKey(java.lang.String key) { return (List) super.setKey(key); } @Override public List setOauthToken(java.lang.String oauthToken) { return (List) super.setOauthToken(oauthToken); } @Override public List setPrettyPrint(java.lang.Boolean prettyPrint) { return (List) super.setPrettyPrint(prettyPrint); } @Override public List setQuotaUser(java.lang.String quotaUser) { return (List) super.setQuotaUser(quotaUser); } @Override public List setUploadType(java.lang.String uploadType) { return (List) super.setUploadType(uploadType); } @Override public List setUploadProtocol(java.lang.String uploadProtocol) { return (List) super.setUploadProtocol(uploadProtocol); } /** The resource that owns the locations collection, if applicable. */ @com.google.api.client.util.Key private java.lang.String name; /** The resource that owns the locations collection, if applicable. */ public java.lang.String getName() { return name; } /** The resource that owns the locations collection, if applicable. */ public List setName(java.lang.String name) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+$"); } this.name = name; return this; } /** The standard list filter. */ @com.google.api.client.util.Key private java.lang.String filter; /** The standard list filter. */ public java.lang.String getFilter() { return filter; } /** The standard list filter. */ public List setFilter(java.lang.String filter) { this.filter = filter; return this; } /** The standard list page size. */ @com.google.api.client.util.Key private java.lang.Integer pageSize; /** The standard list page size. */ public java.lang.Integer getPageSize() { return pageSize; } /** The standard list page size. */ public List setPageSize(java.lang.Integer pageSize) { this.pageSize = pageSize; return this; } /** The standard list page token. */ @com.google.api.client.util.Key private java.lang.String pageToken; /** The standard list page token. */ public java.lang.String getPageToken() { return pageToken; } /** The standard list page token. */ public List setPageToken(java.lang.String pageToken) { this.pageToken = pageToken; return this; } @Override public List set(String parameterName, Object value) { return (List) super.set(parameterName, value); } } /** * An accessor for creating requests from the Functions collection. * * <p>The typical use is:</p> * <pre> * {@code CloudFunctions cloudfunctions = new CloudFunctions(...);} * {@code CloudFunctions.Functions.List request = cloudfunctions.functions().list(parameters ...)} * </pre> * * @return the resource collection */ public Functions functions() { return new Functions(); } /** * The "functions" collection of methods. */ public class Functions { /** * Synchronously invokes a deployed Cloud Function. To be used for testing purposes as very limited * traffic is allowed. For more information on the actual limits, refer to [Rate * Limits](https://cloud.google.com/functions/quotas#rate_limits). * * Create a request for the method "functions.call". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link Call#execute()} method to invoke the remote operation. * * @param name Required. The name of the function to be called. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.CallFunctionRequest} * @return the request */ public Call call(java.lang.String name, com.google.api.services.cloudfunctions.v1.model.CallFunctionRequest content) throws java.io.IOException { Call result = new Call(name, content); initialize(result); return result; } public class Call extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.CallFunctionResponse> { private static final String REST_PATH = "v1/{+name}:call"; private final java.util.regex.Pattern NAME_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Synchronously invokes a deployed Cloud Function. To be used for testing purposes as very * limited traffic is allowed. For more information on the actual limits, refer to [Rate * Limits](https://cloud.google.com/functions/quotas#rate_limits). * * Create a request for the method "functions.call". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link Call#execute()} method to invoke the remote operation. <p> * {@link Call#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @param name Required. The name of the function to be called. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.CallFunctionRequest} * @since 1.13 */ protected Call(java.lang.String name, com.google.api.services.cloudfunctions.v1.model.CallFunctionRequest content) { super(CloudFunctions.this, "POST", REST_PATH, content, com.google.api.services.cloudfunctions.v1.model.CallFunctionResponse.class); this.name = com.google.api.client.util.Preconditions.checkNotNull(name, "Required parameter name must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public Call set$Xgafv(java.lang.String $Xgafv) { return (Call) super.set$Xgafv($Xgafv); } @Override public Call setAccessToken(java.lang.String accessToken) { return (Call) super.setAccessToken(accessToken); } @Override public Call setAlt(java.lang.String alt) { return (Call) super.setAlt(alt); } @Override public Call setCallback(java.lang.String callback) { return (Call) super.setCallback(callback); } @Override public Call setFields(java.lang.String fields) { return (Call) super.setFields(fields); } @Override public Call setKey(java.lang.String key) { return (Call) super.setKey(key); } @Override public Call setOauthToken(java.lang.String oauthToken) { return (Call) super.setOauthToken(oauthToken); } @Override public Call setPrettyPrint(java.lang.Boolean prettyPrint) { return (Call) super.setPrettyPrint(prettyPrint); } @Override public Call setQuotaUser(java.lang.String quotaUser) { return (Call) super.setQuotaUser(quotaUser); } @Override public Call setUploadType(java.lang.String uploadType) { return (Call) super.setUploadType(uploadType); } @Override public Call setUploadProtocol(java.lang.String uploadProtocol) { return (Call) super.setUploadProtocol(uploadProtocol); } /** Required. The name of the function to be called. */ @com.google.api.client.util.Key private java.lang.String name; /** Required. The name of the function to be called. */ public java.lang.String getName() { return name; } /** Required. The name of the function to be called. */ public Call setName(java.lang.String name) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.name = name; return this; } @Override public Call set(String parameterName, Object value) { return (Call) super.set(parameterName, value); } } /** * Creates a new function. If a function with the given name already exists in the specified * project, the long running operation will return `ALREADY_EXISTS` error. * * Create a request for the method "functions.create". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link Create#execute()} method to invoke the remote operation. * * @param location Required. The project and location in which the function should be created, specified in the format * `projects/locations` * @param content the {@link com.google.api.services.cloudfunctions.v1.model.CloudFunction} * @return the request */ public Create create(java.lang.String location, com.google.api.services.cloudfunctions.v1.model.CloudFunction content) throws java.io.IOException { Create result = new Create(location, content); initialize(result); return result; } public class Create extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.Operation> { private static final String REST_PATH = "v1/{+location}/functions"; private final java.util.regex.Pattern LOCATION_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+$"); /** * Creates a new function. If a function with the given name already exists in the specified * project, the long running operation will return `ALREADY_EXISTS` error. * * Create a request for the method "functions.create". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link Create#execute()} method to invoke the remote operation. * <p> {@link * Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must * be called to initialize this instance immediately after invoking the constructor. </p> * * @param location Required. The project and location in which the function should be created, specified in the format * `projects/locations` * @param content the {@link com.google.api.services.cloudfunctions.v1.model.CloudFunction} * @since 1.13 */ protected Create(java.lang.String location, com.google.api.services.cloudfunctions.v1.model.CloudFunction content) { super(CloudFunctions.this, "POST", REST_PATH, content, com.google.api.services.cloudfunctions.v1.model.Operation.class); this.location = com.google.api.client.util.Preconditions.checkNotNull(location, "Required parameter location must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(LOCATION_PATTERN.matcher(location).matches(), "Parameter location must conform to the pattern " + "^projects/[^/]+/locations/[^/]+$"); } } @Override public Create set$Xgafv(java.lang.String $Xgafv) { return (Create) super.set$Xgafv($Xgafv); } @Override public Create setAccessToken(java.lang.String accessToken) { return (Create) super.setAccessToken(accessToken); } @Override public Create setAlt(java.lang.String alt) { return (Create) super.setAlt(alt); } @Override public Create setCallback(java.lang.String callback) { return (Create) super.setCallback(callback); } @Override public Create setFields(java.lang.String fields) { return (Create) super.setFields(fields); } @Override public Create setKey(java.lang.String key) { return (Create) super.setKey(key); } @Override public Create setOauthToken(java.lang.String oauthToken) { return (Create) super.setOauthToken(oauthToken); } @Override public Create setPrettyPrint(java.lang.Boolean prettyPrint) { return (Create) super.setPrettyPrint(prettyPrint); } @Override public Create setQuotaUser(java.lang.String quotaUser) { return (Create) super.setQuotaUser(quotaUser); } @Override public Create setUploadType(java.lang.String uploadType) { return (Create) super.setUploadType(uploadType); } @Override public Create setUploadProtocol(java.lang.String uploadProtocol) { return (Create) super.setUploadProtocol(uploadProtocol); } /** * Required. The project and location in which the function should be created, specified * in the format `projects/locations` */ @com.google.api.client.util.Key private java.lang.String location; /** Required. The project and location in which the function should be created, specified in the format `projects/locations` */ public java.lang.String getLocation() { return location; } /** * Required. The project and location in which the function should be created, specified * in the format `projects/locations` */ public Create setLocation(java.lang.String location) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(LOCATION_PATTERN.matcher(location).matches(), "Parameter location must conform to the pattern " + "^projects/[^/]+/locations/[^/]+$"); } this.location = location; return this; } @Override public Create set(String parameterName, Object value) { return (Create) super.set(parameterName, value); } } /** * Deletes a function with the given name from the specified project. If the given function is used * by some trigger, the trigger will be updated to remove this function. * * Create a request for the method "functions.delete". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link Delete#execute()} method to invoke the remote operation. * * @param name Required. The name of the function which should be deleted. * @return the request */ public Delete delete(java.lang.String name) throws java.io.IOException { Delete result = new Delete(name); initialize(result); return result; } public class Delete extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.Operation> { private static final String REST_PATH = "v1/{+name}"; private final java.util.regex.Pattern NAME_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Deletes a function with the given name from the specified project. If the given function is * used by some trigger, the trigger will be updated to remove this function. * * Create a request for the method "functions.delete". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link Delete#execute()} method to invoke the remote operation. * <p> {@link * Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must * be called to initialize this instance immediately after invoking the constructor. </p> * * @param name Required. The name of the function which should be deleted. * @since 1.13 */ protected Delete(java.lang.String name) { super(CloudFunctions.this, "DELETE", REST_PATH, null, com.google.api.services.cloudfunctions.v1.model.Operation.class); this.name = com.google.api.client.util.Preconditions.checkNotNull(name, "Required parameter name must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public Delete set$Xgafv(java.lang.String $Xgafv) { return (Delete) super.set$Xgafv($Xgafv); } @Override public Delete setAccessToken(java.lang.String accessToken) { return (Delete) super.setAccessToken(accessToken); } @Override public Delete setAlt(java.lang.String alt) { return (Delete) super.setAlt(alt); } @Override public Delete setCallback(java.lang.String callback) { return (Delete) super.setCallback(callback); } @Override public Delete setFields(java.lang.String fields) { return (Delete) super.setFields(fields); } @Override public Delete setKey(java.lang.String key) { return (Delete) super.setKey(key); } @Override public Delete setOauthToken(java.lang.String oauthToken) { return (Delete) super.setOauthToken(oauthToken); } @Override public Delete setPrettyPrint(java.lang.Boolean prettyPrint) { return (Delete) super.setPrettyPrint(prettyPrint); } @Override public Delete setQuotaUser(java.lang.String quotaUser) { return (Delete) super.setQuotaUser(quotaUser); } @Override public Delete setUploadType(java.lang.String uploadType) { return (Delete) super.setUploadType(uploadType); } @Override public Delete setUploadProtocol(java.lang.String uploadProtocol) { return (Delete) super.setUploadProtocol(uploadProtocol); } /** Required. The name of the function which should be deleted. */ @com.google.api.client.util.Key private java.lang.String name; /** Required. The name of the function which should be deleted. */ public java.lang.String getName() { return name; } /** Required. The name of the function which should be deleted. */ public Delete setName(java.lang.String name) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.name = name; return this; } @Override public Delete set(String parameterName, Object value) { return (Delete) super.set(parameterName, value); } } /** * Returns a signed URL for downloading deployed function source code. The URL is only valid for a * limited period and should be used within minutes after generation. For more information about the * signed URL usage see: https://cloud.google.com/storage/docs/access-control/signed-urls * * Create a request for the method "functions.generateDownloadUrl". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link GenerateDownloadUrl#execute()} method to invoke the remote * operation. * * @param name The name of function for which source code Google Cloud Storage signed URL should be generated. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.GenerateDownloadUrlRequest} * @return the request */ public GenerateDownloadUrl generateDownloadUrl(java.lang.String name, com.google.api.services.cloudfunctions.v1.model.GenerateDownloadUrlRequest content) throws java.io.IOException { GenerateDownloadUrl result = new GenerateDownloadUrl(name, content); initialize(result); return result; } public class GenerateDownloadUrl extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.GenerateDownloadUrlResponse> { private static final String REST_PATH = "v1/{+name}:generateDownloadUrl"; private final java.util.regex.Pattern NAME_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Returns a signed URL for downloading deployed function source code. The URL is only valid for a * limited period and should be used within minutes after generation. For more information about * the signed URL usage see: https://cloud.google.com/storage/docs/access-control/signed-urls * * Create a request for the method "functions.generateDownloadUrl". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link GenerateDownloadUrl#execute()} method to invoke the remote * operation. <p> {@link GenerateDownloadUrl#initialize(com.google.api.client.googleapis.services. * AbstractGoogleClientRequest)} must be called to initialize this instance immediately after * invoking the constructor. </p> * * @param name The name of function for which source code Google Cloud Storage signed URL should be generated. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.GenerateDownloadUrlRequest} * @since 1.13 */ protected GenerateDownloadUrl(java.lang.String name, com.google.api.services.cloudfunctions.v1.model.GenerateDownloadUrlRequest content) { super(CloudFunctions.this, "POST", REST_PATH, content, com.google.api.services.cloudfunctions.v1.model.GenerateDownloadUrlResponse.class); this.name = com.google.api.client.util.Preconditions.checkNotNull(name, "Required parameter name must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public GenerateDownloadUrl set$Xgafv(java.lang.String $Xgafv) { return (GenerateDownloadUrl) super.set$Xgafv($Xgafv); } @Override public GenerateDownloadUrl setAccessToken(java.lang.String accessToken) { return (GenerateDownloadUrl) super.setAccessToken(accessToken); } @Override public GenerateDownloadUrl setAlt(java.lang.String alt) { return (GenerateDownloadUrl) super.setAlt(alt); } @Override public GenerateDownloadUrl setCallback(java.lang.String callback) { return (GenerateDownloadUrl) super.setCallback(callback); } @Override public GenerateDownloadUrl setFields(java.lang.String fields) { return (GenerateDownloadUrl) super.setFields(fields); } @Override public GenerateDownloadUrl setKey(java.lang.String key) { return (GenerateDownloadUrl) super.setKey(key); } @Override public GenerateDownloadUrl setOauthToken(java.lang.String oauthToken) { return (GenerateDownloadUrl) super.setOauthToken(oauthToken); } @Override public GenerateDownloadUrl setPrettyPrint(java.lang.Boolean prettyPrint) { return (GenerateDownloadUrl) super.setPrettyPrint(prettyPrint); } @Override public GenerateDownloadUrl setQuotaUser(java.lang.String quotaUser) { return (GenerateDownloadUrl) super.setQuotaUser(quotaUser); } @Override public GenerateDownloadUrl setUploadType(java.lang.String uploadType) { return (GenerateDownloadUrl) super.setUploadType(uploadType); } @Override public GenerateDownloadUrl setUploadProtocol(java.lang.String uploadProtocol) { return (GenerateDownloadUrl) super.setUploadProtocol(uploadProtocol); } /** * The name of function for which source code Google Cloud Storage signed URL should be * generated. */ @com.google.api.client.util.Key private java.lang.String name; /** The name of function for which source code Google Cloud Storage signed URL should be generated. */ public java.lang.String getName() { return name; } /** * The name of function for which source code Google Cloud Storage signed URL should be * generated. */ public GenerateDownloadUrl setName(java.lang.String name) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.name = name; return this; } @Override public GenerateDownloadUrl set(String parameterName, Object value) { return (GenerateDownloadUrl) super.set(parameterName, value); } } /** * Returns a signed URL for uploading a function source code. For more information about the signed * URL usage see: https://cloud.google.com/storage/docs/access-control/signed-urls. Once the * function source code upload is complete, the used signed URL should be provided in CreateFunction * or UpdateFunction request as a reference to the function source code. When uploading source code * to the generated signed URL, please follow these restrictions: * Source file type should be a zip * file. * Source file size should not exceed 100MB limit. * No credentials should be attached - the * signed URLs provide access to the target bucket using internal service identity; if credentials * were attached, the identity from the credentials would be used, but that identity does not have * permissions to upload files to the URL. When making a HTTP PUT request, these two headers need to * be specified: * `content-type: application/zip` * `x-goog-content-length-range: 0,104857600` And * this header SHOULD NOT be specified: * `Authorization: Bearer YOUR_TOKEN` * * Create a request for the method "functions.generateUploadUrl". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link GenerateUploadUrl#execute()} method to invoke the remote * operation. * * @param parent The project and location in which the Google Cloud Storage signed URL should be generated, specified * in the format `projects/locations`. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.GenerateUploadUrlRequest} * @return the request */ public GenerateUploadUrl generateUploadUrl(java.lang.String parent, com.google.api.services.cloudfunctions.v1.model.GenerateUploadUrlRequest content) throws java.io.IOException { GenerateUploadUrl result = new GenerateUploadUrl(parent, content); initialize(result); return result; } public class GenerateUploadUrl extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.GenerateUploadUrlResponse> { private static final String REST_PATH = "v1/{+parent}/functions:generateUploadUrl"; private final java.util.regex.Pattern PARENT_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+$"); /** * Returns a signed URL for uploading a function source code. For more information about the * signed URL usage see: https://cloud.google.com/storage/docs/access-control/signed-urls. Once * the function source code upload is complete, the used signed URL should be provided in * CreateFunction or UpdateFunction request as a reference to the function source code. When * uploading source code to the generated signed URL, please follow these restrictions: * Source * file type should be a zip file. * Source file size should not exceed 100MB limit. * No * credentials should be attached - the signed URLs provide access to the target bucket using * internal service identity; if credentials were attached, the identity from the credentials * would be used, but that identity does not have permissions to upload files to the URL. When * making a HTTP PUT request, these two headers need to be specified: * `content-type: * application/zip` * `x-goog-content-length-range: 0,104857600` And this header SHOULD NOT be * specified: * `Authorization: Bearer YOUR_TOKEN` * * Create a request for the method "functions.generateUploadUrl". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link GenerateUploadUrl#execute()} method to invoke the remote * operation. <p> {@link GenerateUploadUrl#initialize(com.google.api.client.googleapis.services.Ab * stractGoogleClientRequest)} must be called to initialize this instance immediately after * invoking the constructor. </p> * * @param parent The project and location in which the Google Cloud Storage signed URL should be generated, specified * in the format `projects/locations`. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.GenerateUploadUrlRequest} * @since 1.13 */ protected GenerateUploadUrl(java.lang.String parent, com.google.api.services.cloudfunctions.v1.model.GenerateUploadUrlRequest content) { super(CloudFunctions.this, "POST", REST_PATH, content, com.google.api.services.cloudfunctions.v1.model.GenerateUploadUrlResponse.class); this.parent = com.google.api.client.util.Preconditions.checkNotNull(parent, "Required parameter parent must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(PARENT_PATTERN.matcher(parent).matches(), "Parameter parent must conform to the pattern " + "^projects/[^/]+/locations/[^/]+$"); } } @Override public GenerateUploadUrl set$Xgafv(java.lang.String $Xgafv) { return (GenerateUploadUrl) super.set$Xgafv($Xgafv); } @Override public GenerateUploadUrl setAccessToken(java.lang.String accessToken) { return (GenerateUploadUrl) super.setAccessToken(accessToken); } @Override public GenerateUploadUrl setAlt(java.lang.String alt) { return (GenerateUploadUrl) super.setAlt(alt); } @Override public GenerateUploadUrl setCallback(java.lang.String callback) { return (GenerateUploadUrl) super.setCallback(callback); } @Override public GenerateUploadUrl setFields(java.lang.String fields) { return (GenerateUploadUrl) super.setFields(fields); } @Override public GenerateUploadUrl setKey(java.lang.String key) { return (GenerateUploadUrl) super.setKey(key); } @Override public GenerateUploadUrl setOauthToken(java.lang.String oauthToken) { return (GenerateUploadUrl) super.setOauthToken(oauthToken); } @Override public GenerateUploadUrl setPrettyPrint(java.lang.Boolean prettyPrint) { return (GenerateUploadUrl) super.setPrettyPrint(prettyPrint); } @Override public GenerateUploadUrl setQuotaUser(java.lang.String quotaUser) { return (GenerateUploadUrl) super.setQuotaUser(quotaUser); } @Override public GenerateUploadUrl setUploadType(java.lang.String uploadType) { return (GenerateUploadUrl) super.setUploadType(uploadType); } @Override public GenerateUploadUrl setUploadProtocol(java.lang.String uploadProtocol) { return (GenerateUploadUrl) super.setUploadProtocol(uploadProtocol); } /** * The project and location in which the Google Cloud Storage signed URL should be * generated, specified in the format `projects/locations`. */ @com.google.api.client.util.Key private java.lang.String parent; /** The project and location in which the Google Cloud Storage signed URL should be generated, specified in the format `projects/locations`. */ public java.lang.String getParent() { return parent; } /** * The project and location in which the Google Cloud Storage signed URL should be * generated, specified in the format `projects/locations`. */ public GenerateUploadUrl setParent(java.lang.String parent) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(PARENT_PATTERN.matcher(parent).matches(), "Parameter parent must conform to the pattern " + "^projects/[^/]+/locations/[^/]+$"); } this.parent = parent; return this; } @Override public GenerateUploadUrl set(String parameterName, Object value) { return (GenerateUploadUrl) super.set(parameterName, value); } } /** * Returns a function with the given name from the requested project. * * Create a request for the method "functions.get". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link Get#execute()} method to invoke the remote operation. * * @param name Required. The name of the function which details should be obtained. * @return the request */ public Get get(java.lang.String name) throws java.io.IOException { Get result = new Get(name); initialize(result); return result; } public class Get extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.CloudFunction> { private static final String REST_PATH = "v1/{+name}"; private final java.util.regex.Pattern NAME_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Returns a function with the given name from the requested project. * * Create a request for the method "functions.get". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p> * {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @param name Required. The name of the function which details should be obtained. * @since 1.13 */ protected Get(java.lang.String name) { super(CloudFunctions.this, "GET", REST_PATH, null, com.google.api.services.cloudfunctions.v1.model.CloudFunction.class); this.name = com.google.api.client.util.Preconditions.checkNotNull(name, "Required parameter name must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException { return super.executeUsingHead(); } @Override public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException { return super.buildHttpRequestUsingHead(); } @Override public Get set$Xgafv(java.lang.String $Xgafv) { return (Get) super.set$Xgafv($Xgafv); } @Override public Get setAccessToken(java.lang.String accessToken) { return (Get) super.setAccessToken(accessToken); } @Override public Get setAlt(java.lang.String alt) { return (Get) super.setAlt(alt); } @Override public Get setCallback(java.lang.String callback) { return (Get) super.setCallback(callback); } @Override public Get setFields(java.lang.String fields) { return (Get) super.setFields(fields); } @Override public Get setKey(java.lang.String key) { return (Get) super.setKey(key); } @Override public Get setOauthToken(java.lang.String oauthToken) { return (Get) super.setOauthToken(oauthToken); } @Override public Get setPrettyPrint(java.lang.Boolean prettyPrint) { return (Get) super.setPrettyPrint(prettyPrint); } @Override public Get setQuotaUser(java.lang.String quotaUser) { return (Get) super.setQuotaUser(quotaUser); } @Override public Get setUploadType(java.lang.String uploadType) { return (Get) super.setUploadType(uploadType); } @Override public Get setUploadProtocol(java.lang.String uploadProtocol) { return (Get) super.setUploadProtocol(uploadProtocol); } /** Required. The name of the function which details should be obtained. */ @com.google.api.client.util.Key private java.lang.String name; /** Required. The name of the function which details should be obtained. */ public java.lang.String getName() { return name; } /** Required. The name of the function which details should be obtained. */ public Get setName(java.lang.String name) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.name = name; return this; } @Override public Get set(String parameterName, Object value) { return (Get) super.set(parameterName, value); } } /** * Gets the IAM access control policy for a function. Returns an empty policy if the function exists * and does not have a policy set. * * Create a request for the method "functions.getIamPolicy". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link GetIamPolicy#execute()} method to invoke the remote * operation. * * @param resource REQUIRED: The resource for which the policy is being requested. See the operation documentation for * the appropriate value for this field. * @return the request */ public GetIamPolicy getIamPolicy(java.lang.String resource) throws java.io.IOException { GetIamPolicy result = new GetIamPolicy(resource); initialize(result); return result; } public class GetIamPolicy extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.Policy> { private static final String REST_PATH = "v1/{+resource}:getIamPolicy"; private final java.util.regex.Pattern RESOURCE_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Gets the IAM access control policy for a function. Returns an empty policy if the function * exists and does not have a policy set. * * Create a request for the method "functions.getIamPolicy". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link GetIamPolicy#execute()} method to invoke the remote * operation. <p> {@link * GetIamPolicy#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @param resource REQUIRED: The resource for which the policy is being requested. See the operation documentation for * the appropriate value for this field. * @since 1.13 */ protected GetIamPolicy(java.lang.String resource) { super(CloudFunctions.this, "GET", REST_PATH, null, com.google.api.services.cloudfunctions.v1.model.Policy.class); this.resource = com.google.api.client.util.Preconditions.checkNotNull(resource, "Required parameter resource must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(RESOURCE_PATTERN.matcher(resource).matches(), "Parameter resource must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException { return super.executeUsingHead(); } @Override public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException { return super.buildHttpRequestUsingHead(); } @Override public GetIamPolicy set$Xgafv(java.lang.String $Xgafv) { return (GetIamPolicy) super.set$Xgafv($Xgafv); } @Override public GetIamPolicy setAccessToken(java.lang.String accessToken) { return (GetIamPolicy) super.setAccessToken(accessToken); } @Override public GetIamPolicy setAlt(java.lang.String alt) { return (GetIamPolicy) super.setAlt(alt); } @Override public GetIamPolicy setCallback(java.lang.String callback) { return (GetIamPolicy) super.setCallback(callback); } @Override public GetIamPolicy setFields(java.lang.String fields) { return (GetIamPolicy) super.setFields(fields); } @Override public GetIamPolicy setKey(java.lang.String key) { return (GetIamPolicy) super.setKey(key); } @Override public GetIamPolicy setOauthToken(java.lang.String oauthToken) { return (GetIamPolicy) super.setOauthToken(oauthToken); } @Override public GetIamPolicy setPrettyPrint(java.lang.Boolean prettyPrint) { return (GetIamPolicy) super.setPrettyPrint(prettyPrint); } @Override public GetIamPolicy setQuotaUser(java.lang.String quotaUser) { return (GetIamPolicy) super.setQuotaUser(quotaUser); } @Override public GetIamPolicy setUploadType(java.lang.String uploadType) { return (GetIamPolicy) super.setUploadType(uploadType); } @Override public GetIamPolicy setUploadProtocol(java.lang.String uploadProtocol) { return (GetIamPolicy) super.setUploadProtocol(uploadProtocol); } /** * REQUIRED: The resource for which the policy is being requested. See the operation * documentation for the appropriate value for this field. */ @com.google.api.client.util.Key private java.lang.String resource; /** REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field. */ public java.lang.String getResource() { return resource; } /** * REQUIRED: The resource for which the policy is being requested. See the operation * documentation for the appropriate value for this field. */ public GetIamPolicy setResource(java.lang.String resource) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(RESOURCE_PATTERN.matcher(resource).matches(), "Parameter resource must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.resource = resource; return this; } /** * Optional. The policy format version to be returned. Valid values are 0, 1, and 3. * Requests specifying an invalid value will be rejected. Requests for policies with any * conditional bindings must specify version 3. Policies without any conditional bindings * may specify any valid value or leave the field unset. To learn which resources support * conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ @com.google.api.client.util.Key("options.requestedPolicyVersion") private java.lang.Integer optionsRequestedPolicyVersion; /** Optional. The policy format version to be returned. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional bindings must specify version 3. Policies without any conditional bindings may specify any valid value or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ public java.lang.Integer getOptionsRequestedPolicyVersion() { return optionsRequestedPolicyVersion; } /** * Optional. The policy format version to be returned. Valid values are 0, 1, and 3. * Requests specifying an invalid value will be rejected. Requests for policies with any * conditional bindings must specify version 3. Policies without any conditional bindings * may specify any valid value or leave the field unset. To learn which resources support * conditions in their IAM policies, see the [IAM * documentation](https://cloud.google.com/iam/help/conditions/resource-policies). */ public GetIamPolicy setOptionsRequestedPolicyVersion(java.lang.Integer optionsRequestedPolicyVersion) { this.optionsRequestedPolicyVersion = optionsRequestedPolicyVersion; return this; } @Override public GetIamPolicy set(String parameterName, Object value) { return (GetIamPolicy) super.set(parameterName, value); } } /** * Returns a list of functions that belong to the requested project. * * Create a request for the method "functions.list". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link List#execute()} method to invoke the remote operation. * * @param parent The project and location from which the function should be listed, specified in the format * `projects/locations` If you want to list functions in all locations, use "-" in place of a * location. When listing functions in all locations, if one or more location(s) are * unreachable, the response will contain functions from all reachable locations along with * the names of any unreachable locations. * @return the request */ public List list(java.lang.String parent) throws java.io.IOException { List result = new List(parent); initialize(result); return result; } public class List extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.ListFunctionsResponse> { private static final String REST_PATH = "v1/{+parent}/functions"; private final java.util.regex.Pattern PARENT_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+$"); /** * Returns a list of functions that belong to the requested project. * * Create a request for the method "functions.list". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p> * {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @param parent The project and location from which the function should be listed, specified in the format * `projects/locations` If you want to list functions in all locations, use "-" in place of a * location. When listing functions in all locations, if one or more location(s) are * unreachable, the response will contain functions from all reachable locations along with * the names of any unreachable locations. * @since 1.13 */ protected List(java.lang.String parent) { super(CloudFunctions.this, "GET", REST_PATH, null, com.google.api.services.cloudfunctions.v1.model.ListFunctionsResponse.class); this.parent = com.google.api.client.util.Preconditions.checkNotNull(parent, "Required parameter parent must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(PARENT_PATTERN.matcher(parent).matches(), "Parameter parent must conform to the pattern " + "^projects/[^/]+/locations/[^/]+$"); } } @Override public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException { return super.executeUsingHead(); } @Override public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException { return super.buildHttpRequestUsingHead(); } @Override public List set$Xgafv(java.lang.String $Xgafv) { return (List) super.set$Xgafv($Xgafv); } @Override public List setAccessToken(java.lang.String accessToken) { return (List) super.setAccessToken(accessToken); } @Override public List setAlt(java.lang.String alt) { return (List) super.setAlt(alt); } @Override public List setCallback(java.lang.String callback) { return (List) super.setCallback(callback); } @Override public List setFields(java.lang.String fields) { return (List) super.setFields(fields); } @Override public List setKey(java.lang.String key) { return (List) super.setKey(key); } @Override public List setOauthToken(java.lang.String oauthToken) { return (List) super.setOauthToken(oauthToken); } @Override public List setPrettyPrint(java.lang.Boolean prettyPrint) { return (List) super.setPrettyPrint(prettyPrint); } @Override public List setQuotaUser(java.lang.String quotaUser) { return (List) super.setQuotaUser(quotaUser); } @Override public List setUploadType(java.lang.String uploadType) { return (List) super.setUploadType(uploadType); } @Override public List setUploadProtocol(java.lang.String uploadProtocol) { return (List) super.setUploadProtocol(uploadProtocol); } /** * The project and location from which the function should be listed, specified in the * format `projects/locations` If you want to list functions in all locations, use "-" in * place of a location. When listing functions in all locations, if one or more * location(s) are unreachable, the response will contain functions from all reachable * locations along with the names of any unreachable locations. */ @com.google.api.client.util.Key private java.lang.String parent; /** The project and location from which the function should be listed, specified in the format `projects/locations` If you want to list functions in all locations, use "-" in place of a location. When listing functions in all locations, if one or more location(s) are unreachable, the response will contain functions from all reachable locations along with the names of any unreachable locations. */ public java.lang.String getParent() { return parent; } /** * The project and location from which the function should be listed, specified in the * format `projects/locations` If you want to list functions in all locations, use "-" in * place of a location. When listing functions in all locations, if one or more * location(s) are unreachable, the response will contain functions from all reachable * locations along with the names of any unreachable locations. */ public List setParent(java.lang.String parent) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(PARENT_PATTERN.matcher(parent).matches(), "Parameter parent must conform to the pattern " + "^projects/[^/]+/locations/[^/]+$"); } this.parent = parent; return this; } /** Maximum number of functions to return per call. */ @com.google.api.client.util.Key private java.lang.Integer pageSize; /** Maximum number of functions to return per call. */ public java.lang.Integer getPageSize() { return pageSize; } /** Maximum number of functions to return per call. */ public List setPageSize(java.lang.Integer pageSize) { this.pageSize = pageSize; return this; } /** * The value returned by the last `ListFunctionsResponse`; indicates that this is a * continuation of a prior `ListFunctions` call, and that the system should return the * next page of data. */ @com.google.api.client.util.Key private java.lang.String pageToken; /** The value returned by the last `ListFunctionsResponse`; indicates that this is a continuation of a prior `ListFunctions` call, and that the system should return the next page of data. */ public java.lang.String getPageToken() { return pageToken; } /** * The value returned by the last `ListFunctionsResponse`; indicates that this is a * continuation of a prior `ListFunctions` call, and that the system should return the * next page of data. */ public List setPageToken(java.lang.String pageToken) { this.pageToken = pageToken; return this; } @Override public List set(String parameterName, Object value) { return (List) super.set(parameterName, value); } } /** * Updates existing function. * * Create a request for the method "functions.patch". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link Patch#execute()} method to invoke the remote operation. * * @param name A user-defined name of the function. Function names must be unique globally and match pattern * `projects/locations/functions` * @param content the {@link com.google.api.services.cloudfunctions.v1.model.CloudFunction} * @return the request */ public Patch patch(java.lang.String name, com.google.api.services.cloudfunctions.v1.model.CloudFunction content) throws java.io.IOException { Patch result = new Patch(name, content); initialize(result); return result; } public class Patch extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.Operation> { private static final String REST_PATH = "v1/{+name}"; private final java.util.regex.Pattern NAME_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Updates existing function. * * Create a request for the method "functions.patch". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link Patch#execute()} method to invoke the remote operation. * <p> {@link * Patch#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must * be called to initialize this instance immediately after invoking the constructor. </p> * * @param name A user-defined name of the function. Function names must be unique globally and match pattern * `projects/locations/functions` * @param content the {@link com.google.api.services.cloudfunctions.v1.model.CloudFunction} * @since 1.13 */ protected Patch(java.lang.String name, com.google.api.services.cloudfunctions.v1.model.CloudFunction content) { super(CloudFunctions.this, "PATCH", REST_PATH, content, com.google.api.services.cloudfunctions.v1.model.Operation.class); this.name = com.google.api.client.util.Preconditions.checkNotNull(name, "Required parameter name must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public Patch set$Xgafv(java.lang.String $Xgafv) { return (Patch) super.set$Xgafv($Xgafv); } @Override public Patch setAccessToken(java.lang.String accessToken) { return (Patch) super.setAccessToken(accessToken); } @Override public Patch setAlt(java.lang.String alt) { return (Patch) super.setAlt(alt); } @Override public Patch setCallback(java.lang.String callback) { return (Patch) super.setCallback(callback); } @Override public Patch setFields(java.lang.String fields) { return (Patch) super.setFields(fields); } @Override public Patch setKey(java.lang.String key) { return (Patch) super.setKey(key); } @Override public Patch setOauthToken(java.lang.String oauthToken) { return (Patch) super.setOauthToken(oauthToken); } @Override public Patch setPrettyPrint(java.lang.Boolean prettyPrint) { return (Patch) super.setPrettyPrint(prettyPrint); } @Override public Patch setQuotaUser(java.lang.String quotaUser) { return (Patch) super.setQuotaUser(quotaUser); } @Override public Patch setUploadType(java.lang.String uploadType) { return (Patch) super.setUploadType(uploadType); } @Override public Patch setUploadProtocol(java.lang.String uploadProtocol) { return (Patch) super.setUploadProtocol(uploadProtocol); } /** * A user-defined name of the function. Function names must be unique globally and match * pattern `projects/locations/functions` */ @com.google.api.client.util.Key private java.lang.String name; /** A user-defined name of the function. Function names must be unique globally and match pattern `projects/locations/functions` */ public java.lang.String getName() { return name; } /** * A user-defined name of the function. Function names must be unique globally and match * pattern `projects/locations/functions` */ public Patch setName(java.lang.String name) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(NAME_PATTERN.matcher(name).matches(), "Parameter name must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.name = name; return this; } /** Required list of fields to be updated in this request. */ @com.google.api.client.util.Key private String updateMask; /** Required list of fields to be updated in this request. */ public String getUpdateMask() { return updateMask; } /** Required list of fields to be updated in this request. */ public Patch setUpdateMask(String updateMask) { this.updateMask = updateMask; return this; } @Override public Patch set(String parameterName, Object value) { return (Patch) super.set(parameterName, value); } } /** * Sets the IAM access control policy on the specified function. Replaces any existing policy. * * Create a request for the method "functions.setIamPolicy". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link SetIamPolicy#execute()} method to invoke the remote * operation. * * @param resource REQUIRED: The resource for which the policy is being specified. See the operation documentation for * the appropriate value for this field. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.SetIamPolicyRequest} * @return the request */ public SetIamPolicy setIamPolicy(java.lang.String resource, com.google.api.services.cloudfunctions.v1.model.SetIamPolicyRequest content) throws java.io.IOException { SetIamPolicy result = new SetIamPolicy(resource, content); initialize(result); return result; } public class SetIamPolicy extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.Policy> { private static final String REST_PATH = "v1/{+resource}:setIamPolicy"; private final java.util.regex.Pattern RESOURCE_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Sets the IAM access control policy on the specified function. Replaces any existing policy. * * Create a request for the method "functions.setIamPolicy". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link SetIamPolicy#execute()} method to invoke the remote * operation. <p> {@link * SetIamPolicy#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} * must be called to initialize this instance immediately after invoking the constructor. </p> * * @param resource REQUIRED: The resource for which the policy is being specified. See the operation documentation for * the appropriate value for this field. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.SetIamPolicyRequest} * @since 1.13 */ protected SetIamPolicy(java.lang.String resource, com.google.api.services.cloudfunctions.v1.model.SetIamPolicyRequest content) { super(CloudFunctions.this, "POST", REST_PATH, content, com.google.api.services.cloudfunctions.v1.model.Policy.class); this.resource = com.google.api.client.util.Preconditions.checkNotNull(resource, "Required parameter resource must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(RESOURCE_PATTERN.matcher(resource).matches(), "Parameter resource must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public SetIamPolicy set$Xgafv(java.lang.String $Xgafv) { return (SetIamPolicy) super.set$Xgafv($Xgafv); } @Override public SetIamPolicy setAccessToken(java.lang.String accessToken) { return (SetIamPolicy) super.setAccessToken(accessToken); } @Override public SetIamPolicy setAlt(java.lang.String alt) { return (SetIamPolicy) super.setAlt(alt); } @Override public SetIamPolicy setCallback(java.lang.String callback) { return (SetIamPolicy) super.setCallback(callback); } @Override public SetIamPolicy setFields(java.lang.String fields) { return (SetIamPolicy) super.setFields(fields); } @Override public SetIamPolicy setKey(java.lang.String key) { return (SetIamPolicy) super.setKey(key); } @Override public SetIamPolicy setOauthToken(java.lang.String oauthToken) { return (SetIamPolicy) super.setOauthToken(oauthToken); } @Override public SetIamPolicy setPrettyPrint(java.lang.Boolean prettyPrint) { return (SetIamPolicy) super.setPrettyPrint(prettyPrint); } @Override public SetIamPolicy setQuotaUser(java.lang.String quotaUser) { return (SetIamPolicy) super.setQuotaUser(quotaUser); } @Override public SetIamPolicy setUploadType(java.lang.String uploadType) { return (SetIamPolicy) super.setUploadType(uploadType); } @Override public SetIamPolicy setUploadProtocol(java.lang.String uploadProtocol) { return (SetIamPolicy) super.setUploadProtocol(uploadProtocol); } /** * REQUIRED: The resource for which the policy is being specified. See the operation * documentation for the appropriate value for this field. */ @com.google.api.client.util.Key private java.lang.String resource; /** REQUIRED: The resource for which the policy is being specified. See the operation documentation for the appropriate value for this field. */ public java.lang.String getResource() { return resource; } /** * REQUIRED: The resource for which the policy is being specified. See the operation * documentation for the appropriate value for this field. */ public SetIamPolicy setResource(java.lang.String resource) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(RESOURCE_PATTERN.matcher(resource).matches(), "Parameter resource must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.resource = resource; return this; } @Override public SetIamPolicy set(String parameterName, Object value) { return (SetIamPolicy) super.set(parameterName, value); } } /** * Tests the specified permissions against the IAM access control policy for a function. If the * function does not exist, this will return an empty set of permissions, not a NOT_FOUND error. * * Create a request for the method "functions.testIamPermissions". * * This request holds the parameters needed by the cloudfunctions server. After setting any * optional parameters, call the {@link TestIamPermissions#execute()} method to invoke the remote * operation. * * @param resource REQUIRED: The resource for which the policy detail is being requested. See the operation * documentation for the appropriate value for this field. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.TestIamPermissionsRequest} * @return the request */ public TestIamPermissions testIamPermissions(java.lang.String resource, com.google.api.services.cloudfunctions.v1.model.TestIamPermissionsRequest content) throws java.io.IOException { TestIamPermissions result = new TestIamPermissions(resource, content); initialize(result); return result; } public class TestIamPermissions extends CloudFunctionsRequest<com.google.api.services.cloudfunctions.v1.model.TestIamPermissionsResponse> { private static final String REST_PATH = "v1/{+resource}:testIamPermissions"; private final java.util.regex.Pattern RESOURCE_PATTERN = java.util.regex.Pattern.compile("^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); /** * Tests the specified permissions against the IAM access control policy for a function. If the * function does not exist, this will return an empty set of permissions, not a NOT_FOUND error. * * Create a request for the method "functions.testIamPermissions". * * This request holds the parameters needed by the the cloudfunctions server. After setting any * optional parameters, call the {@link TestIamPermissions#execute()} method to invoke the remote * operation. <p> {@link TestIamPermissions#initialize(com.google.api.client.googleapis.services.A * bstractGoogleClientRequest)} must be called to initialize this instance immediately after * invoking the constructor. </p> * * @param resource REQUIRED: The resource for which the policy detail is being requested. See the operation * documentation for the appropriate value for this field. * @param content the {@link com.google.api.services.cloudfunctions.v1.model.TestIamPermissionsRequest} * @since 1.13 */ protected TestIamPermissions(java.lang.String resource, com.google.api.services.cloudfunctions.v1.model.TestIamPermissionsRequest content) { super(CloudFunctions.this, "POST", REST_PATH, content, com.google.api.services.cloudfunctions.v1.model.TestIamPermissionsResponse.class); this.resource = com.google.api.client.util.Preconditions.checkNotNull(resource, "Required parameter resource must be specified."); if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(RESOURCE_PATTERN.matcher(resource).matches(), "Parameter resource must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } } @Override public TestIamPermissions set$Xgafv(java.lang.String $Xgafv) { return (TestIamPermissions) super.set$Xgafv($Xgafv); } @Override public TestIamPermissions setAccessToken(java.lang.String accessToken) { return (TestIamPermissions) super.setAccessToken(accessToken); } @Override public TestIamPermissions setAlt(java.lang.String alt) { return (TestIamPermissions) super.setAlt(alt); } @Override public TestIamPermissions setCallback(java.lang.String callback) { return (TestIamPermissions) super.setCallback(callback); } @Override public TestIamPermissions setFields(java.lang.String fields) { return (TestIamPermissions) super.setFields(fields); } @Override public TestIamPermissions setKey(java.lang.String key) { return (TestIamPermissions) super.setKey(key); } @Override public TestIamPermissions setOauthToken(java.lang.String oauthToken) { return (TestIamPermissions) super.setOauthToken(oauthToken); } @Override public TestIamPermissions setPrettyPrint(java.lang.Boolean prettyPrint) { return (TestIamPermissions) super.setPrettyPrint(prettyPrint); } @Override public TestIamPermissions setQuotaUser(java.lang.String quotaUser) { return (TestIamPermissions) super.setQuotaUser(quotaUser); } @Override public TestIamPermissions setUploadType(java.lang.String uploadType) { return (TestIamPermissions) super.setUploadType(uploadType); } @Override public TestIamPermissions setUploadProtocol(java.lang.String uploadProtocol) { return (TestIamPermissions) super.setUploadProtocol(uploadProtocol); } /** * REQUIRED: The resource for which the policy detail is being requested. See the * operation documentation for the appropriate value for this field. */ @com.google.api.client.util.Key private java.lang.String resource; /** REQUIRED: The resource for which the policy detail is being requested. See the operation documentation for the appropriate value for this field. */ public java.lang.String getResource() { return resource; } /** * REQUIRED: The resource for which the policy detail is being requested. See the * operation documentation for the appropriate value for this field. */ public TestIamPermissions setResource(java.lang.String resource) { if (!getSuppressPatternChecks()) { com.google.api.client.util.Preconditions.checkArgument(RESOURCE_PATTERN.matcher(resource).matches(), "Parameter resource must conform to the pattern " + "^projects/[^/]+/locations/[^/]+/functions/[^/]+$"); } this.resource = resource; return this; } @Override public TestIamPermissions set(String parameterName, Object value) { return (TestIamPermissions) super.set(parameterName, value); } } } } } /** * Builder for {@link CloudFunctions}. * * <p> * Implementation is not thread-safe. * </p> * * @since 1.3.0 */ public static final class Builder extends com.google.api.client.googleapis.services.json.AbstractGoogleJsonClient.Builder { private static String chooseEndpoint(com.google.api.client.http.HttpTransport transport) { // If the GOOGLE_API_USE_MTLS_ENDPOINT environment variable value is "always", use mTLS endpoint. // If the env variable is "auto", use mTLS endpoint if and only if the transport is mTLS. // Use the regular endpoint for all other cases. String useMtlsEndpoint = System.getenv("GOOGLE_API_USE_MTLS_ENDPOINT"); useMtlsEndpoint = useMtlsEndpoint == null ? "auto" : useMtlsEndpoint; if ("always".equals(useMtlsEndpoint) || ("auto".equals(useMtlsEndpoint) && transport != null && transport.isMtls())) { return DEFAULT_MTLS_ROOT_URL; } return DEFAULT_ROOT_URL; } /** * Returns an instance of a new builder. * * @param transport HTTP transport, which should normally be: * <ul> * <li>Google App Engine: * {@code com.google.api.client.extensions.appengine.http.UrlFetchTransport}</li> * <li>Android: {@code newCompatibleTransport} from * {@code com.google.api.client.extensions.android.http.AndroidHttp}</li> * <li>Java: {@link com.google.api.client.googleapis.javanet.GoogleNetHttpTransport#newTrustedTransport()} * </li> * </ul> * @param jsonFactory JSON factory, which may be: * <ul> * <li>Jackson: {@code com.google.api.client.json.jackson2.JacksonFactory}</li> * <li>Google GSON: {@code com.google.api.client.json.gson.GsonFactory}</li> * <li>Android Honeycomb or higher: * {@code com.google.api.client.extensions.android.json.AndroidJsonFactory}</li> * </ul> * @param httpRequestInitializer HTTP request initializer or {@code null} for none * @since 1.7 */ public Builder(com.google.api.client.http.HttpTransport transport, com.google.api.client.json.JsonFactory jsonFactory, com.google.api.client.http.HttpRequestInitializer httpRequestInitializer) { super( transport, jsonFactory, Builder.chooseEndpoint(transport), DEFAULT_SERVICE_PATH, httpRequestInitializer, false); setBatchPath(DEFAULT_BATCH_PATH); } /** Builds a new instance of {@link CloudFunctions}. */ @Override public CloudFunctions build() { return new CloudFunctions(this); } @Override public Builder setRootUrl(String rootUrl) { return (Builder) super.setRootUrl(rootUrl); } @Override public Builder setServicePath(String servicePath) { return (Builder) super.setServicePath(servicePath); } @Override public Builder setBatchPath(String batchPath) { return (Builder) super.setBatchPath(batchPath); } @Override public Builder setHttpRequestInitializer(com.google.api.client.http.HttpRequestInitializer httpRequestInitializer) { return (Builder) super.setHttpRequestInitializer(httpRequestInitializer); } @Override public Builder setApplicationName(String applicationName) { return (Builder) super.setApplicationName(applicationName); } @Override public Builder setSuppressPatternChecks(boolean suppressPatternChecks) { return (Builder) super.setSuppressPatternChecks(suppressPatternChecks); } @Override public Builder setSuppressRequiredParameterChecks(boolean suppressRequiredParameterChecks) { return (Builder) super.setSuppressRequiredParameterChecks(suppressRequiredParameterChecks); } @Override public Builder setSuppressAllChecks(boolean suppressAllChecks) { return (Builder) super.setSuppressAllChecks(suppressAllChecks); } /** * Set the {@link CloudFunctionsRequestInitializer}. * * @since 1.12 */ public Builder setCloudFunctionsRequestInitializer( CloudFunctionsRequestInitializer cloudfunctionsRequestInitializer) { return (Builder) super.setGoogleClientRequestInitializer(cloudfunctionsRequestInitializer); } @Override public Builder setGoogleClientRequestInitializer( com.google.api.client.googleapis.services.GoogleClientRequestInitializer googleClientRequestInitializer) { return (Builder) super.setGoogleClientRequestInitializer(googleClientRequestInitializer); } } }
[ "\"GOOGLE_API_USE_MTLS_ENDPOINT\"" ]
[]
[ "GOOGLE_API_USE_MTLS_ENDPOINT" ]
[]
["GOOGLE_API_USE_MTLS_ENDPOINT"]
java
1
0
integration/integration_test.go
// This is the main file that sets up integration tests using go-check. package integration import ( "bytes" "flag" "fmt" "io/ioutil" "net" "os" "os/exec" "path/filepath" "strings" "testing" "text/template" "github.com/containous/traefik/pkg/log" "github.com/fatih/structs" "github.com/go-check/check" compose "github.com/libkermit/compose/check" checker "github.com/vdemeester/shakers" ) var integration = flag.Bool("integration", false, "run integration tests") var container = flag.Bool("container", false, "run container integration tests") var host = flag.Bool("host", false, "run host integration tests") var showLog = flag.Bool("tlog", false, "always show Traefik logs") func Test(t *testing.T) { check.TestingT(t) } func init() { flag.Parse() if !*integration { log.Info("Integration tests disabled.") return } if *container { // tests launched from a container check.Suite(&AccessLogSuite{}) check.Suite(&AcmeSuite{}) check.Suite(&DockerComposeSuite{}) check.Suite(&DockerSuite{}) check.Suite(&ErrorPagesSuite{}) check.Suite(&FileSuite{}) check.Suite(&GRPCSuite{}) check.Suite(&HealthCheckSuite{}) check.Suite(&HeadersSuite{}) check.Suite(&HostResolverSuite{}) check.Suite(&HTTPSSuite{}) check.Suite(&KeepAliveSuite{}) check.Suite(&LogRotationSuite{}) check.Suite(&MarathonSuite{}) check.Suite(&MarathonSuite15{}) // TODO: disable temporarily // check.Suite(&RateLimitSuite{}) check.Suite(&RestSuite{}) check.Suite(&RetrySuite{}) check.Suite(&SimpleSuite{}) check.Suite(&TimeoutSuite{}) check.Suite(&TLSClientHeadersSuite{}) check.Suite(&TracingSuite{}) check.Suite(&WebsocketSuite{}) } if *host { // tests launched from the host check.Suite(&K8sSuite{}) check.Suite(&ProxyProtocolSuite{}) check.Suite(&TCPSuite{}) } } var traefikBinary = "../dist/traefik" type BaseSuite struct { composeProject *compose.Project } func (s *BaseSuite) TearDownSuite(c *check.C) { // shutdown and delete compose project if s.composeProject != nil { s.composeProject.Stop(c) } } func (s *BaseSuite) createComposeProject(c *check.C, name string) { projectName := fmt.Sprintf("integration-test-%s", name) composeFile := fmt.Sprintf("resources/compose/%s.yml", name) addrs, err := net.InterfaceAddrs() c.Assert(err, checker.IsNil) for _, addr := range addrs { ip, _, err := net.ParseCIDR(addr.String()) c.Assert(err, checker.IsNil) if !ip.IsLoopback() && ip.To4() != nil { os.Setenv("DOCKER_HOST_IP", ip.String()) break } } s.composeProject = compose.CreateProject(c, projectName, composeFile) } func withConfigFile(file string) string { return "--configFile=" + file } func (s *BaseSuite) cmdTraefik(args ...string) (*exec.Cmd, *bytes.Buffer) { cmd := exec.Command(traefikBinary, args...) var out bytes.Buffer cmd.Stdout = &out cmd.Stderr = &out return cmd, &out } func (s *BaseSuite) traefikCmd(args ...string) (*exec.Cmd, func(*check.C)) { cmd, out := s.cmdTraefik(args...) return cmd, func(c *check.C) { if c.Failed() || *showLog { s.displayTraefikLog(c, out) } } } func (s *BaseSuite) displayTraefikLog(c *check.C, output *bytes.Buffer) { if output == nil || output.Len() == 0 { log.Infof("%s: No Traefik logs.", c.TestName()) } else { log.Infof("%s: Traefik logs: ", c.TestName()) log.Infof(output.String()) } } func (s *BaseSuite) getDockerHost() string { dockerHost := os.Getenv("DOCKER_HOST") if dockerHost == "" { // Default docker socket dockerHost = "unix:///var/run/docker.sock" } return dockerHost } func (s *BaseSuite) adaptFile(c *check.C, path string, tempObjects interface{}) string { // Load file tmpl, err := template.ParseFiles(path) c.Assert(err, checker.IsNil) folder, prefix := filepath.Split(path) tmpFile, err := ioutil.TempFile(folder, strings.TrimSuffix(prefix, filepath.Ext(prefix))+"_*"+filepath.Ext(prefix)) c.Assert(err, checker.IsNil) defer tmpFile.Close() model := structs.Map(tempObjects) model["SelfFilename"] = tmpFile.Name() err = tmpl.ExecuteTemplate(tmpFile, prefix, model) c.Assert(err, checker.IsNil) err = tmpFile.Sync() c.Assert(err, checker.IsNil) return tmpFile.Name() }
[ "\"DOCKER_HOST\"" ]
[]
[ "DOCKER_HOST" ]
[]
["DOCKER_HOST"]
go
1
0
vendor/golang.org/x/build/cmd/release/release.go
// Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // TODO(adg): add flag so that we can choose to run make.bash only // Command release builds a Go release. package main import ( "archive/tar" "archive/zip" "bytes" "compress/gzip" "flag" "fmt" gobuild "go/build" "io" "io/ioutil" "log" "os" "path" "path/filepath" "runtime" "strings" "sync" "golang.org/x/build" "golang.org/x/build/buildenv" "golang.org/x/build/buildlet" "golang.org/x/build/dashboard" ) var ( target = flag.String("target", "", "If specified, build specific target platform ('linux-amd64')") watch = flag.Bool("watch", false, "Watch the build. Only compatible with -target") rev = flag.String("rev", "", "Go revision to build") toolsRev = flag.String("tools", "", "Tools revision to build") tourRev = flag.String("tour", "master", "Tour revision to include") blogRev = flag.String("blog", "master", "Blog revision to include") netRev = flag.String("net", "master", "Net revision to include") version = flag.String("version", "", "Version string (go1.5.2)") user = flag.String("user", username(), "coordinator username, appended to 'user-'") skipTests = flag.Bool("skip_tests", false, "skip tests; run make.bash instead of all.bash (only use if you ran trybots first)") uploadMode = flag.Bool("upload", false, "Upload files (exclusive to all other flags)") ) var ( coordClient *buildlet.CoordinatorClient buildEnv *buildenv.Environment ) func main() { flag.Parse() if *uploadMode { if err := upload(flag.Args()); err != nil { log.Fatal(err) } return } if err := findReleaselet(); err != nil { log.Fatalf("couldn't find releaselet source: %v", err) } if *rev == "" { log.Fatal("must specify -rev flag") } if *toolsRev == "" { log.Fatal("must specify -tools flag") } if *version == "" { log.Fatal("must specify -version flag") } coordClient = coordinatorClient() buildEnv = buildenv.Production var wg sync.WaitGroup for _, b := range builds { b := b if *target != "" && b.String() != *target { continue } b.logf("Start.") wg.Add(1) go func() { defer wg.Done() if err := b.make(); err != nil { b.logf("Error: %v", err) } else { b.logf("Done.") } }() } wg.Wait() } var releaselet = "releaselet.go" func findReleaselet() error { // First try the working directory. if _, err := os.Stat(releaselet); err == nil { return nil } // Then, try to locate the release command in the workspace. const importPath = "golang.org/x/build/cmd/release" pkg, err := gobuild.Import(importPath, "", gobuild.FindOnly) if err != nil { return fmt.Errorf("finding %q: %v", importPath, err) } r := filepath.Join(pkg.Dir, releaselet) if _, err := os.Stat(r); err != nil { return err } releaselet = r return nil } type Build struct { OS, Arch string Source bool Race bool // Build race detector. Builder string // Key for dashboard.Builders. Goarm int // GOARM value if set. } func (b *Build) String() string { if b.Source { return "src" } if b.Goarm != 0 { return fmt.Sprintf("%v-%vv%vl", b.OS, b.Arch, b.Goarm) } return fmt.Sprintf("%v-%v", b.OS, b.Arch) } func (b *Build) toolDir() string { return "go/pkg/tool/" + b.OS + "_" + b.Arch } func (b *Build) logf(format string, args ...interface{}) { format = fmt.Sprintf("%v: %s", b, format) log.Printf(format, args...) } var builds = []*Build{ { Source: true, Builder: "linux-amd64", }, { OS: "linux", Arch: "386", Builder: "linux-386", }, { OS: "linux", Arch: "arm", Builder: "linux-arm", Goarm: 6, // for compatibility with all Raspberry Pi models. }, { OS: "linux", Arch: "amd64", Race: true, Builder: "linux-amd64", }, { OS: "freebsd", Arch: "386", Builder: "freebsd-386-gce101", }, { OS: "freebsd", Arch: "amd64", Race: true, Builder: "freebsd-amd64-gce101", }, { OS: "windows", Arch: "386", Builder: "windows-386-gce", }, { OS: "windows", Arch: "amd64", Race: true, Builder: "windows-amd64-gce", }, { OS: "darwin", Arch: "amd64", Race: true, Builder: "darwin-amd64-10_10", }, } const ( toolsRepo = "golang.org/x/tools" blogRepo = "golang.org/x/blog" tourRepo = "golang.org/x/tour" ) var toolPaths = []string{ "golang.org/x/tools/cmd/godoc", "golang.org/x/tour/gotour", } var preBuildCleanFiles = []string{ ".gitattributes", ".gitignore", ".hgignore", ".hgtags", "misc/dashboard", "misc/makerelease", } var postBuildCleanFiles = []string{ "VERSION.cache", "pkg/bootstrap", "src/cmd/api", } func (b *Build) buildlet() (*buildlet.Client, error) { b.logf("Creating buildlet.") bc, err := coordClient.CreateBuildlet(b.Builder) if err != nil { return nil, err } return bc, nil } func (b *Build) make() error { bc, ok := dashboard.Builders[b.Builder] if !ok { return fmt.Errorf("unknown builder: %v", bc) } client, err := b.buildlet() if err != nil { return err } defer client.Close() work, err := client.WorkDir() if err != nil { return err } // Push source to VM b.logf("Pushing source to VM.") const ( goDir = "go" goPath = "gopath" go14 = "go1.4" ) for _, r := range []struct { repo, rev string }{ {"go", *rev}, {"tools", *toolsRev}, {"blog", *blogRev}, {"tour", *tourRev}, {"net", *netRev}, } { if b.Source && r.repo != "go" { continue } dir := goDir if r.repo != "go" { dir = goPath + "/src/golang.org/x/" + r.repo } tar := "https://go.googlesource.com/" + r.repo + "/+archive/" + r.rev + ".tar.gz" if err := client.PutTarFromURL(tar, dir); err != nil { return err } } if u := bc.GoBootstrapURL(buildEnv); u != "" && !b.Source { b.logf("Installing go1.4.") if err := client.PutTarFromURL(u, go14); err != nil { return err } } // Write out version file. b.logf("Writing VERSION file.") if err := client.Put(strings.NewReader(*version), "go/VERSION", 0644); err != nil { return err } b.logf("Cleaning goroot (pre-build).") if err := client.RemoveAll(addPrefix(goDir, preBuildCleanFiles)...); err != nil { return err } if b.Source { b.logf("Skipping build.") return b.fetchTarball(client) } // Set up build environment. sep := "/" if b.OS == "windows" { sep = "\\" } env := append(bc.Env(), "GOROOT_FINAL="+bc.GorootFinal(), "GOROOT="+work+sep+goDir, "GOPATH="+work+sep+goPath, "GOBIN=", ) if b.Goarm > 0 { env = append(env, fmt.Sprintf("GOARM=%d", b.Goarm)) } // Execute build b.logf("Building.") out := new(bytes.Buffer) script := bc.AllScript() scriptArgs := bc.AllScriptArgs() if *skipTests { script = bc.MakeScript() scriptArgs = bc.MakeScriptArgs() } all := filepath.Join(goDir, script) var execOut io.Writer = out if *watch && *target != "" { execOut = io.MultiWriter(out, os.Stdout) } remoteErr, err := client.Exec(all, buildlet.ExecOpts{ Output: execOut, ExtraEnv: env, Args: scriptArgs, }) if err != nil { return err } if remoteErr != nil { return fmt.Errorf("Build failed: %v\nOutput:\n%v", remoteErr, out) } goCmd := path.Join(goDir, "bin/go") if b.OS == "windows" { goCmd += ".exe" } runGo := func(args ...string) error { out := new(bytes.Buffer) var execOut io.Writer = out if *watch && *target != "" { execOut = io.MultiWriter(out, os.Stdout) } remoteErr, err := client.Exec(goCmd, buildlet.ExecOpts{ Output: execOut, Dir: ".", // root of buildlet work directory Args: args, ExtraEnv: env, }) if err != nil { return err } if remoteErr != nil { return fmt.Errorf("go %v: %v\n%s", strings.Join(args, " "), remoteErr, out) } return nil } if b.Race { b.logf("Building race detector.") if err := runGo("install", "-race", "std"); err != nil { return err } } b.logf("Building %v.", strings.Join(toolPaths, ", ")) if err := runGo(append([]string{"install"}, toolPaths...)...); err != nil { return err } b.logf("Cleaning goroot (post-build).") if err := client.RemoveAll(addPrefix(goDir, postBuildCleanFiles)...); err != nil { return err } if err := client.RemoveAll(b.toolDir() + "/api"); err != nil { return err } b.logf("Pushing and running releaselet.") f, err := os.Open(releaselet) if err != nil { return err } err = client.Put(f, "releaselet.go", 0666) f.Close() if err != nil { return err } if err := runGo("run", "releaselet.go"); err != nil { return err } cleanFiles := []string{"releaselet.go", goPath, go14} switch b.OS { case "darwin": filename := *version + "." + b.String() + ".pkg" if err := b.fetchFile(client, filename, "pkg"); err != nil { return err } cleanFiles = append(cleanFiles, "pkg") case "windows": filename := *version + "." + b.String() + ".msi" if err := b.fetchFile(client, filename, "msi"); err != nil { return err } cleanFiles = append(cleanFiles, "msi") } // Need to delete everything except the final "go" directory, // as we make the tarball relative to workdir. b.logf("Cleaning workdir.") if err := client.RemoveAll(cleanFiles...); err != nil { return err } if b.OS == "windows" { return b.fetchZip(client) } return b.fetchTarball(client) } func (b *Build) fetchTarball(client *buildlet.Client) error { b.logf("Downloading tarball.") tgz, err := client.GetTar(".") if err != nil { return err } filename := *version + "." + b.String() + ".tar.gz" return b.writeFile(filename, tgz) } func (b *Build) fetchZip(client *buildlet.Client) error { b.logf("Downloading tarball and re-compressing as zip.") tgz, err := client.GetTar(".") if err != nil { return err } defer tgz.Close() filename := *version + "." + b.String() + ".zip" f, err := os.Create(filename) if err != nil { return err } if err := tgzToZip(f, tgz); err != nil { f.Close() return err } if err := f.Close(); err != nil { return err } b.logf("Wrote %q.", filename) return nil } func tgzToZip(w io.Writer, r io.Reader) error { zr, err := gzip.NewReader(r) if err != nil { return err } tr := tar.NewReader(zr) zw := zip.NewWriter(w) for { th, err := tr.Next() if err == io.EOF { break } if err != nil { return err } fi := th.FileInfo() zh, err := zip.FileInfoHeader(fi) if err != nil { return err } zh.Name = th.Name // for the full path switch strings.ToLower(path.Ext(zh.Name)) { case ".jpg", ".jpeg", ".png", ".gif": // Don't re-compress already compressed files. zh.Method = zip.Store default: zh.Method = zip.Deflate } if fi.IsDir() { zh.Method = zip.Store } w, err := zw.CreateHeader(zh) if err != nil { return err } if fi.IsDir() { continue } if _, err := io.Copy(w, tr); err != nil { return err } } return zw.Close() } // fetchFile fetches the specified directory from the given buildlet, and // writes the first file it finds in that directory to dest. func (b *Build) fetchFile(client *buildlet.Client, dest, dir string) error { b.logf("Downloading file from %q.", dir) tgz, err := client.GetTar(dir) if err != nil { return err } defer tgz.Close() zr, err := gzip.NewReader(tgz) if err != nil { return err } tr := tar.NewReader(zr) for { h, err := tr.Next() if err == io.EOF { return io.ErrUnexpectedEOF } if err != nil { return err } if !h.FileInfo().IsDir() { break } } return b.writeFile(dest, tr) } func (b *Build) writeFile(name string, r io.Reader) error { f, err := os.Create(name) if err != nil { return err } if _, err := io.Copy(f, r); err != nil { f.Close() return err } if err := f.Close(); err != nil { return err } b.logf("Wrote %q.", name) return nil } func addPrefix(prefix string, in []string) []string { var out []string for _, s := range in { out = append(out, path.Join(prefix, s)) } return out } func coordinatorClient() *buildlet.CoordinatorClient { return &buildlet.CoordinatorClient{ Auth: buildlet.UserPass{ Username: "user-" + *user, Password: userToken(), }, Instance: build.ProdCoordinator, } } func homeDir() string { if runtime.GOOS == "windows" { return os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH") } return os.Getenv("HOME") } func configDir() string { if runtime.GOOS == "windows" { return filepath.Join(os.Getenv("APPDATA"), "Gomote") } if xdg := os.Getenv("XDG_CONFIG_HOME"); xdg != "" { return filepath.Join(xdg, "gomote") } return filepath.Join(homeDir(), ".config", "gomote") } func username() string { if runtime.GOOS == "windows" { return os.Getenv("USERNAME") } return os.Getenv("USER") } func userToken() string { if *user == "" { panic("userToken called with user flag empty") } keyDir := configDir() baseFile := "user-" + *user + ".token" tokenFile := filepath.Join(keyDir, baseFile) slurp, err := ioutil.ReadFile(tokenFile) if os.IsNotExist(err) { log.Printf("Missing file %s for user %q. Change --user or obtain a token and place it there.", tokenFile, *user) } if err != nil { log.Fatal(err) } return strings.TrimSpace(string(slurp)) }
[ "\"HOMEDRIVE\"", "\"HOMEPATH\"", "\"HOME\"", "\"APPDATA\"", "\"XDG_CONFIG_HOME\"", "\"USERNAME\"", "\"USER\"" ]
[]
[ "USERNAME", "APPDATA", "HOMEPATH", "HOMEDRIVE", "USER", "HOME", "XDG_CONFIG_HOME" ]
[]
["USERNAME", "APPDATA", "HOMEPATH", "HOMEDRIVE", "USER", "HOME", "XDG_CONFIG_HOME"]
go
7
0
server/server_test.go
// Copyright 2015 PingCAP, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // See the License for the specific language governing permissions and // limitations under the License. package server import ( "bytes" "database/sql" "encoding/json" "fmt" "io" "io/ioutil" "math/rand" "net/http" "net/url" "os" "path/filepath" "reflect" "regexp" "strconv" "strings" "testing" "time" "github.com/go-sql-driver/mysql" . "github.com/pingcap/check" "github.com/pingcap/errors" "github.com/pingcap/failpoint" "github.com/pingcap/log" tmysql "github.com/pingcap/parser/mysql" "github.com/pingcap/tidb/config" "github.com/pingcap/tidb/errno" "github.com/pingcap/tidb/kv" "github.com/pingcap/tidb/util/logutil" "github.com/pingcap/tidb/util/versioninfo" "go.uber.org/zap" ) var ( regression = true ) func TestT(t *testing.T) { defaultConfig := config.NewConfig() globalConfig := config.GetGlobalConfig() // Test for issue 22162. the global config shouldn't be changed by other pkg init function. if !reflect.DeepEqual(defaultConfig, globalConfig) { t.Fatalf("%#v != %#v\n", defaultConfig, globalConfig) } CustomVerboseFlag = true logLevel := os.Getenv("log_level") err := logutil.InitZapLogger(logutil.NewLogConfig(logLevel, logutil.DefaultLogFormat, "", logutil.EmptyFileLogConfig, false)) if err != nil { t.Fatal(err) } TestingT(t) } type configOverrider func(*mysql.Config) // testServerClient config server connect parameters and provider several // method to communicate with server and run tests type testServerClient struct { port uint statusPort uint statusScheme string } // newTestServerClient return a testServerClient with unique address func newTestServerClient() *testServerClient { return &testServerClient{ port: 0, statusPort: 0, statusScheme: "http", } } // statusURL return the full URL of a status path func (cli *testServerClient) statusURL(path string) string { return fmt.Sprintf("%s://localhost:%d%s", cli.statusScheme, cli.statusPort, path) } // fetchStatus exec http.Get to server status port func (cli *testServerClient) fetchStatus(path string) (*http.Response, error) { return http.Get(cli.statusURL(path)) } // postStatus exec http.Port to server status port func (cli *testServerClient) postStatus(path, contentType string, body io.Reader) (*http.Response, error) { return http.Post(cli.statusURL(path), contentType, body) } // formStatus post a form request to server status address func (cli *testServerClient) formStatus(path string, data url.Values) (*http.Response, error) { return http.PostForm(cli.statusURL(path), data) } // getDSN generates a DSN string for MySQL connection. func (cli *testServerClient) getDSN(overriders ...configOverrider) string { config := mysql.NewConfig() config.User = "root" config.Net = "tcp" config.Addr = fmt.Sprintf("127.0.0.1:%d", cli.port) config.DBName = "test" config.Params = make(map[string]string) for _, overrider := range overriders { if overrider != nil { overrider(config) } } return config.FormatDSN() } // runTests runs tests using the default database `test`. func (cli *testServerClient) runTests(c *C, overrider configOverrider, tests ...func(dbt *DBTest)) { db, err := sql.Open("mysql", cli.getDSN(overrider)) c.Assert(err, IsNil, Commentf("Error connecting")) defer func() { err := db.Close() c.Assert(err, IsNil) }() _, err = db.Exec("DROP TABLE IF EXISTS test") c.Assert(err, IsNil) dbt := &DBTest{c, db} for _, test := range tests { test(dbt) // fixed query error _, _ = dbt.db.Exec("DROP TABLE IF EXISTS test") } } // runTestsOnNewDB runs tests using a specified database which will be created before the test and destroyed after the test. func (cli *testServerClient) runTestsOnNewDB(c *C, overrider configOverrider, dbName string, tests ...func(dbt *DBTest)) { dsn := cli.getDSN(overrider, func(config *mysql.Config) { config.DBName = "" }) db, err := sql.Open("mysql", dsn) c.Assert(err, IsNil, Commentf("Error connecting")) defer func() { err := db.Close() c.Assert(err, IsNil) }() _, err = db.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS `%s`;", dbName)) if err != nil { fmt.Println(err) } c.Assert(err, IsNil, Commentf("Error drop database %s: %s", dbName, err)) _, err = db.Exec(fmt.Sprintf("CREATE DATABASE `%s`;", dbName)) c.Assert(err, IsNil, Commentf("Error create database %s: %s", dbName, err)) defer func() { _, err = db.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS `%s`;", dbName)) c.Assert(err, IsNil, Commentf("Error drop database %s: %s", dbName, err)) }() _, err = db.Exec(fmt.Sprintf("USE `%s`;", dbName)) c.Assert(err, IsNil, Commentf("Error use database %s: %s", dbName, err)) dbt := &DBTest{c, db} for _, test := range tests { test(dbt) // to fix : no db selected _, _ = dbt.db.Exec("DROP TABLE IF EXISTS test") } } type DBTest struct { *C db *sql.DB } func (dbt *DBTest) fail(method, query string, err error) { if len(query) > 300 { query = "[query too large to print]" } dbt.Fatalf("Error on %s %s: %s", method, query, err.Error()) } func (dbt *DBTest) mustPrepare(query string) *sql.Stmt { stmt, err := dbt.db.Prepare(query) dbt.Assert(err, IsNil, Commentf("Prepare %s", query)) return stmt } func (dbt *DBTest) mustExecPrepared(stmt *sql.Stmt, args ...interface{}) sql.Result { res, err := stmt.Exec(args...) dbt.Assert(err, IsNil, Commentf("Execute prepared with args: %s", args)) return res } func (dbt *DBTest) mustQueryPrepared(stmt *sql.Stmt, args ...interface{}) *sql.Rows { rows, err := stmt.Query(args...) dbt.Assert(err, IsNil, Commentf("Query prepared with args: %s", args)) return rows } func (dbt *DBTest) mustExec(query string, args ...interface{}) (res sql.Result) { res, err := dbt.db.Exec(query, args...) dbt.Assert(err, IsNil, Commentf("Exec %s", query)) return res } func (dbt *DBTest) mustQuery(query string, args ...interface{}) (rows *sql.Rows) { rows, err := dbt.db.Query(query, args...) dbt.Assert(err, IsNil, Commentf("Query %s", query)) return rows } func (dbt *DBTest) mustQueryRows(query string, args ...interface{}) { rows := dbt.mustQuery(query, args...) dbt.Assert(rows.Next(), IsTrue) rows.Close() } func (cli *testServerClient) runTestRegression(c *C, overrider configOverrider, dbName string) { cli.runTestsOnNewDB(c, overrider, dbName, func(dbt *DBTest) { // Show the user dbt.mustExec("select user()") // Create Table dbt.mustExec("CREATE TABLE test (val TINYINT)") // Test for unexpected data var out bool rows := dbt.mustQuery("SELECT * FROM test") dbt.Assert(rows.Next(), IsFalse, Commentf("unexpected data in empty table")) // Create Data res := dbt.mustExec("INSERT INTO test VALUES (1)") // res := dbt.mustExec("INSERT INTO test VALUES (?)", 1) count, err := res.RowsAffected() dbt.Assert(err, IsNil) dbt.Check(count, Equals, int64(1)) id, err := res.LastInsertId() dbt.Assert(err, IsNil) dbt.Check(id, Equals, int64(0)) // Read rows = dbt.mustQuery("SELECT val FROM test") if rows.Next() { err = rows.Scan(&out) c.Assert(err, IsNil) dbt.Check(out, IsTrue) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) } else { dbt.Error("no data") } rows.Close() // Update res = dbt.mustExec("UPDATE test SET val = 0 WHERE val = ?", 1) count, err = res.RowsAffected() dbt.Assert(err, IsNil) dbt.Check(count, Equals, int64(1)) // Check Update rows = dbt.mustQuery("SELECT val FROM test") if rows.Next() { err = rows.Scan(&out) c.Assert(err, IsNil) dbt.Check(out, IsFalse) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) } else { dbt.Error("no data") } rows.Close() // Delete res = dbt.mustExec("DELETE FROM test WHERE val = 0") // res = dbt.mustExec("DELETE FROM test WHERE val = ?", 0) count, err = res.RowsAffected() dbt.Assert(err, IsNil) dbt.Check(count, Equals, int64(1)) // Check for unexpected rows res = dbt.mustExec("DELETE FROM test") count, err = res.RowsAffected() dbt.Assert(err, IsNil) dbt.Check(count, Equals, int64(0)) dbt.mustQueryRows("SELECT 1") var b = make([]byte, 0) if err := dbt.db.QueryRow("SELECT ?", b).Scan(&b); err != nil { dbt.Fatal(err) } if b == nil { dbt.Error("nil echo from non-nil input") } }) } func (cli *testServerClient) runTestPrepareResultFieldType(t *C) { var param int64 = 83 cli.runTests(t, nil, func(dbt *DBTest) { stmt, err := dbt.db.Prepare(`SELECT ?`) if err != nil { dbt.Fatal(err) } defer stmt.Close() row := stmt.QueryRow(param) var result int64 err = row.Scan(&result) if err != nil { dbt.Fatal(err) } if result != param { dbt.Fatal("Unexpected result value") } }) } func (cli *testServerClient) runTestSpecialType(t *C) { cli.runTestsOnNewDB(t, nil, "SpecialType", func(dbt *DBTest) { dbt.mustExec("create table test (a decimal(10, 5), b datetime, c time, d bit(8))") dbt.mustExec("insert test values (1.4, '2012-12-21 12:12:12', '4:23:34', b'1000')") rows := dbt.mustQuery("select * from test where a > ?", 0) t.Assert(rows.Next(), IsTrue) var outA float64 var outB, outC string var outD []byte err := rows.Scan(&outA, &outB, &outC, &outD) t.Assert(err, IsNil) t.Assert(outA, Equals, 1.4) t.Assert(outB, Equals, "2012-12-21 12:12:12") t.Assert(outC, Equals, "04:23:34") t.Assert(outD, BytesEquals, []byte{8}) }) } func (cli *testServerClient) runTestClientWithCollation(t *C) { cli.runTests(t, func(config *mysql.Config) { config.Collation = "utf8mb4_general_ci" }, func(dbt *DBTest) { var name, charset, collation string // check session variable collation_connection rows := dbt.mustQuery("show variables like 'collation_connection'") t.Assert(rows.Next(), IsTrue) err := rows.Scan(&name, &collation) t.Assert(err, IsNil) t.Assert(collation, Equals, "utf8mb4_general_ci") // check session variable character_set_client rows = dbt.mustQuery("show variables like 'character_set_client'") t.Assert(rows.Next(), IsTrue) err = rows.Scan(&name, &charset) t.Assert(err, IsNil) t.Assert(charset, Equals, "utf8mb4") // check session variable character_set_results rows = dbt.mustQuery("show variables like 'character_set_results'") t.Assert(rows.Next(), IsTrue) err = rows.Scan(&name, &charset) t.Assert(err, IsNil) t.Assert(charset, Equals, "utf8mb4") // check session variable character_set_connection rows = dbt.mustQuery("show variables like 'character_set_connection'") t.Assert(rows.Next(), IsTrue) err = rows.Scan(&name, &charset) t.Assert(err, IsNil) t.Assert(charset, Equals, "utf8mb4") }) } func (cli *testServerClient) runTestPreparedString(t *C) { cli.runTestsOnNewDB(t, nil, "PreparedString", func(dbt *DBTest) { dbt.mustExec("create table test (a char(10), b char(10))") dbt.mustExec("insert test values (?, ?)", "abcdeabcde", "abcde") rows := dbt.mustQuery("select * from test where 1 = ?", 1) t.Assert(rows.Next(), IsTrue) var outA, outB string err := rows.Scan(&outA, &outB) t.Assert(err, IsNil) t.Assert(outA, Equals, "abcdeabcde") t.Assert(outB, Equals, "abcde") }) } // runTestPreparedTimestamp does not really cover binary timestamp format, because MySQL driver in golang // does not use this format. MySQL driver in golang will convert the timestamp to a string. // This case guarantees it could work. func (cli *testServerClient) runTestPreparedTimestamp(t *C) { cli.runTestsOnNewDB(t, nil, "prepared_timestamp", func(dbt *DBTest) { dbt.mustExec("create table test (a timestamp, b time)") dbt.mustExec("set time_zone='+00:00'") insertStmt := dbt.mustPrepare("insert test values (?, ?)") defer insertStmt.Close() vts := time.Unix(1, 1) vt := time.Unix(-1, 1) dbt.mustExecPrepared(insertStmt, vts, vt) selectStmt := dbt.mustPrepare("select * from test where a = ? and b = ?") defer selectStmt.Close() rows := dbt.mustQueryPrepared(selectStmt, vts, vt) t.Assert(rows.Next(), IsTrue) var outA, outB string err := rows.Scan(&outA, &outB) t.Assert(err, IsNil) t.Assert(outA, Equals, "1970-01-01 00:00:01") t.Assert(outB, Equals, "23:59:59") }) } func (cli *testServerClient) runTestLoadDataWithSelectIntoOutfile(c *C, server *Server) { cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "SelectIntoOutfile", func(dbt *DBTest) { dbt.mustExec("create table t (i int, r real, d decimal(10, 5), s varchar(100), dt datetime, ts timestamp, j json)") dbt.mustExec("insert into t values (1, 1.1, 0.1, 'a', '2000-01-01', '01:01:01', '[1]')") dbt.mustExec("insert into t values (2, 2.2, 0.2, 'b', '2000-02-02', '02:02:02', '[1,2]')") dbt.mustExec("insert into t values (null, null, null, null, '2000-03-03', '03:03:03', '[1,2,3]')") dbt.mustExec("insert into t values (4, 4.4, 0.4, 'd', null, null, null)") outfile := filepath.Join(os.TempDir(), fmt.Sprintf("select_into_outfile_%v_%d.csv", time.Now().UnixNano(), rand.Int())) // On windows use fmt.Sprintf("%q") to escape \ for SQL, // outfile may be 'C:\Users\genius\AppData\Local\Temp\select_into_outfile_1582732846769492000_8074605509026837941.csv' // Without quote, after SQL escape it would become: // 'C:UsersgeniusAppDataLocalTempselect_into_outfile_1582732846769492000_8074605509026837941.csv' dbt.mustExec(fmt.Sprintf("select * from t into outfile %q", outfile)) defer func() { c.Assert(os.Remove(outfile), IsNil) }() dbt.mustExec("create table t1 (i int, r real, d decimal(10, 5), s varchar(100), dt datetime, ts timestamp, j json)") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t1", outfile)) fetchResults := func(table string) [][]interface{} { var res [][]interface{} row := dbt.mustQuery("select * from " + table + " order by i") for row.Next() { r := make([]interface{}, 7) c.Assert(row.Scan(&r[0], &r[1], &r[2], &r[3], &r[4], &r[5], &r[6]), IsNil) res = append(res, r) } c.Assert(row.Close(), IsNil) return res } res := fetchResults("t") res1 := fetchResults("t1") c.Assert(len(res), Equals, len(res1)) for i := range res { for j := range res[i] { // using Sprintf to avoid some uncomparable types c.Assert(fmt.Sprintf("%v", res[i][j]), Equals, fmt.Sprintf("%v", res1[i][j])) } } }) } func (cli *testServerClient) runTestLoadDataForSlowLog(c *C, server *Server) { path := "/tmp/load_data_test.csv" fp, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) c.Assert(err, IsNil) c.Assert(fp, NotNil) defer func() { err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) }() _, err = fp.WriteString( "1 1\n" + "2 2\n" + "3 3\n" + "4 4\n" + "5 5\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "load_data_slow_query", func(dbt *DBTest) { dbt.mustExec("create table t_slow (a int key, b int)") defer func() { dbt.mustExec("set tidb_slow_log_threshold=300;") dbt.mustExec("set @@global.tidb_enable_stmt_summary=0") }() dbt.mustExec("set tidb_slow_log_threshold=0;") dbt.mustExec("set @@global.tidb_enable_stmt_summary=1") query := fmt.Sprintf("load data local infile %q into table t_slow", path) dbt.mustExec(query) dbt.mustExec("insert ignore into t_slow values (1,1);") checkPlan := func(rows *sql.Rows, expectPlan string) { dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) var plan sql.NullString err = rows.Scan(&plan) dbt.Check(err, IsNil) planStr := strings.ReplaceAll(plan.String, "\t", " ") planStr = strings.ReplaceAll(planStr, "\n", " ") c.Assert(planStr, Matches, expectPlan) } // Test for record slow log for load data statement. rows := dbt.mustQuery(fmt.Sprintf("select plan from information_schema.slow_query where query like 'load data local infile %% into table t_slow;' order by time desc limit 1")) expectedPlan := ".*LoadData.* time.* loops.* prepare.* check_insert.* mem_insert_time:.* prefetch.* rpc.* commit_txn.*" checkPlan(rows, expectedPlan) // Test for record statements_summary for load data statement. rows = dbt.mustQuery(fmt.Sprintf("select plan from information_schema.STATEMENTS_SUMMARY where QUERY_SAMPLE_TEXT like 'load data local infile %%' limit 1")) checkPlan(rows, expectedPlan) // Test log normal statement after executing load date. rows = dbt.mustQuery(fmt.Sprintf("select plan from information_schema.slow_query where query = 'insert ignore into t_slow values (1,1);' order by time desc limit 1")) expectedPlan = ".*Insert.* time.* loops.* prepare.* check_insert.* mem_insert_time:.* prefetch.* rpc.*" checkPlan(rows, expectedPlan) }) } func (cli *testServerClient) prepareLoadDataFile(c *C, path string, rows ...string) { fp, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) c.Assert(err, IsNil) c.Assert(fp, NotNil) defer func() { err = fp.Close() c.Assert(err, IsNil) }() for _, row := range rows { fields := strings.Split(row, " ") _, err = fp.WriteString(strings.Join(fields, "\t")) _, err = fp.WriteString("\n") } c.Assert(err, IsNil) } func (cli *testServerClient) runTestLoadDataAutoRandom(c *C) { path := "/tmp/load_data_txn_error.csv" fp, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) c.Assert(err, IsNil) c.Assert(fp, NotNil) defer func() { _ = os.Remove(path) }() cksum1 := 0 cksum2 := 0 for i := 0; i < 50000; i++ { n1 := rand.Intn(1000) n2 := rand.Intn(1000) str1 := strconv.Itoa(n1) str2 := strconv.Itoa(n2) row := str1 + "\t" + str2 _, err := fp.WriteString(row) c.Assert(err, IsNil) _, err = fp.WriteString("\n") c.Assert(err, IsNil) if i == 0 { cksum1 = n1 cksum2 = n2 } else { cksum1 = cksum1 ^ n1 cksum2 = cksum2 ^ n2 } } err = fp.Close() c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "load_data_batch_dml", func(dbt *DBTest) { // Set batch size, and check if load data got a invalid txn error. dbt.mustExec("set @@session.tidb_dml_batch_size = 128") dbt.mustExec("drop table if exists t") dbt.mustExec("create table t(c1 bigint auto_random primary key, c2 bigint, c3 bigint)") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t (c2, c3)", path)) rows := dbt.mustQuery("select count(*) from t") cli.checkRows(c, rows, "50000") rows = dbt.mustQuery("select bit_xor(c2), bit_xor(c3) from t") res := strconv.Itoa(cksum1) res = res + " " res = res + strconv.Itoa(cksum2) cli.checkRows(c, rows, res) }) } func (cli *testServerClient) runTestLoadDataAutoRandomWithSpecialTerm(c *C) { path := "/tmp/load_data_txn_error_term.csv" fp, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) c.Assert(err, IsNil) c.Assert(fp, NotNil) defer func() { _ = os.Remove(path) }() cksum1 := 0 cksum2 := 0 for i := 0; i < 50000; i++ { n1 := rand.Intn(1000) n2 := rand.Intn(1000) str1 := strconv.Itoa(n1) str2 := strconv.Itoa(n2) row := "'" + str1 + "','" + str2 + "'" _, err := fp.WriteString(row) c.Assert(err, IsNil) if i != 49999 { _, err = fp.WriteString("|") } c.Assert(err, IsNil) if i == 0 { cksum1 = n1 cksum2 = n2 } else { cksum1 = cksum1 ^ n1 cksum2 = cksum2 ^ n2 } } err = fp.Close() c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params = map[string]string{"sql_mode": "''"} }, "load_data_batch_dml", func(dbt *DBTest) { // Set batch size, and check if load data got a invalid txn error. dbt.mustExec("set @@session.tidb_dml_batch_size = 128") dbt.mustExec("drop table if exists t1") dbt.mustExec("create table t1(c1 bigint auto_random primary key, c2 bigint, c3 bigint)") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t1 fields terminated by ',' enclosed by '\\'' lines terminated by '|' (c2, c3)", path)) rows := dbt.mustQuery("select count(*) from t1") cli.checkRows(c, rows, "50000") rows = dbt.mustQuery("select bit_xor(c2), bit_xor(c3) from t1") res := strconv.Itoa(cksum1) res = res + " " res = res + strconv.Itoa(cksum2) cli.checkRows(c, rows, res) }) } func (cli *testServerClient) runTestLoadDataForListPartition(c *C) { path := "/tmp/load_data_list_partition.csv" defer func() { _ = os.Remove(path) }() cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "load_data_list_partition", func(dbt *DBTest) { dbt.mustExec("set @@session.tidb_enable_list_partition = ON") dbt.mustExec(`create table t (id int, name varchar(10), unique index idx (id)) partition by list (id) ( partition p0 values in (3,5,6,9,17), partition p1 values in (1,2,10,11,19,20), partition p2 values in (4,12,13,14,18), partition p3 values in (7,8,15,16,null) );`) // Test load data into 1 partition. cli.prepareLoadDataFile(c, path, "1 a", "2 b") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows := dbt.mustQuery("select * from t partition(p1) order by id") cli.checkRows(c, rows, "1 a", "2 b") // Test load data into multi-partitions. dbt.mustExec("delete from t") cli.prepareLoadDataFile(c, path, "1 a", "3 c", "4 e") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "1 a", "3 c", "4 e") // Test load data meet duplicate error. cli.prepareLoadDataFile(c, path, "1 x", "2 b", "2 x", "7 a") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1062 Duplicate entry '1' for key 'idx'", "Warning 1062 Duplicate entry '2' for key 'idx'") rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "1 a", "2 b", "3 c", "4 e", "7 a") // Test load data meet no partition warning. cli.prepareLoadDataFile(c, path, "5 a", "100 x") _, err := dbt.db.Exec(fmt.Sprintf("load data local infile %q into table t", path)) c.Assert(err, IsNil) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1526 Table has no partition for value 100") rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "1 a", "2 b", "3 c", "4 e", "5 a", "7 a") }) } func (cli *testServerClient) runTestLoadDataForListPartition2(c *C) { path := "/tmp/load_data_list_partition.csv" defer func() { _ = os.Remove(path) }() cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "load_data_list_partition", func(dbt *DBTest) { dbt.mustExec("set @@session.tidb_enable_list_partition = ON") dbt.mustExec(`create table t (id int, name varchar(10),b int generated always as (length(name)+1) virtual, unique index idx (id,b)) partition by list (id*2 + b*b + b*b - b*b*2 - abs(id)) ( partition p0 values in (3,5,6,9,17), partition p1 values in (1,2,10,11,19,20), partition p2 values in (4,12,13,14,18), partition p3 values in (7,8,15,16,null) );`) // Test load data into 1 partition. cli.prepareLoadDataFile(c, path, "1 a", "2 b") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t (id,name)", path)) rows := dbt.mustQuery("select id,name from t partition(p1) order by id") cli.checkRows(c, rows, "1 a", "2 b") // Test load data into multi-partitions. dbt.mustExec("delete from t") cli.prepareLoadDataFile(c, path, "1 a", "3 c", "4 e") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t (id,name)", path)) rows = dbt.mustQuery("select id,name from t order by id") cli.checkRows(c, rows, "1 a", "3 c", "4 e") // Test load data meet duplicate error. cli.prepareLoadDataFile(c, path, "1 x", "2 b", "2 x", "7 a") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t (id,name)", path)) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1062 Duplicate entry '1-2' for key 'idx'", "Warning 1062 Duplicate entry '2-2' for key 'idx'") rows = dbt.mustQuery("select id,name from t order by id") cli.checkRows(c, rows, "1 a", "2 b", "3 c", "4 e", "7 a") // Test load data meet no partition warning. cli.prepareLoadDataFile(c, path, "5 a", "100 x") _, err := dbt.db.Exec(fmt.Sprintf("load data local infile %q into table t (id,name)", path)) c.Assert(err, IsNil) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1526 Table has no partition for value 100") rows = dbt.mustQuery("select id,name from t order by id") cli.checkRows(c, rows, "1 a", "2 b", "3 c", "4 e", "5 a", "7 a") }) } func (cli *testServerClient) runTestLoadDataForListColumnPartition(c *C) { path := "/tmp/load_data_list_partition.csv" defer func() { _ = os.Remove(path) }() cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "load_data_list_partition", func(dbt *DBTest) { dbt.mustExec("set @@session.tidb_enable_list_partition = ON") dbt.mustExec(`create table t (id int, name varchar(10), unique index idx (id)) partition by list columns (id) ( partition p0 values in (3,5,6,9,17), partition p1 values in (1,2,10,11,19,20), partition p2 values in (4,12,13,14,18), partition p3 values in (7,8,15,16,null) );`) // Test load data into 1 partition. cli.prepareLoadDataFile(c, path, "1 a", "2 b") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows := dbt.mustQuery("select * from t partition(p1) order by id") cli.checkRows(c, rows, "1 a", "2 b") // Test load data into multi-partitions. dbt.mustExec("delete from t") cli.prepareLoadDataFile(c, path, "1 a", "3 c", "4 e") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "1 a", "3 c", "4 e") // Test load data meet duplicate error. cli.prepareLoadDataFile(c, path, "1 x", "2 b", "2 x", "7 a") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1062 Duplicate entry '1' for key 'idx'", "Warning 1062 Duplicate entry '2' for key 'idx'") rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "1 a", "2 b", "3 c", "4 e", "7 a") // Test load data meet no partition warning. cli.prepareLoadDataFile(c, path, "5 a", "100 x") _, err := dbt.db.Exec(fmt.Sprintf("load data local infile %q into table t", path)) c.Assert(err, IsNil) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1526 Table has no partition for value from column_list") rows = dbt.mustQuery("select id,name from t order by id") cli.checkRows(c, rows, "1 a", "2 b", "3 c", "4 e", "5 a", "7 a") }) } func (cli *testServerClient) runTestLoadDataForListColumnPartition2(c *C) { path := "/tmp/load_data_list_partition.csv" defer func() { _ = os.Remove(path) }() cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "load_data_list_partition", func(dbt *DBTest) { dbt.mustExec("set @@session.tidb_enable_list_partition = ON") dbt.mustExec(`create table t (location varchar(10), id int, a int, unique index idx (location,id)) partition by list columns (location,id) ( partition p_west values in (('w', 1),('w', 2),('w', 3),('w', 4)), partition p_east values in (('e', 5),('e', 6),('e', 7),('e', 8)), partition p_north values in (('n', 9),('n',10),('n',11),('n',12)), partition p_south values in (('s',13),('s',14),('s',15),('s',16)) );`) // Test load data into 1 partition. cli.prepareLoadDataFile(c, path, "w 1 1", "w 2 2") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows := dbt.mustQuery("select * from t partition(p_west) order by id") cli.checkRows(c, rows, "w 1 1", "w 2 2") // Test load data into multi-partitions. dbt.mustExec("delete from t") cli.prepareLoadDataFile(c, path, "w 1 1", "e 5 5", "n 9 9") dbt.mustExec(fmt.Sprintf("load data local infile %q into table t", path)) rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "w 1 1", "e 5 5", "n 9 9") // Test load data meet duplicate error. cli.prepareLoadDataFile(c, path, "w 1 2", "w 2 2") _, err := dbt.db.Exec(fmt.Sprintf("load data local infile %q into table t", path)) c.Assert(err, IsNil) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1062 Duplicate entry 'w-1' for key 'idx'") rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "w 1 1", "w 2 2", "e 5 5", "n 9 9") // Test load data meet no partition warning. cli.prepareLoadDataFile(c, path, "w 3 3", "w 5 5", "e 8 8") _, err = dbt.db.Exec(fmt.Sprintf("load data local infile %q into table t", path)) c.Assert(err, IsNil) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1526 Table has no partition for value from column_list") cli.prepareLoadDataFile(c, path, "x 1 1", "w 1 1") _, err = dbt.db.Exec(fmt.Sprintf("load data local infile %q into table t", path)) c.Assert(err, IsNil) rows = dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 1526 Table has no partition for value from column_list", "Warning 1062 Duplicate entry 'w-1' for key 'idx'") rows = dbt.mustQuery("select * from t order by id") cli.checkRows(c, rows, "w 1 1", "w 2 2", "w 3 3", "e 5 5", "e 8 8", "n 9 9") }) } func (cli *testServerClient) checkRows(c *C, rows *sql.Rows, expectedRows ...string) { buf := bytes.NewBuffer(nil) result := make([]string, 0, 2) for rows.Next() { cols, err := rows.Columns() c.Assert(err, IsNil) rawResult := make([][]byte, len(cols)) dest := make([]interface{}, len(cols)) for i := range rawResult { dest[i] = &rawResult[i] } err = rows.Scan(dest...) c.Assert(err, IsNil) buf.Reset() for i, raw := range rawResult { if i > 0 { buf.WriteString(" ") } if raw == nil { buf.WriteString("<nil>") } else { buf.WriteString(string(raw)) } } result = append(result, buf.String()) } c.Assert(strings.Join(result, "\n"), Equals, strings.Join(expectedRows, "\n")) } func (cli *testServerClient) runTestLoadData(c *C, server *Server) { // create a file and write data. path := "/tmp/load_data_test.csv" fp, err := os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) defer func() { err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) }() _, err = fp.WriteString("\n" + "xxx row1_col1 - row1_col2 1abc\n" + "xxx row2_col1 - row2_col2 \n" + "xxxy row3_col1 - row3_col2 \n" + "xxx row4_col1 - 900\n" + "xxx row5_col1 - row5_col3") c.Assert(err, IsNil) originalTxnTotalSizeLimit := kv.TxnTotalSizeLimit // If the MemBuffer can't be committed once in each batch, it will return an error like "transaction is too large". kv.TxnTotalSizeLimit = 10240 defer func() { kv.TxnTotalSizeLimit = originalTxnTotalSizeLimit }() // support ClientLocalFiles capability cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("set @@tidb_dml_batch_size = 3") dbt.mustExec("create table test (a varchar(255), b varchar(255) default 'default value', c int not null auto_increment, primary key(c))") dbt.mustExec("create view v1 as select 1") dbt.mustExec("create sequence s1") // can't insert into views (in TiDB) or sequences. issue #20880 _, err = dbt.db.Exec("load data local infile '/tmp/load_data_test.csv' into table v1") dbt.Assert(err, NotNil) dbt.Assert(err.Error(), Equals, "Error 1105: can only load data into base tables") _, err = dbt.db.Exec("load data local infile '/tmp/load_data_test.csv' into table s1") dbt.Assert(err, NotNil) dbt.Assert(err.Error(), Equals, "Error 1105: can only load data into base tables") rs, err1 := dbt.db.Exec("load data local infile '/tmp/load_data_test.csv' into table test") dbt.Assert(err1, IsNil) lastID, err1 := rs.LastInsertId() dbt.Assert(err1, IsNil) dbt.Assert(lastID, Equals, int64(1)) affectedRows, err1 := rs.RowsAffected() dbt.Assert(err1, IsNil) dbt.Assert(affectedRows, Equals, int64(5)) var ( a string b string bb sql.NullString cc int ) rows := dbt.mustQuery("select * from test") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &bb, &cc) dbt.Check(err, IsNil) dbt.Check(a, DeepEquals, "") dbt.Check(bb.String, DeepEquals, "") dbt.Check(cc, DeepEquals, 1) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "xxx row2_col1") dbt.Check(b, DeepEquals, "- row2_col2") dbt.Check(cc, DeepEquals, 2) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "xxxy row3_col1") dbt.Check(b, DeepEquals, "- row3_col2") dbt.Check(cc, DeepEquals, 3) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "xxx row4_col1") dbt.Check(b, DeepEquals, "- ") dbt.Check(cc, DeepEquals, 4) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "xxx row5_col1") dbt.Check(b, DeepEquals, "- ") dbt.Check(cc, DeepEquals, 5) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) rows.Close() // specify faileds and lines dbt.mustExec("delete from test") dbt.mustExec("set @@tidb_dml_batch_size = 3") rs, err = dbt.db.Exec("load data local infile '/tmp/load_data_test.csv' into table test fields terminated by '\t- ' lines starting by 'xxx ' terminated by '\n'") dbt.Assert(err, IsNil) lastID, err = rs.LastInsertId() dbt.Assert(err, IsNil) dbt.Assert(lastID, Equals, int64(6)) affectedRows, err = rs.RowsAffected() dbt.Assert(err, IsNil) dbt.Assert(affectedRows, Equals, int64(4)) rows = dbt.mustQuery("select * from test") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "row1_col1") dbt.Check(b, DeepEquals, "row1_col2\t1abc") dbt.Check(cc, DeepEquals, 6) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "row2_col1") dbt.Check(b, DeepEquals, "row2_col2\t") dbt.Check(cc, DeepEquals, 7) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "row4_col1") dbt.Check(b, DeepEquals, "\t\t900") dbt.Check(cc, DeepEquals, 8) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &cc) c.Assert(err, IsNil) dbt.Check(a, DeepEquals, "row5_col1") dbt.Check(b, DeepEquals, "\trow5_col3") dbt.Check(cc, DeepEquals, 9) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) // infile size more than a packet size(16K) dbt.mustExec("delete from test") _, err = fp.WriteString("\n") dbt.Assert(err, IsNil) for i := 6; i <= 800; i++ { _, err = fp.WriteString(fmt.Sprintf("xxx row%d_col1 - row%d_col2\n", i, i)) dbt.Assert(err, IsNil) } dbt.mustExec("set @@tidb_dml_batch_size = 3") rs, err = dbt.db.Exec("load data local infile '/tmp/load_data_test.csv' into table test fields terminated by '\t- ' lines starting by 'xxx ' terminated by '\n'") dbt.Assert(err, IsNil) lastID, err = rs.LastInsertId() dbt.Assert(err, IsNil) dbt.Assert(lastID, Equals, int64(10)) affectedRows, err = rs.RowsAffected() dbt.Assert(err, IsNil) dbt.Assert(affectedRows, Equals, int64(799)) rows = dbt.mustQuery("select * from test") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) // don't support lines terminated is "" dbt.mustExec("set @@tidb_dml_batch_size = 3") _, err = dbt.db.Exec("load data local infile '/tmp/load_data_test.csv' into table test lines terminated by ''") dbt.Assert(err, NotNil) // infile doesn't exist dbt.mustExec("set @@tidb_dml_batch_size = 3") _, err = dbt.db.Exec("load data local infile '/tmp/nonexistence.csv' into table test") dbt.Assert(err, NotNil) }) err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test mixed unenclosed and enclosed fields. _, err = fp.WriteString( "\"abc\",123\n" + "def,456,\n" + "hig,\"789\",") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("create table test (str varchar(10) default null, i int default null)") dbt.mustExec("set @@tidb_dml_batch_size = 3") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table test FIELDS TERMINATED BY ',' enclosed by '"'`) dbt.Assert(err1, IsNil) var ( str string id int ) rows := dbt.mustQuery("select * from test") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&str, &id) dbt.Check(err, IsNil) dbt.Check(str, DeepEquals, "abc") dbt.Check(id, DeepEquals, 123) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&str, &id) c.Assert(err, IsNil) dbt.Check(str, DeepEquals, "def") dbt.Check(id, DeepEquals, 456) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&str, &id) c.Assert(err, IsNil) dbt.Check(str, DeepEquals, "hig") dbt.Check(id, DeepEquals, 789) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) dbt.mustExec("delete from test") }) err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test irregular csv file. _, err = fp.WriteString( `,\N,NULL,,` + "\n" + "00,0,000000,,\n" + `2003-03-03, 20030303,030303,\N` + "\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("create table test (a date, b date, c date not null, d date)") dbt.mustExec("set @@tidb_dml_batch_size = 3") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table test FIELDS TERMINATED BY ','`) dbt.Assert(err1, IsNil) var ( a sql.NullString b sql.NullString d sql.NullString c sql.NullString ) rows := dbt.mustQuery("select * from test") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c, &d) dbt.Check(err, IsNil) dbt.Check(a.String, Equals, "0000-00-00") dbt.Check(b.String, Equals, "") dbt.Check(c.String, Equals, "0000-00-00") dbt.Check(d.String, Equals, "0000-00-00") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c, &d) dbt.Check(err, IsNil) dbt.Check(a.String, Equals, "0000-00-00") dbt.Check(b.String, Equals, "0000-00-00") dbt.Check(c.String, Equals, "0000-00-00") dbt.Check(d.String, Equals, "0000-00-00") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c, &d) dbt.Check(err, IsNil) dbt.Check(a.String, Equals, "2003-03-03") dbt.Check(b.String, Equals, "2003-03-03") dbt.Check(c.String, Equals, "2003-03-03") dbt.Check(d.String, Equals, "") dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) dbt.mustExec("delete from test") }) err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test double enclosed. _, err = fp.WriteString( `"field1","field2"` + "\n" + `"a""b","cd""ef"` + "\n" + `"a"b",c"d"e` + "\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("create table test (a varchar(20), b varchar(20))") dbt.mustExec("set @@tidb_dml_batch_size = 3") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table test FIELDS TERMINATED BY ',' enclosed by '"'`) dbt.Assert(err1, IsNil) var ( a sql.NullString b sql.NullString ) rows := dbt.mustQuery("select * from test") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b) dbt.Check(err, IsNil) dbt.Check(a.String, Equals, "field1") dbt.Check(b.String, Equals, "field2") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b) c.Assert(err, IsNil) dbt.Check(a.String, Equals, `a"b`) dbt.Check(b.String, Equals, `cd"ef`) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b) c.Assert(err, IsNil) dbt.Check(a.String, Equals, `a"b`) dbt.Check(b.String, Equals, `c"d"e`) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) dbt.mustExec("delete from test") }) err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test OPTIONALLY _, err = fp.WriteString( `"a,b,c` + "\n" + `"1",2,"3"` + "\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true }, "LoadData", func(dbt *DBTest) { dbt.mustExec("create table test (id INT NOT NULL PRIMARY KEY, b INT, c varchar(10))") dbt.mustExec("set @@tidb_dml_batch_size = 3") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table test FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' IGNORE 1 LINES`) dbt.Assert(err1, IsNil) var ( a int b int c sql.NullString ) rows := dbt.mustQuery("select * from test") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c) dbt.Check(err, IsNil) dbt.Check(a, Equals, 1) dbt.Check(b, Equals, 2) dbt.Check(c.String, Equals, "3") dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) dbt.mustExec("delete from test") }) // unsupport ClientLocalFiles capability server.capability ^= tmysql.ClientLocalFiles cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true }, "LoadData", func(dbt *DBTest) { dbt.mustExec("create table test (a varchar(255), b varchar(255) default 'default value', c int not null auto_increment, primary key(c))") dbt.mustExec("set @@tidb_dml_batch_size = 3") _, err = dbt.db.Exec("load data local infile '/tmp/load_data_test.csv' into table test") dbt.Assert(err, NotNil) checkErrorCode(c, err, errno.ErrNotAllowedCommand) }) server.capability |= tmysql.ClientLocalFiles err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test OPTIONALLY _, err = fp.WriteString( `1,2` + "\n" + `3,4` + "\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("drop table if exists pn") dbt.mustExec("create table pn (c1 int, c2 int)") dbt.mustExec("set @@tidb_dml_batch_size = 1") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table pn FIELDS TERMINATED BY ','`) dbt.Assert(err1, IsNil) var ( a int b int ) rows := dbt.mustQuery("select * from pn") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b) dbt.Check(err, IsNil) dbt.Check(a, Equals, 1) dbt.Check(b, Equals, 2) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b) dbt.Check(err, IsNil) dbt.Check(a, Equals, 3) dbt.Check(b, Equals, 4) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) // fail error processing test dbt.Assert(failpoint.Enable("github.com/pingcap/tidb/executor/commitOneTaskErr", "return"), IsNil) _, err1 = dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table pn FIELDS TERMINATED BY ','`) mysqlErr, ok := err1.(*mysql.MySQLError) dbt.Assert(ok, IsTrue) dbt.Assert(mysqlErr.Message, Equals, "mock commit one task error") dbt.Assert(failpoint.Disable("github.com/pingcap/tidb/executor/commitOneTaskErr"), IsNil) dbt.mustExec("drop table if exists pn") }) err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test Column List Specification _, err = fp.WriteString( `1,2` + "\n" + `3,4` + "\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("drop table if exists pn") dbt.mustExec("create table pn (c1 int, c2 int)") dbt.mustExec("set @@tidb_dml_batch_size = 1") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table pn FIELDS TERMINATED BY ',' (c1, c2)`) dbt.Assert(err1, IsNil) var ( a int b int ) rows := dbt.mustQuery("select * from pn") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b) dbt.Check(err, IsNil) dbt.Check(a, Equals, 1) dbt.Check(b, Equals, 2) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b) dbt.Check(err, IsNil) dbt.Check(a, Equals, 3) dbt.Check(b, Equals, 4) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) dbt.mustExec("drop table if exists pn") }) err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test Column List Specification _, err = fp.WriteString( `1,2,3` + "\n" + `4,5,6` + "\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("drop table if exists pn") dbt.mustExec("create table pn (c1 int, c2 int, c3 int)") dbt.mustExec("set @@tidb_dml_batch_size = 1") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table pn FIELDS TERMINATED BY ',' (c1, @dummy)`) dbt.Assert(err1, IsNil) var ( a int b sql.NullString c sql.NullString ) rows := dbt.mustQuery("select * from pn") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c) dbt.Check(err, IsNil) dbt.Check(a, Equals, 1) dbt.Check(b.String, Equals, "") dbt.Check(c.String, Equals, "") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c) dbt.Check(err, IsNil) dbt.Check(a, Equals, 4) dbt.Check(b.String, Equals, "") dbt.Check(c.String, Equals, "") dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) dbt.mustExec("drop table if exists pn") }) err = fp.Close() c.Assert(err, IsNil) err = os.Remove(path) c.Assert(err, IsNil) fp, err = os.Create(path) c.Assert(err, IsNil) c.Assert(fp, NotNil) // Test Input Preprocessing _, err = fp.WriteString( `1,2,3` + "\n" + `4,5,6` + "\n") c.Assert(err, IsNil) cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.AllowAllFiles = true config.Params["sql_mode"] = "''" }, "LoadData", func(dbt *DBTest) { dbt.mustExec("drop table if exists pn") dbt.mustExec("create table pn (c1 int, c2 int, c3 int)") dbt.mustExec("set @@tidb_dml_batch_size = 1") _, err1 := dbt.db.Exec(`load data local infile '/tmp/load_data_test.csv' into table pn FIELDS TERMINATED BY ',' (c1, @val1, @val2) SET c3 = @val2 * 100, c2 = CAST(@val1 AS UNSIGNED)`) dbt.Assert(err1, IsNil) var ( a int b int c int ) rows := dbt.mustQuery("select * from pn") dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c) dbt.Check(err, IsNil) dbt.Check(a, Equals, 1) dbt.Check(b, Equals, 2) dbt.Check(c, Equals, 300) dbt.Check(rows.Next(), IsTrue, Commentf("unexpected data")) err = rows.Scan(&a, &b, &c) dbt.Check(err, IsNil) dbt.Check(a, Equals, 4) dbt.Check(b, Equals, 5) dbt.Check(c, Equals, 600) dbt.Check(rows.Next(), IsFalse, Commentf("unexpected data")) dbt.mustExec("drop table if exists pn") }) } func (cli *testServerClient) runTestConcurrentUpdate(c *C) { dbName := "Concurrent" cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.Params["sql_mode"] = "''" }, dbName, func(dbt *DBTest) { dbt.mustExec("drop table if exists test2") dbt.mustExec("create table test2 (a int, b int)") dbt.mustExec("insert test2 values (1, 1)") dbt.mustExec("set @@tidb_disable_txn_auto_retry = 0") txn1, err := dbt.db.Begin() c.Assert(err, IsNil) _, err = txn1.Exec(fmt.Sprintf("USE `%s`;", dbName)) c.Assert(err, IsNil) txn2, err := dbt.db.Begin() c.Assert(err, IsNil) _, err = txn2.Exec(fmt.Sprintf("USE `%s`;", dbName)) c.Assert(err, IsNil) _, err = txn2.Exec("update test2 set a = a + 1 where b = 1") c.Assert(err, IsNil) err = txn2.Commit() c.Assert(err, IsNil) _, err = txn1.Exec("update test2 set a = a + 1 where b = 1") c.Assert(err, IsNil) err = txn1.Commit() c.Assert(err, IsNil) }) } func (cli *testServerClient) runTestExplainForConn(c *C) { cli.runTestsOnNewDB(c, nil, "explain_for_conn", func(dbt *DBTest) { dbt.mustExec("drop table if exists t") dbt.mustExec("create table t (a int key, b int)") dbt.mustExec("insert t values (1, 1)") rows := dbt.mustQuery("select connection_id();") c.Assert(rows.Next(), IsTrue) var connID int64 err := rows.Scan(&connID) c.Assert(err, IsNil) c.Assert(rows.Close(), IsNil) dbt.mustQuery("select * from t where a=1") rows = dbt.mustQuery("explain for connection " + strconv.Itoa(int(connID))) c.Assert(rows.Next(), IsTrue) row := make([]string, 9) err = rows.Scan(&row[0], &row[1], &row[2], &row[3], &row[4], &row[5], &row[6], &row[7], &row[8]) c.Assert(err, IsNil) c.Assert(strings.Join(row, ","), Matches, "Point_Get_1,1.00,1,root,table:t,time.*loop.*handle:1.*") c.Assert(rows.Close(), IsNil) }) } func (cli *testServerClient) runTestErrorCode(c *C) { cli.runTestsOnNewDB(c, nil, "ErrorCode", func(dbt *DBTest) { dbt.mustExec("create table test (c int PRIMARY KEY);") dbt.mustExec("insert into test values (1);") txn1, err := dbt.db.Begin() c.Assert(err, IsNil) _, err = txn1.Exec("insert into test values(1)") c.Assert(err, IsNil) err = txn1.Commit() checkErrorCode(c, err, errno.ErrDupEntry) // Schema errors txn2, err := dbt.db.Begin() c.Assert(err, IsNil) _, err = txn2.Exec("use db_not_exists;") checkErrorCode(c, err, errno.ErrBadDB) _, err = txn2.Exec("select * from tbl_not_exists;") checkErrorCode(c, err, errno.ErrNoSuchTable) _, err = txn2.Exec("create database test;") // Make tests stable. Some times the error may be the ErrInfoSchemaChanged. checkErrorCode(c, err, errno.ErrDBCreateExists, errno.ErrInfoSchemaChanged) _, err = txn2.Exec("create database aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;") checkErrorCode(c, err, errno.ErrTooLongIdent, errno.ErrInfoSchemaChanged) _, err = txn2.Exec("create table test (c int);") checkErrorCode(c, err, errno.ErrTableExists, errno.ErrInfoSchemaChanged) _, err = txn2.Exec("drop table unknown_table;") checkErrorCode(c, err, errno.ErrBadTable, errno.ErrInfoSchemaChanged) _, err = txn2.Exec("drop database unknown_db;") checkErrorCode(c, err, errno.ErrDBDropExists, errno.ErrInfoSchemaChanged) _, err = txn2.Exec("create table aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa (a int);") checkErrorCode(c, err, errno.ErrTooLongIdent, errno.ErrInfoSchemaChanged) _, err = txn2.Exec("create table long_column_table (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa int);") checkErrorCode(c, err, errno.ErrTooLongIdent, errno.ErrInfoSchemaChanged) _, err = txn2.Exec("alter table test add aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa int;") checkErrorCode(c, err, errno.ErrTooLongIdent, errno.ErrInfoSchemaChanged) // Optimizer errors _, err = txn2.Exec("select *, * from test;") checkErrorCode(c, err, errno.ErrInvalidWildCard) _, err = txn2.Exec("select row(1, 2) > 1;") checkErrorCode(c, err, errno.ErrOperandColumns) _, err = txn2.Exec("select * from test order by row(c, c);") checkErrorCode(c, err, errno.ErrOperandColumns) // Variable errors _, err = txn2.Exec("select @@unknown_sys_var;") checkErrorCode(c, err, errno.ErrUnknownSystemVariable) _, err = txn2.Exec("set @@unknown_sys_var='1';") checkErrorCode(c, err, errno.ErrUnknownSystemVariable) // Expression errors _, err = txn2.Exec("select greatest(2);") checkErrorCode(c, err, errno.ErrWrongParamcountToNativeFct) }) } func checkErrorCode(c *C, e error, codes ...uint16) { me, ok := e.(*mysql.MySQLError) c.Assert(ok, IsTrue, Commentf("err: %v", e)) if len(codes) == 1 { c.Assert(me.Number, Equals, codes[0]) } isMatchCode := false for _, code := range codes { if me.Number == code { isMatchCode = true break } } c.Assert(isMatchCode, IsTrue, Commentf("got err %v, expected err codes %v", me, codes)) } func (cli *testServerClient) runTestAuth(c *C) { cli.runTests(c, nil, func(dbt *DBTest) { dbt.mustExec(`CREATE USER 'authtest'@'%' IDENTIFIED BY '123';`) dbt.mustExec(`CREATE ROLE 'authtest_r1'@'%';`) dbt.mustExec(`GRANT ALL on test.* to 'authtest'`) dbt.mustExec(`GRANT authtest_r1 to 'authtest'`) dbt.mustExec(`SET DEFAULT ROLE authtest_r1 TO authtest`) }) cli.runTests(c, func(config *mysql.Config) { config.User = "authtest" config.Passwd = "123" }, func(dbt *DBTest) { dbt.mustExec(`USE information_schema;`) }) db, err := sql.Open("mysql", cli.getDSN(func(config *mysql.Config) { config.User = "authtest" config.Passwd = "456" })) c.Assert(err, IsNil) _, err = db.Query("USE information_schema;") c.Assert(err, NotNil, Commentf("Wrong password should be failed")) err = db.Close() c.Assert(err, IsNil) // Test for loading active roles. db, err = sql.Open("mysql", cli.getDSN(func(config *mysql.Config) { config.User = "authtest" config.Passwd = "123" })) c.Assert(err, IsNil) rows, err := db.Query("select current_role;") c.Assert(err, IsNil) c.Assert(rows.Next(), IsTrue) var outA string err = rows.Scan(&outA) c.Assert(err, IsNil) c.Assert(outA, Equals, "`authtest_r1`@`%`") err = db.Close() c.Assert(err, IsNil) // Test login use IP that not exists in mysql.user. cli.runTests(c, nil, func(dbt *DBTest) { dbt.mustExec(`CREATE USER 'authtest2'@'localhost' IDENTIFIED BY '123';`) dbt.mustExec(`GRANT ALL on test.* to 'authtest2'@'localhost'`) }) cli.runTests(c, func(config *mysql.Config) { config.User = "authtest2" config.Passwd = "123" }, func(dbt *DBTest) { dbt.mustExec(`USE information_schema;`) }) } func (cli *testServerClient) runTestIssue3662(c *C) { db, err := sql.Open("mysql", cli.getDSN(func(config *mysql.Config) { config.DBName = "non_existing_schema" })) c.Assert(err, IsNil) go func() { err := db.Close() c.Assert(err, IsNil) }() // According to documentation, "Open may just validate its arguments without // creating a connection to the database. To verify that the data source name // is valid, call Ping." err = db.Ping() c.Assert(err, NotNil) c.Assert(err.Error(), Equals, "Error 1049: Unknown database 'non_existing_schema'") } func (cli *testServerClient) runTestIssue3680(c *C) { db, err := sql.Open("mysql", cli.getDSN(func(config *mysql.Config) { config.User = "non_existing_user" })) c.Assert(err, IsNil) go func() { err := db.Close() c.Assert(err, IsNil) }() // According to documentation, "Open may just validate its arguments without // creating a connection to the database. To verify that the data source name // is valid, call Ping." err = db.Ping() c.Assert(err, NotNil) c.Assert(err.Error(), Equals, "Error 1045: Access denied for user 'non_existing_user'@'127.0.0.1' (using password: NO)") } func (cli *testServerClient) runTestIssue22646(c *C) { cli.runTests(c, nil, func(dbt *DBTest) { c1 := make(chan string, 1) go func() { dbt.mustExec(``) // empty query. c1 <- "success" }() select { case res := <-c1: fmt.Println(res) case <-time.After(30 * time.Second): panic("read empty query statement timed out.") } }) } func (cli *testServerClient) runTestIssue3682(c *C) { cli.runTests(c, nil, func(dbt *DBTest) { dbt.mustExec(`CREATE USER 'issue3682'@'%' IDENTIFIED BY '123';`) dbt.mustExec(`GRANT ALL on test.* to 'issue3682'`) dbt.mustExec(`GRANT ALL on mysql.* to 'issue3682'`) }) cli.runTests(c, func(config *mysql.Config) { config.User = "issue3682" config.Passwd = "123" }, func(dbt *DBTest) { dbt.mustExec(`USE mysql;`) }) db, err := sql.Open("mysql", cli.getDSN(func(config *mysql.Config) { config.User = "issue3682" config.Passwd = "wrong_password" config.DBName = "non_existing_schema" })) c.Assert(err, IsNil) go func() { err := db.Close() c.Assert(err, IsNil) }() err = db.Ping() c.Assert(err, NotNil) c.Assert(err.Error(), Equals, "Error 1045: Access denied for user 'issue3682'@'127.0.0.1' (using password: YES)") } func (cli *testServerClient) runTestDBNameEscape(c *C) { cli.runTests(c, nil, func(dbt *DBTest) { dbt.mustExec("CREATE DATABASE `aa-a`;") }) cli.runTests(c, func(config *mysql.Config) { config.DBName = "aa-a" }, func(dbt *DBTest) { dbt.mustExec(`USE mysql;`) dbt.mustExec("DROP DATABASE `aa-a`") }) } func (cli *testServerClient) runTestResultFieldTableIsNull(c *C) { cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.Params["sql_mode"] = "''" }, "ResultFieldTableIsNull", func(dbt *DBTest) { dbt.mustExec("drop table if exists test;") dbt.mustExec("create table test (c int);") dbt.mustExec("explain select * from test;") }) } func (cli *testServerClient) runTestStatusAPI(c *C) { resp, err := cli.fetchStatus("/status") c.Assert(err, IsNil) defer resp.Body.Close() decoder := json.NewDecoder(resp.Body) var data status err = decoder.Decode(&data) c.Assert(err, IsNil) c.Assert(data.Version, Equals, tmysql.ServerVersion) c.Assert(data.GitHash, Equals, versioninfo.TiDBGitHash) } // The golang sql driver (and most drivers) should have multi-statement // disabled by default for security reasons. Lets ensure that the behavior // is correct. func (cli *testServerClient) runFailedTestMultiStatements(c *C) { cli.runTestsOnNewDB(c, nil, "FailedMultiStatements", func(dbt *DBTest) { // Default is now OFF in new installations. // It is still WARN in upgrade installations (for now) _, err := dbt.db.Exec("SELECT 1; SELECT 1; SELECT 2; SELECT 3;") c.Assert(err.Error(), Equals, "Error 8130: client has multi-statement capability disabled. Run SET GLOBAL tidb_multi_statement_mode='ON' after you understand the security risk") // Change to WARN (legacy mode) dbt.mustExec("SET tidb_multi_statement_mode='WARN'") dbt.mustExec("CREATE TABLE `test` (`id` int(11) NOT NULL, `value` int(11) NOT NULL) ") res := dbt.mustExec("INSERT INTO test VALUES (1, 1)") count, err := res.RowsAffected() c.Assert(err, IsNil, Commentf("res.RowsAffected() returned error")) c.Assert(count, Equals, int64(1)) res = dbt.mustExec("UPDATE test SET value = 3 WHERE id = 1; UPDATE test SET value = 4 WHERE id = 1; UPDATE test SET value = 5 WHERE id = 1;") count, err = res.RowsAffected() c.Assert(err, IsNil, Commentf("res.RowsAffected() returned error")) c.Assert(count, Equals, int64(1)) rows := dbt.mustQuery("show warnings") cli.checkRows(c, rows, "Warning 8130 client has multi-statement capability disabled. Run SET GLOBAL tidb_multi_statement_mode='ON' after you understand the security risk") var out int rows = dbt.mustQuery("SELECT value FROM test WHERE id=1;") if rows.Next() { err = rows.Scan(&out) c.Assert(err, IsNil) c.Assert(out, Equals, 5) if rows.Next() { dbt.Error("unexpected data") } } else { dbt.Error("no data") } // Change to ON = Fully supported, TiDB legacy. No warnings or Errors. dbt.mustExec("SET tidb_multi_statement_mode='ON';") dbt.mustExec("DROP TABLE IF EXISTS test") dbt.mustExec("CREATE TABLE `test` (`id` int(11) NOT NULL, `value` int(11) NOT NULL) ") res = dbt.mustExec("INSERT INTO test VALUES (1, 1)") count, err = res.RowsAffected() c.Assert(err, IsNil, Commentf("res.RowsAffected() returned error")) c.Assert(count, Equals, int64(1)) res = dbt.mustExec("update test SET value = 3 WHERE id = 1; UPDATE test SET value = 4 WHERE id = 1; UPDATE test SET value = 5 WHERE id = 1;") count, err = res.RowsAffected() c.Assert(err, IsNil, Commentf("res.RowsAffected() returned error")) c.Assert(count, Equals, int64(1)) rows = dbt.mustQuery("SELECT value FROM test WHERE id=1;") if rows.Next() { err = rows.Scan(&out) c.Assert(err, IsNil) c.Assert(out, Equals, 5) if rows.Next() { dbt.Error("unexpected data") } } else { dbt.Error("no data") } }) } func (cli *testServerClient) runTestMultiStatements(c *C) { cli.runTestsOnNewDB(c, func(config *mysql.Config) { config.Params["multiStatements"] = "true" }, "MultiStatements", func(dbt *DBTest) { // Create Table dbt.mustExec("CREATE TABLE `test` (`id` int(11) NOT NULL, `value` int(11) NOT NULL) ") // Create Data res := dbt.mustExec("INSERT INTO test VALUES (1, 1)") count, err := res.RowsAffected() c.Assert(err, IsNil, Commentf("res.RowsAffected() returned error")) c.Assert(count, Equals, int64(1)) // Update res = dbt.mustExec("UPDATE test SET value = 3 WHERE id = 1; UPDATE test SET value = 4 WHERE id = 1; UPDATE test SET value = 5 WHERE id = 1;") count, err = res.RowsAffected() c.Assert(err, IsNil, Commentf("res.RowsAffected() returned error")) c.Assert(count, Equals, int64(1)) // Read var out int rows := dbt.mustQuery("SELECT value FROM test WHERE id=1;") if rows.Next() { err = rows.Scan(&out) c.Assert(err, IsNil) c.Assert(out, Equals, 5) if rows.Next() { dbt.Error("unexpected data") } } else { dbt.Error("no data") } }) } func (cli *testServerClient) runTestStmtCount(t *C) { cli.runTestsOnNewDB(t, nil, "StatementCount", func(dbt *DBTest) { originStmtCnt := getStmtCnt(string(cli.getMetrics(t))) dbt.mustExec("create table test (a int)") dbt.mustExec("insert into test values(1)") dbt.mustExec("insert into test values(2)") dbt.mustExec("insert into test values(3)") dbt.mustExec("insert into test values(4)") dbt.mustExec("insert into test values(5)") dbt.mustExec("delete from test where a = 3") dbt.mustExec("update test set a = 2 where a = 1") dbt.mustExec("select * from test") dbt.mustExec("select 2") dbt.mustExec("prepare stmt1 from 'update test set a = 1 where a = 2'") dbt.mustExec("execute stmt1") dbt.mustExec("prepare stmt2 from 'select * from test'") dbt.mustExec("execute stmt2") dbt.mustExec("replace into test(a) values(6);") currentStmtCnt := getStmtCnt(string(cli.getMetrics(t))) t.Assert(currentStmtCnt["CreateTable"], Equals, originStmtCnt["CreateTable"]+1) t.Assert(currentStmtCnt["Insert"], Equals, originStmtCnt["Insert"]+5) t.Assert(currentStmtCnt["Delete"], Equals, originStmtCnt["Delete"]+1) t.Assert(currentStmtCnt["Update"], Equals, originStmtCnt["Update"]+1) t.Assert(currentStmtCnt["Select"], Equals, originStmtCnt["Select"]+2) t.Assert(currentStmtCnt["Prepare"], Equals, originStmtCnt["Prepare"]+2) t.Assert(currentStmtCnt["Execute"], Equals, originStmtCnt["Execute"]+2) t.Assert(currentStmtCnt["Replace"], Equals, originStmtCnt["Replace"]+1) }) } func (cli *testServerClient) runTestTLSConnection(t *C, overrider configOverrider) error { dsn := cli.getDSN(overrider) db, err := sql.Open("mysql", dsn) t.Assert(err, IsNil) go func() { err := db.Close() t.Assert(err, IsNil) }() _, err = db.Exec("USE test") if err != nil { return errors.Annotate(err, "dsn:"+dsn) } return err } func (cli *testServerClient) runReloadTLS(t *C, overrider configOverrider, errorNoRollback bool) error { db, err := sql.Open("mysql", cli.getDSN(overrider)) t.Assert(err, IsNil) go func() { err := db.Close() t.Assert(err, IsNil) }() sql := "alter instance reload tls" if errorNoRollback { sql += " no rollback on error" } _, err = db.Exec(sql) return err } func (cli *testServerClient) runTestSumAvg(c *C) { cli.runTests(c, nil, func(dbt *DBTest) { dbt.mustExec("create table sumavg (a int, b decimal, c double)") dbt.mustExec("insert sumavg values (1, 1, 1)") rows := dbt.mustQuery("select sum(a), sum(b), sum(c) from sumavg") c.Assert(rows.Next(), IsTrue) var outA, outB, outC float64 err := rows.Scan(&outA, &outB, &outC) c.Assert(err, IsNil) c.Assert(outA, Equals, 1.0) c.Assert(outB, Equals, 1.0) c.Assert(outC, Equals, 1.0) rows = dbt.mustQuery("select avg(a), avg(b), avg(c) from sumavg") c.Assert(rows.Next(), IsTrue) err = rows.Scan(&outA, &outB, &outC) c.Assert(err, IsNil) c.Assert(outA, Equals, 1.0) c.Assert(outB, Equals, 1.0) c.Assert(outC, Equals, 1.0) }) } func (cli *testServerClient) getMetrics(t *C) []byte { resp, err := cli.fetchStatus("/metrics") t.Assert(err, IsNil) content, err := ioutil.ReadAll(resp.Body) t.Assert(err, IsNil) err = resp.Body.Close() t.Assert(err, IsNil) return content } func getStmtCnt(content string) (stmtCnt map[string]int) { stmtCnt = make(map[string]int) r := regexp.MustCompile("tidb_executor_statement_total{type=\"([A-Z|a-z|-]+)\"} (\\d+)") matchResult := r.FindAllStringSubmatch(content, -1) for _, v := range matchResult { cnt, _ := strconv.Atoi(v[2]) stmtCnt[v[1]] = cnt } return stmtCnt } const retryTime = 100 func (cli *testServerClient) waitUntilServerOnline() { // connect server retry := 0 for ; retry < retryTime; retry++ { time.Sleep(time.Millisecond * 10) db, err := sql.Open("mysql", cli.getDSN()) if err == nil { err = db.Close() if err != nil { panic(err) } break } } if retry == retryTime { log.Fatal("failed to connect DB in every 10 ms", zap.Int("retryTime", retryTime)) } for retry = 0; retry < retryTime; retry++ { // fetch http status resp, err := cli.fetchStatus("/status") if err == nil { _, err = ioutil.ReadAll(resp.Body) if err != nil { panic(err) } err = resp.Body.Close() if err != nil { panic(err) } break } time.Sleep(time.Millisecond * 10) } if retry == retryTime { log.Fatal("failed to connect HTTP status in every 10 ms", zap.Int("retryTime", retryTime)) } } // Client errors are only incremented when using the TiDB Server protocol, // and not internal SQL statements. Thus, this test is in the server-test suite. func (cli *testServerClient) runTestInfoschemaClientErrors(t *C) { cli.runTestsOnNewDB(t, nil, "clientErrors", func(dbt *DBTest) { clientErrors := []struct { stmt string incrementWarnings bool incrementErrors bool errCode int }{ { stmt: "SELECT 0/0", incrementWarnings: true, errCode: 1365, // div by zero }, { stmt: "CREATE TABLE test_client_errors2 (a int primary key, b int primary key)", incrementErrors: true, errCode: 1068, // multiple pkeys }, { stmt: "gibberish", incrementErrors: true, errCode: 1064, // parse error }, } sources := []string{"client_errors_summary_global", "client_errors_summary_by_user", "client_errors_summary_by_host"} for _, test := range clientErrors { for _, tbl := range sources { var errors, warnings int rows := dbt.mustQuery("SELECT SUM(error_count), SUM(warning_count) FROM information_schema."+tbl+" WHERE error_number = ? GROUP BY error_number", test.errCode) if rows.Next() { rows.Scan(&errors, &warnings) } if test.incrementErrors { errors++ } if test.incrementWarnings { warnings++ } dbt.db.Query(test.stmt) // ignore results and errors (query table) var newErrors, newWarnings int rows = dbt.mustQuery("SELECT SUM(error_count), SUM(warning_count) FROM information_schema."+tbl+" WHERE error_number = ? GROUP BY error_number", test.errCode) if rows.Next() { rows.Scan(&newErrors, &newWarnings) } dbt.Check(newErrors, Equals, errors) dbt.Check(newWarnings, Equals, warnings) } } }) }
[ "\"log_level\"" ]
[]
[ "log_level" ]
[]
["log_level"]
go
1
0
demos/TD3/GraphDrive-Hard(SR)/baseline.py
# Read this guide for how to use this script: https://medium.com/distributed-computing-with-ray/intro-to-rllib-example-environments-3a113f532c70 import os os.environ["TUNE_RESULT_DIR"] = 'tmp/ray_results' import multiprocessing import json import shutil import ray import time from xarl.utils.workflow import train from ray.rllib.agents.ddpg.td3 import TD3Trainer, TD3_DEFAULT_CONFIG from environments import * from ray.rllib.models import ModelCatalog from xarl.models.ddpg import TFAdaptiveMultiHeadDDPG # # ModelCatalog.register_custom_model("adaptive_multihead_network", TFAdaptiveMultiHeadDDPG) # SELECT_ENV = "CescoDrive-V1" SELECT_ENV = "GraphDrive-Hard-Sparse" CONFIG = TD3_DEFAULT_CONFIG.copy() CONFIG.update({ # "model": { # this is for GraphDrive and GridDrive # "custom_model": "adaptive_multihead_network", # }, # "preprocessor_pref": "rllib", # this prevents reward clipping on Atari and other weird issues when running from checkpoints "seed": 42, # This makes experiments reproducible. "rollout_fragment_length": 2**6, # Divide episodes into fragments of this many steps each during rollouts. Default is 1. "train_batch_size": 2**8, # Number of transitions per train-batch. Default is: 100 for TD3, 256 for SAC and DDPG, 32 for DQN, 500 for APPO. # "batch_mode": "truncate_episodes", # For some clustering schemes (e.g. extrinsic_reward, moving_best_extrinsic_reward, etc..) it has to be equal to 'complete_episodes', otherwise it can also be 'truncate_episodes'. ########################### "prioritized_replay": True, # Whether to replay batches with the highest priority/importance/relevance for the agent. 'buffer_size': 2**14, # Size of the experience buffer. Default 50000 "prioritized_replay_alpha": 0.6, "prioritized_replay_beta": 0.4, # The smaller, the stronger is over-sampling "prioritized_replay_eps": 1e-6, "learning_starts": 2**14, # How many steps of the model to sample before learning starts. ########################### "gamma": 0.999, # We use an higher gamma to extend the MDP's horizon; optimal agency on GraphDrive requires a longer horizon. "tau": 1e-4, ################################## }) CONFIG["callbacks"] = CustomEnvironmentCallbacks #################################################################################### #################################################################################### ray.shutdown() ray.init(ignore_reinit_error=True) train(TD3Trainer, CONFIG, SELECT_ENV, test_every_n_step=4e7, stop_training_after_n_step=4e7)
[]
[]
[ "TUNE_RESULT_DIR" ]
[]
["TUNE_RESULT_DIR"]
python
1
0
manage.py
#!/usr/bin/env python """Django's command-line utility for administrative tasks.""" import os import sys def main(): os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'PersonalWebsite2.settings') try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?" ) from exc execute_from_command_line(sys.argv) if __name__ == '__main__': main()
[]
[]
[]
[]
[]
python
0
0
git-bark/src/git_bark/__main__.py
"""Git repository information consists of: 1. Files in the `.git` repository directory 2. Files in the working tree Backing up a git repository means persisting it in a way so it can be recovered later. There are several possible approaches, with different trade-offs: 1. `git bundle create` - the resulting bundle does not include modified files in the working tree, `.git/hooks`, `.git/config`, `.git/info/*`, or the reflog. 2. `git clone --mirror` - this does not include repository-local files and is also pickier about which objects it copes. 3. backup the working tree and `.git` file/directory - this will likely copy build artifacts (there can be a lot). What build artifacts to exclude is going to vary by project, and some backup applications (duplicity, rclone, restic) don't seem to support directory-specific exclude files (like reading `.gitignore`). 4. backup just the `.git` file/directory - this does not include modified files in the working tree. This script improves the `.git` directory backup approach, saving all modifications to the working tree to the repository. The regular index is not modified, so in-progress rebase/merge/staging is not interrupted. Any ignored files will not be included. """ import argparse import os import subprocess import sys import tempfile import textwrap from contextlib import contextmanager from pathlib import Path from typing import Iterable, List, NamedTuple, Optional class OutputPrintingError(subprocess.CalledProcessError): def __init__(self, exc: subprocess.CalledProcessError): super().__init__(exc.returncode, exc.cmd, exc.output, exc.stderr) def __str__(self): # Already has command and exit code/signal. base_text = super().__str__() fields = [] if self.output is not None: printable_output = self.output.decode("utf-8", errors="replace") output = textwrap.indent(printable_output, " ") fields.append(f"output:\n{output}") if self.stderr is not None: printable_stderr = self.stderr.decode("utf-8", errors="replace") stderr = textwrap.indent(printable_stderr, " ") fields.append(f"stderr:\n{stderr}") if fields: field_text = textwrap.indent("\n".join(fields), " ") return f"{base_text}\n{field_text}" return base_text @contextmanager def traced_error_output(): try: yield except subprocess.CalledProcessError as e: raise OutputPrintingError(e).with_traceback(e.__traceback__) from None def git(args, **kwargs) -> subprocess.CompletedProcess: args.insert(0, "git") with traced_error_output(): return subprocess.run( args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True, **kwargs ) def git_ref_exists(name: str) -> bool: try: git(["show-ref", "--quiet", "--verify", name]) except subprocess.CalledProcessError as e: if e.returncode == 1: return False raise else: return True # Any refs under refs/worktree are worktree-specific, and behavior is exactly like we'd # expect: # - per-worktree refs (worktrees/<name>/refs/... or refs/...) # - per-worktree reflogs (worktrees/<name>/logs/... or logs/...) BACKUP_REF = "refs/worktree/backup" def backup() -> None: """Given a (possibly dirty) worktree, back it up to the repository. """ # Create a new tree object. with tempfile.TemporaryDirectory() as d: index_file = Path(d) / "INDEX" env = os.environ.copy() env.update({"GIT_INDEX_FILE": str(index_file)}) subprocess.run(["git", "add", "--all"], env=env, check=True) result = git(["write-tree"], env=env) tree_id = result.stdout.decode("utf-8").strip() result = git(["cat-file", "tree", tree_id]) if not result.stdout.strip(): # We cannot check out an empty tree, so do nothing. return if git_ref_exists(BACKUP_REF): result = git(["show", "--quiet", "--pretty=format:%T", BACKUP_REF]) current_tree_id = result.stdout.decode("utf-8").strip() if current_tree_id == tree_id: # If the backup is already current, don't make a new commit. return message = b"backup" result = git(["commit-tree", "--no-gpg-sign", tree_id], input=message) commit_id = result.stdout.decode("utf-8").strip() git(["update-ref", "-m", "new backup", "--create-reflog", BACKUP_REF, commit_id]) def _parse_ls_files_z(output: bytes) -> Iterable[str]: output = output.rstrip(b"\0") if not output: return records = output.split(b"\0") for record in records: _perms, _hash, _stage, filename = record.decode("utf-8").split(maxsplit=3) yield filename class StatusEntry(NamedTuple): state_1: str state_2: str path: str orig_path: Optional[str] MULTI_FIELD_STATES = {"C", "R"} def _parse_status_z(output: bytes) -> Iterable[StatusEntry]: output = output.rstrip(b"\0") # No change in index or working tree. if not output: return fields = iter(output.split(b"\0")) # field is the first part of an entry, i.e. XY PATH for field in fields: decoded_field = field.decode("utf-8") state_1, state_2, path = decoded_field[0], decoded_field[1], decoded_field[3:] orig_path = None if state_1 in MULTI_FIELD_STATES or state_2 in MULTI_FIELD_STATES: orig_path = next(fields).decode("utf-8") yield StatusEntry(state_1, state_2, path, orig_path) def restore() -> None: """Given a worktree that has been backed up, restore it. "Backed up" means: 1. `backup` was executed on the worktree 2. git knows how to locate the repository 3. the worktree 3. the current state of the provided `path` is that the copied `.git` directory/file is present and any other files present in the worktree can be disregarded in favor of the backed up working tree state. """ # Our goal is to support a worktree with no (consequential) contents. This means # no added/updated/renamed/untracked files. # git status alone doesn't let us differentiate between unmerged paths and paths that # are different from the index, so we retrieve the unmerged paths separately. result = git(["rev-parse", "--show-toplevel"]) worktree_dir = Path(result.stdout.decode("utf-8").rstrip("\n")) # -z: NUL-terminated result = git(["ls-files", "-z", "--unmerged"]) unmerged_paths = set(_parse_ls_files_z(result.stdout)) for path in unmerged_paths: if (worktree_dir / path).exists(): raise RuntimeError("Cannot restore worktree with unresolved paths present") # --no-optional-locks: Do not touch the index. # -z: NUL-separated fields/NUL-terminated records. result = git(["--no-optional-locks", "status", "-z"]) for entry in _parse_status_z(result.stdout): if entry.path in unmerged_paths: continue # Relative to the index, all files must be considered deleted. if entry.state_2 != "D": raise RuntimeError("Working tree must not have any files!") if not git_ref_exists(BACKUP_REF): # No ref, no action. return with tempfile.TemporaryDirectory() as d: index_file = Path(d) / "INDEX" env = os.environ.copy() # Temporarily set git index to a different location so we don't clobber the existing one. env.update({"GIT_INDEX_FILE": str(index_file)}) git(["checkout", BACKUP_REF, "."], env=env) def main(argv: List[str] = sys.argv[1:]): parser = argparse.ArgumentParser( description="Backup in-progress git repository files" ) subparsers = parser.add_subparsers( description="command", dest="command", required=True ) backup_parser = subparsers.add_parser("backup") backup_parser.set_defaults(func=backup) restore_parser = subparsers.add_parser("restore") restore_parser.set_defaults(func=restore) args = parser.parse_args(argv) args.func() if __name__ == "__main__": main()
[]
[]
[]
[]
[]
python
0
0
uta/__init__.py
import pkg_resources import logging import os import warnings from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from uta.exceptions import * from uta import models try: __version__ = pkg_resources.get_distribution(__package__).version except pkg_resources.DistributionNotFound as e: warnings.warn( "can't get __version__ because %s package isn't installed" % __package__, Warning) __version__ = None public_db_url = "postgresql://uta_public:[email protected]/uta" default_db_url = os.environ.get("UTA_DB_URL", public_db_url) def connect(db_url=default_db_url): """ Connect to a UTA database instance and return a UTA0 interface instance. When called with an explicit db_url argument, that db_url is used for connecting. When called without an explicit argument, the function default is determined by the environment variable UTA_DB_URL if it exists, or bdi.sources.uta0.public_db_url. The format of the db_url is driver://user:pass@host/database (the same as that used by SQLAlchemy). Examples: A remote public postgresql database: postgresql://uta_public:[email protected]/uta' A local postgresql database: postgresql://localhost/uta A local SQLite database: sqlite:////tmp/uta-0.0.5.db SQLite database snapshots are available at: `https://bitbucket.org/biocommons/uta/downloads`_ """ # TODO: Verify schema version engine = create_engine(db_url) Session = sessionmaker(bind=engine) session = Session() logger = logging.getLogger(__name__) logger.info("connected to " + db_url) return session # <LICENSE> # Copyright 2014 UTA Contributors (https://bitbucket.org/biocommons/uta) ## # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at ## # http://www.apache.org/licenses/LICENSE-2.0 ## # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # </LICENSE>
[]
[]
[ "UTA_DB_URL" ]
[]
["UTA_DB_URL"]
python
1
0
votepizza/votepizza/asgi.py
""" ASGI config for votepizza project. It exposes the ASGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/ """ import os from django.core.asgi import get_asgi_application os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'votepizza.settings') application = get_asgi_application()
[]
[]
[]
[]
[]
python
0
0
app/interface/main/activity/dao/like/dao_test.go
package like import ( "flag" "go-common/app/interface/main/activity/conf" "os" "testing" ) var ( d *Dao ) func TestMain(m *testing.M) { if os.Getenv("DEPLOY_ENV") != "" { flag.Set("app_id", "main.web-svr.activity") flag.Set("conf_token", "22edc93e2998bf0cb0bbee661b03d41f") flag.Set("tree_id", "2873") flag.Set("conf_version", "docker-1") flag.Set("deploy_env", "uat") flag.Set("conf_host", "config.bilibili.co") flag.Set("conf_path", "/tmp") flag.Set("region", "sh") flag.Set("zone", "sh001") } else { flag.Set("conf", "../../cmd/activity-test.toml") } flag.Parse() if err := conf.Init(); err != nil { panic(err) } d = New(conf.Conf) os.Exit(m.Run()) }
[ "\"DEPLOY_ENV\"" ]
[]
[ "DEPLOY_ENV" ]
[]
["DEPLOY_ENV"]
go
1
0
src/syscall/syscall_unix_test.go
// Copyright 2013 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // +build darwin dragonfly freebsd linux netbsd openbsd solaris package syscall_test import ( "flag" "fmt" "internal/testenv" "io" "io/ioutil" "net" "os" "os/exec" "path/filepath" "runtime" "syscall" "testing" "time" ) // Tests that below functions, structures and constants are consistent // on all Unix-like systems. func _() { // program scheduling priority functions and constants var ( _ func(int, int, int) error = syscall.Setpriority _ func(int, int) (int, error) = syscall.Getpriority ) const ( _ int = syscall.PRIO_USER _ int = syscall.PRIO_PROCESS _ int = syscall.PRIO_PGRP ) // termios constants const ( _ int = syscall.TCIFLUSH _ int = syscall.TCIOFLUSH _ int = syscall.TCOFLUSH ) // fcntl file locking structure and constants var ( _ = syscall.Flock_t{ Type: int16(0), Whence: int16(0), Start: int64(0), Len: int64(0), Pid: int32(0), } ) const ( _ = syscall.F_GETLK _ = syscall.F_SETLK _ = syscall.F_SETLKW ) } // TestFcntlFlock tests whether the file locking structure matches // the calling convention of each kernel. // On some Linux systems, glibc uses another set of values for the // commands and translates them to the correct value that the kernel // expects just before the actual fcntl syscall. As Go uses raw // syscalls directly, it must use the real value, not the glibc value. // Thus this test also verifies that the Flock_t structure can be // roundtripped with F_SETLK and F_GETLK. func TestFcntlFlock(t *testing.T) { if runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") { t.Skip("skipping; no child processes allowed on iOS") } flock := syscall.Flock_t{ Type: syscall.F_WRLCK, Start: 31415, Len: 271828, Whence: 1, } if os.Getenv("GO_WANT_HELPER_PROCESS") == "" { // parent tempDir, err := ioutil.TempDir("", "TestFcntlFlock") if err != nil { t.Fatalf("Failed to create temp dir: %v", err) } name := filepath.Join(tempDir, "TestFcntlFlock") fd, err := syscall.Open(name, syscall.O_CREAT|syscall.O_RDWR|syscall.O_CLOEXEC, 0) if err != nil { t.Fatalf("Open failed: %v", err) } defer os.RemoveAll(tempDir) defer syscall.Close(fd) if err := syscall.Ftruncate(fd, 1<<20); err != nil { t.Fatalf("Ftruncate(1<<20) failed: %v", err) } if err := syscall.FcntlFlock(uintptr(fd), syscall.F_SETLK, &flock); err != nil { t.Fatalf("FcntlFlock(F_SETLK) failed: %v", err) } cmd := exec.Command(os.Args[0], "-test.run=^TestFcntlFlock$") cmd.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=1") cmd.ExtraFiles = []*os.File{os.NewFile(uintptr(fd), name)} out, err := cmd.CombinedOutput() if len(out) > 0 || err != nil { t.Fatalf("child process: %q, %v", out, err) } } else { // child got := flock // make sure the child lock is conflicting with the parent lock got.Start-- got.Len++ if err := syscall.FcntlFlock(3, syscall.F_GETLK, &got); err != nil { t.Fatalf("FcntlFlock(F_GETLK) failed: %v", err) } flock.Pid = int32(syscall.Getppid()) // Linux kernel always set Whence to 0 flock.Whence = 0 if got.Type == flock.Type && got.Start == flock.Start && got.Len == flock.Len && got.Pid == flock.Pid && got.Whence == flock.Whence { os.Exit(0) } t.Fatalf("FcntlFlock got %v, want %v", got, flock) } } // TestPassFD tests passing a file descriptor over a Unix socket. // // This test involved both a parent and child process. The parent // process is invoked as a normal test, with "go test", which then // runs the child process by running the current test binary with args // "-test.run=^TestPassFD$" and an environment variable used to signal // that the test should become the child process instead. func TestPassFD(t *testing.T) { testenv.MustHaveExec(t) if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" { passFDChild() return } tempDir, err := ioutil.TempDir("", "TestPassFD") if err != nil { t.Fatal(err) } defer os.RemoveAll(tempDir) fds, err := syscall.Socketpair(syscall.AF_LOCAL, syscall.SOCK_STREAM, 0) if err != nil { t.Fatalf("Socketpair: %v", err) } defer syscall.Close(fds[0]) defer syscall.Close(fds[1]) writeFile := os.NewFile(uintptr(fds[0]), "child-writes") readFile := os.NewFile(uintptr(fds[1]), "parent-reads") defer writeFile.Close() defer readFile.Close() cmd := exec.Command(os.Args[0], "-test.run=^TestPassFD$", "--", tempDir) cmd.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=1") cmd.ExtraFiles = []*os.File{writeFile} out, err := cmd.CombinedOutput() if len(out) > 0 || err != nil { t.Fatalf("child process: %q, %v", out, err) } c, err := net.FileConn(readFile) if err != nil { t.Fatalf("FileConn: %v", err) } defer c.Close() uc, ok := c.(*net.UnixConn) if !ok { t.Fatalf("unexpected FileConn type; expected UnixConn, got %T", c) } buf := make([]byte, 32) // expect 1 byte oob := make([]byte, 32) // expect 24 bytes closeUnix := time.AfterFunc(5*time.Second, func() { t.Logf("timeout reading from unix socket") uc.Close() }) _, oobn, _, _, err := uc.ReadMsgUnix(buf, oob) if err != nil { t.Fatalf("ReadMsgUnix: %v", err) } closeUnix.Stop() scms, err := syscall.ParseSocketControlMessage(oob[:oobn]) if err != nil { t.Fatalf("ParseSocketControlMessage: %v", err) } if len(scms) != 1 { t.Fatalf("expected 1 SocketControlMessage; got scms = %#v", scms) } scm := scms[0] gotFds, err := syscall.ParseUnixRights(&scm) if err != nil { t.Fatalf("syscall.ParseUnixRights: %v", err) } if len(gotFds) != 1 { t.Fatalf("wanted 1 fd; got %#v", gotFds) } f := os.NewFile(uintptr(gotFds[0]), "fd-from-child") defer f.Close() got, err := ioutil.ReadAll(f) want := "Hello from child process!\n" if string(got) != want { t.Errorf("child process ReadAll: %q, %v; want %q", got, err, want) } } // passFDChild is the child process used by TestPassFD. func passFDChild() { defer os.Exit(0) // Look for our fd. It should be fd 3, but we work around an fd leak // bug here (https://golang.org/issue/2603) to let it be elsewhere. var uc *net.UnixConn for fd := uintptr(3); fd <= 10; fd++ { f := os.NewFile(fd, "unix-conn") var ok bool netc, _ := net.FileConn(f) uc, ok = netc.(*net.UnixConn) if ok { break } } if uc == nil { fmt.Println("failed to find unix fd") return } // Make a file f to send to our parent process on uc. // We make it in tempDir, which our parent will clean up. flag.Parse() tempDir := flag.Arg(0) f, err := ioutil.TempFile(tempDir, "") if err != nil { fmt.Printf("TempFile: %v", err) return } f.Write([]byte("Hello from child process!\n")) f.Seek(0, io.SeekStart) rights := syscall.UnixRights(int(f.Fd())) dummyByte := []byte("x") n, oobn, err := uc.WriteMsgUnix(dummyByte, rights, nil) if err != nil { fmt.Printf("WriteMsgUnix: %v", err) return } if n != 1 || oobn != len(rights) { fmt.Printf("WriteMsgUnix = %d, %d; want 1, %d", n, oobn, len(rights)) return } } // TestUnixRightsRoundtrip tests that UnixRights, ParseSocketControlMessage, // and ParseUnixRights are able to successfully round-trip lists of file descriptors. func TestUnixRightsRoundtrip(t *testing.T) { testCases := [...][][]int{ {{42}}, {{1, 2}}, {{3, 4, 5}}, {{}}, {{1, 2}, {3, 4, 5}, {}, {7}}, } for _, testCase := range testCases { b := []byte{} var n int for _, fds := range testCase { // Last assignment to n wins n = len(b) + syscall.CmsgLen(4*len(fds)) b = append(b, syscall.UnixRights(fds...)...) } // Truncate b b = b[:n] scms, err := syscall.ParseSocketControlMessage(b) if err != nil { t.Fatalf("ParseSocketControlMessage: %v", err) } if len(scms) != len(testCase) { t.Fatalf("expected %v SocketControlMessage; got scms = %#v", len(testCase), scms) } for i, scm := range scms { gotFds, err := syscall.ParseUnixRights(&scm) if err != nil { t.Fatalf("ParseUnixRights: %v", err) } wantFds := testCase[i] if len(gotFds) != len(wantFds) { t.Fatalf("expected %v fds, got %#v", len(wantFds), gotFds) } for j, fd := range gotFds { if fd != wantFds[j] { t.Fatalf("expected fd %v, got %v", wantFds[j], fd) } } } } } func TestRlimit(t *testing.T) { var rlimit, zero syscall.Rlimit err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimit) if err != nil { t.Fatalf("Getrlimit: save failed: %v", err) } if zero == rlimit { t.Fatalf("Getrlimit: save failed: got zero value %#v", rlimit) } set := rlimit set.Cur = set.Max - 1 if runtime.GOOS == "darwin" && set.Cur > 10240 { // The max file limit is 10240, even though // the max returned by Getrlimit is 1<<63-1. // This is OPEN_MAX in sys/syslimits.h. set.Cur = 10240 } err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &set) if err != nil { t.Fatalf("Setrlimit: set failed: %#v %v", set, err) } var get syscall.Rlimit err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &get) if err != nil { t.Fatalf("Getrlimit: get failed: %v", err) } set = rlimit set.Cur = set.Max - 1 if runtime.GOOS == "darwin" && set.Cur > 10240 { set.Cur = 10240 } if set != get { t.Fatalf("Rlimit: change failed: wanted %#v got %#v", set, get) } err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rlimit) if err != nil { t.Fatalf("Setrlimit: restore failed: %#v %v", rlimit, err) } } func TestSeekFailure(t *testing.T) { _, err := syscall.Seek(-1, 0, io.SeekStart) if err == nil { t.Fatalf("Seek(-1, 0, 0) did not fail") } str := err.Error() // used to crash on Linux t.Logf("Seek: %v", str) if str == "" { t.Fatalf("Seek(-1, 0, 0) return error with empty message") } }
[ "\"GO_WANT_HELPER_PROCESS\"", "\"GO_WANT_HELPER_PROCESS\"" ]
[]
[ "GO_WANT_HELPER_PROCESS" ]
[]
["GO_WANT_HELPER_PROCESS"]
go
1
0
alttprbot/alttprgen/randomizer/ootr.py
import aiohttp import os OOTR_BASE_URL = os.environ.get('OOTR_BASE_URL', 'https://ootrandomizer.com') OOTR_API_KEY = os.environ.get('OOTR_API_KEY') async def roll_ootr(settings, version='6.1.0', encrypt=True): async with aiohttp.request( method='post', url=f"{OOTR_BASE_URL}/api/sglive/seed/create", raise_for_status=True, json=settings, params={ "key": OOTR_API_KEY, "version": version, "encrypt": str(encrypt).lower() } ) as resp: result = await resp.json() return result
[]
[]
[ "OOTR_BASE_URL", "OOTR_API_KEY" ]
[]
["OOTR_BASE_URL", "OOTR_API_KEY"]
python
2
0
internal/apiserver/root.go
package apiserver /* Copyright 2017 - 2021 Crunchy Data Solutions, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ import ( "context" "crypto/ecdsa" "crypto/x509" "errors" "fmt" "io/ioutil" "net/http" "os" "strconv" "strings" "github.com/percona/percona-postgresql-operator/internal/config" "github.com/percona/percona-postgresql-operator/internal/kubeapi" "github.com/percona/percona-postgresql-operator/internal/ns" "github.com/percona/percona-postgresql-operator/internal/tlsutil" "github.com/percona/percona-postgresql-operator/internal/util" log "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" ) const PGOSecretName = "pgo.tls" const VERSION_MISMATCH_ERROR = "pgo client and server version mismatch" var ( // Clientset is a client for Kubernetes resources Clientset kubeapi.Interface // RESTConfig holds the REST configuration for a Kube client RESTConfig *rest.Config ) // MetricsFlag if set to true will cause crunchy-postgres-exporter to be added into new clusters var MetricsFlag, BadgerFlag bool // AuditFlag if set to true will cause auditing to occur in the logs var AuditFlag bool // DebugFlag is the debug flag value var DebugFlag bool // BasicAuth comes from the apiserver config var BasicAuth bool // Namespace comes from the apiserver config in this version var ( PgoNamespace string InstallationName string ) var CRUNCHY_DEBUG bool // TreeTrunk is for debugging only in this context const TreeTrunk = "└── " // TreeBranch is for debugging only in this context const TreeBranch = "├── " type CredentialDetail struct { Username string Password string Role string Namespaces []string } var Pgo config.PgoConfig // NamespaceOperatingMode defines the namespace operating mode for the cluster, // e.g. "dynamic", "readonly" or "disabled". See type NamespaceOperatingMode // for detailed explanations of each mode available. var namespaceOperatingMode ns.NamespaceOperatingMode func Initialize() { PgoNamespace = os.Getenv("PGO_OPERATOR_NAMESPACE") if PgoNamespace == "" { log.Info("PGO_OPERATOR_NAMESPACE environment variable is not set and is required, this is the namespace that the Operator is to run within.") os.Exit(2) } log.Info("Pgo Namespace is [" + PgoNamespace + "]") InstallationName = os.Getenv("PGO_INSTALLATION_NAME") if InstallationName == "" { log.Error("PGO_INSTALLATION_NAME environment variable is missng") os.Exit(2) } log.Info("InstallationName is [" + InstallationName + "]") tmp := os.Getenv("CRUNCHY_DEBUG") CRUNCHY_DEBUG = false if tmp == "true" { CRUNCHY_DEBUG = true } BasicAuth = true MetricsFlag = false BadgerFlag = false AuditFlag = false log.Infoln("apiserver starts") connectToKube() initializePerms() err := Pgo.GetConfig(Clientset, PgoNamespace) if err != nil { log.Error(err) log.Error("error in Pgo configuration") os.Exit(2) } initConfig() // look through all the pgouser secrets in the Operator's // namespace and set a generated password for any that currently // have an empty password set setRandomPgouserPasswords() if err := setNamespaceOperatingMode(); err != nil { log.Error(err) os.Exit(2) } _, err = ns.GetInitialNamespaceList(Clientset, NamespaceOperatingMode(), InstallationName, PgoNamespace) if err != nil { log.Error(err) os.Exit(2) } log.Infof("Namespace operating mode is '%s'", NamespaceOperatingMode()) } func connectToKube() { client, err := kubeapi.NewClient() if err != nil { panic(err) } Clientset = client RESTConfig = client.Config } func initConfig() { AuditFlag = Pgo.Pgo.Audit if AuditFlag { log.Info("audit flag is set to true") } MetricsFlag = Pgo.Cluster.Metrics if MetricsFlag { log.Info("metrics flag is set to true") } BadgerFlag = Pgo.Cluster.Badger if BadgerFlag { log.Info("badger flag is set to true") } tmp := Pgo.BasicAuth if tmp == "" { BasicAuth = true } else { var err error BasicAuth, err = strconv.ParseBool(tmp) if err != nil { log.Error("BasicAuth config value is not valid") os.Exit(2) } } log.Infof("BasicAuth is %v", BasicAuth) } func BasicAuthCheck(username, password string) bool { ctx := context.TODO() if !BasicAuth { return true } // see if there is a pgouser Secret for this username secretName := "pgouser-" + username secret, err := Clientset.CoreV1().Secrets(PgoNamespace).Get(ctx, secretName, metav1.GetOptions{}) if err != nil { log.Errorf("could not get pgouser secret %s: %s", username, err.Error()) return false } return password == string(secret.Data["password"]) } func BasicAuthzCheck(username, perm string) bool { ctx := context.TODO() secretName := "pgouser-" + username secret, err := Clientset.CoreV1().Secrets(PgoNamespace).Get(ctx, secretName, metav1.GetOptions{}) if err != nil { log.Errorf("could not get pgouser secret %s: %s", username, err.Error()) return false } // get the roles for this user rolesString := string(secret.Data["roles"]) roles := strings.Split(rolesString, ",") if len(roles) == 0 { log.Errorf("%s user has no roles ", username) return false } // venture thru each role this user has looking for a perm match for _, r := range roles { // get the pgorole roleSecretName := "pgorole-" + r rolesecret, err := Clientset.CoreV1().Secrets(PgoNamespace).Get(ctx, roleSecretName, metav1.GetOptions{}) if err != nil { log.Errorf("could not get pgorole secret %s: %s", r, err.Error()) return false } permsString := strings.TrimSpace(string(rolesecret.Data["permissions"])) // first a special case. If this is a solitary "*" indicating that this // encompasses every permission, then we can exit here as true if permsString == "*" { return true } // otherwise, blow up the permission string and see if the user has explicit // permission (i.e. is authorized) to access this resource perms := strings.Split(permsString, ",") for _, p := range perms { pp := strings.TrimSpace(p) if pp == perm { log.Debugf("%s perm found in role %s for username %s", pp, r, username) return true } } } return false } // GetNamespace determines if a user has permission for // a namespace they are requesting // a valid requested namespace is required func GetNamespace(clientset kubernetes.Interface, username, requestedNS string) (string, error) { log.Debugf("GetNamespace username [%s] ns [%s]", username, requestedNS) if requestedNS == "" { return requestedNS, errors.New("empty namespace is not valid from pgo clients") } iAccess, uAccess, err := UserIsPermittedInNamespace(username, requestedNS) if err != nil { return requestedNS, fmt.Errorf("Error when determining whether user [%s] is allowed access to "+ "namespace [%s]: %s", username, requestedNS, err.Error()) } if !iAccess { errMsg := fmt.Sprintf("namespace [%s] is not part of the Operator installation", requestedNS) return requestedNS, errors.New(errMsg) } if !uAccess { errMsg := fmt.Sprintf("user [%s] is not allowed access to namespace [%s]", username, requestedNS) return requestedNS, errors.New(errMsg) } return requestedNS, nil } // Authn performs HTTP Basic Authentication against a user if "BasicAuth" is set // to "true" (which it is by default). // // ...it also performs Authorization (Authz) against the user that is attempting // to authenticate, and as such, to truly "authenticate/authorize," one needs // at least a valid Operator User account. func Authn(perm string, w http.ResponseWriter, r *http.Request) (string, error) { var err error w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`) // Need to run the HTTP library `BasicAuth` even if `BasicAuth == false`, as // this function currently encapsulates authorization as well, and this is // the call where we get the username to check the RBAC settings username, password, authOK := r.BasicAuth() if AuditFlag { log.Infof("[audit] %s username=[%s] method=[%s] ip=[%s] ok=[%t] ", perm, username, r.Method, r.RemoteAddr, authOK) } // Check to see if this user is authenticated // If BasicAuth is "disabled", skip the authentication; o/w/ check if the // authentication passed if !BasicAuth { log.Debugf("BasicAuth disabled, Skipping Authentication %s username=[%s]", perm, username) } else { log.Debugf("Authentication Attempt %s username=[%s]", perm, username) if !authOK { http.Error(w, "Not Authorized. Basic Authentication credentials must be provided according to RFC 7617, Section 2.", 401) return "", errors.New("Not Authorized: Credentials do not comply with RFC 7617") } } if !BasicAuthCheck(username, password) { log.Errorf("Authentication Failed %s username=[%s]", perm, username) http.Error(w, "Not authenticated in apiserver", 401) return "", errors.New("Not Authenticated") } if !BasicAuthzCheck(username, perm) { log.Errorf("Authorization Failed %s username=[%s]", perm, username) http.Error(w, "Not authorized for this apiserver action", 403) return "", errors.New("Not authorized for this apiserver action") } log.Debug("Authentication Success") return username, err } func IsValidStorageName(name string) bool { _, ok := Pgo.Storage[name] return ok } // ValidateNodeLabel // returns error if node label is invalid based on format func ValidateNodeLabel(nodeLabel string) error { parts := strings.Split(nodeLabel, "=") if len(parts) != 2 { return errors.New(nodeLabel + " node label does not follow key=value format") } return nil } // UserIsPermittedInNamespace returns installation access and user access. // Installation access means a namespace belongs to this Operator installation. // User access means this user has access to a namespace. func UserIsPermittedInNamespace(username, requestedNS string) (bool, bool, error) { ctx := context.TODO() var iAccess, uAccess bool if err := ns.ValidateNamespacesWatched(Clientset, NamespaceOperatingMode(), InstallationName, requestedNS); err != nil { if !errors.Is(err, ns.ErrNamespaceNotWatched) { return false, false, err } } else { iAccess = true } if iAccess { // get the pgouser Secret for this username userSecretName := "pgouser-" + username userSecret, err := Clientset.CoreV1().Secrets(PgoNamespace).Get(ctx, userSecretName, metav1.GetOptions{}) if err != nil { log.Errorf("could not get pgouser secret %s: %s", username, err.Error()) return false, false, err } // handle the case of a user in pgouser with "" (all) namespaces, otherwise check the // namespaces config in the user secret nsstring := string(userSecret.Data["namespaces"]) if nsstring == "" { uAccess = true } else { nsList := strings.Split(nsstring, ",") for _, v := range nsList { ns := strings.TrimSpace(v) if ns == requestedNS { uAccess = true } } } } return iAccess, uAccess, nil } // WriteTLSCert is a legacy method that writes the server certificate and key to // files from the PGOSecretName secret or generates a new key (writing to both // the secret and the expected files func WriteTLSCert(certPath, keyPath string) error { ctx := context.TODO() pgoSecret, err := Clientset.CoreV1().Secrets(PgoNamespace).Get(ctx, PGOSecretName, metav1.GetOptions{}) // if the TLS certificate secret is not found, attempt to generate one if err != nil { log.Infof("%s Secret NOT found in namespace %s", PGOSecretName, PgoNamespace) if err := generateTLSCert(certPath, keyPath); err != nil { log.Error("error generating pgo.tls Secret") return err } return nil } // otherwise, write the TLS sertificate to the certificate and key path log.Infof("%s Secret found in namespace %s", PGOSecretName, PgoNamespace) log.Infof("cert key data len is %d", len(pgoSecret.Data[corev1.TLSCertKey])) if err := ioutil.WriteFile(certPath, pgoSecret.Data[corev1.TLSCertKey], 0o600); err != nil { return err } log.Infof("private key data len is %d", len(pgoSecret.Data[corev1.TLSPrivateKeyKey])) if err := ioutil.WriteFile(keyPath, pgoSecret.Data[corev1.TLSPrivateKeyKey], 0o600); err != nil { return err } return nil } // generateTLSCert generates a self signed cert and stores it in both // the PGOSecretName Secret and certPath, keyPath files func generateTLSCert(certPath, keyPath string) error { ctx := context.TODO() var err error // generate private key var privateKey *ecdsa.PrivateKey privateKey, err = tlsutil.NewPrivateKey() if err != nil { fmt.Println(err.Error()) os.Exit(2) } privateKeyBytes := tlsutil.EncodePrivateKeyPEM(privateKey) log.Debugf("generated privateKeyBytes len %d", len(privateKeyBytes)) var caCert *x509.Certificate caCert, err = tlsutil.NewSelfSignedCACertificate(privateKey) if err != nil { fmt.Println(err.Error()) os.Exit(2) } caCertBytes := tlsutil.EncodeCertificatePEM(caCert) log.Debugf("generated caCertBytes len %d", len(caCertBytes)) // CreateSecret newSecret := corev1.Secret{} newSecret.Name = PGOSecretName newSecret.ObjectMeta.Labels = make(map[string]string) newSecret.ObjectMeta.Labels[config.LABEL_VENDOR] = "crunchydata" newSecret.Data = make(map[string][]byte) newSecret.Data[corev1.TLSCertKey] = caCertBytes newSecret.Data[corev1.TLSPrivateKeyKey] = privateKeyBytes newSecret.Type = corev1.SecretTypeTLS _, err = Clientset.CoreV1().Secrets(PgoNamespace).Create(ctx, &newSecret, metav1.CreateOptions{}) if err != nil { fmt.Println(err.Error()) os.Exit(2) } if err := ioutil.WriteFile(certPath, newSecret.Data[corev1.TLSCertKey], 0o600); err != nil { return err } if err := ioutil.WriteFile(keyPath, newSecret.Data[corev1.TLSPrivateKeyKey], 0o600); err != nil { return err } return err } // setNamespaceOperatingMode set the namespace operating mode for the Operator by calling the // proper utility function to determine which mode is applicable based on the current // permissions assigned to the Operator Service Account. func setNamespaceOperatingMode() error { nsOpMode, err := ns.GetNamespaceOperatingMode(Clientset) if err != nil { return err } namespaceOperatingMode = nsOpMode return nil } // setRandomPgouserPasswords looks through the pgouser secrets in the Operator's // namespace. If any have an empty password, it generates a random password, // Base64 encodes it, then stores it in the relevant PGO user's secret func setRandomPgouserPasswords() { ctx := context.TODO() selector := "pgo-pgouser=true,vendor=crunchydata" secrets, err := Clientset.CoreV1().Secrets(PgoNamespace). List(ctx, metav1.ListOptions{LabelSelector: selector}) if err != nil { log.Warnf("Could not get pgouser secrets in namespace: %s", PgoNamespace) return } for _, secret := range secrets.Items { // check if password is set. if it is, continue. if len(secret.Data["password"]) > 0 { continue } log.Infof("Password in pgouser secret %s for operator installation %s in namespace %s is empty. "+ "Setting a generated password.", secret.Name, InstallationName, PgoNamespace) // generate the password using the default password length generatedPassword, err := util.GeneratePassword(util.DefaultGeneratedPasswordLength) if err != nil { log.Errorf("Could not generate password for pgouser secret %s for operator installation %s in "+ "namespace %s", secret.Name, InstallationName, PgoNamespace) continue } // create the password patch patch, err := kubeapi.NewMergePatch().Add("stringData", "password")(generatedPassword).Bytes() if err != nil { log.Errorf("Could not generate password patch for pgouser secret %s for operator installation "+ "%s in namespace %s", secret.Name, InstallationName, PgoNamespace) continue } // patch the pgouser secret with the new password if _, err := Clientset.CoreV1().Secrets(PgoNamespace).Patch(ctx, secret.Name, types.MergePatchType, patch, metav1.PatchOptions{}); err != nil { log.Errorf("Could not patch pgouser secret %s with generated password for operator installation "+ "%s in namespace %s", secret.Name, InstallationName, PgoNamespace) } } } // NamespaceOperatingMode returns the namespace operating mode for the current Operator // installation, which is stored in the "namespaceOperatingMode" variable func NamespaceOperatingMode() ns.NamespaceOperatingMode { return namespaceOperatingMode }
[ "\"PGO_OPERATOR_NAMESPACE\"", "\"PGO_INSTALLATION_NAME\"", "\"CRUNCHY_DEBUG\"" ]
[]
[ "PGO_OPERATOR_NAMESPACE", "PGO_INSTALLATION_NAME", "CRUNCHY_DEBUG" ]
[]
["PGO_OPERATOR_NAMESPACE", "PGO_INSTALLATION_NAME", "CRUNCHY_DEBUG"]
go
3
0
ML/DT/python/DTree_sklearn_titanic.py
# coding: utf-8 # In[13]: import sklearn_dt_utils as utils from sklearn.tree import export_graphviz import os # In[14]: q_src_dir = os.getenv('Q_SRC_ROOT') if not q_src_dir: print("'Q_SRC_ROOT' is not set") exit(-1) csv_file_path = "%s/ML/KNN/data/titanic/titanic_train.csv" % q_src_dir csv_file_path = "/root/WORK/Q/ML/KNN/data/titanic/titanic_train.csv" graphviz_gini = "graphviz_gini.txt" graphviz_entropy = "graphviz_entropy.txt" goal_col_name = "Survived" split_ratio = 0.5 # In[15]: print("Dataset shape") data = utils.import_data(csv_file_path) # In[16]: X, Y, X_train, X_test, y_train, y_test = utils.split_dataset(data, goal_col_name, split_ratio) # In[17]: #print(len(X.columns)) # In[18]: #print(len(data.columns)) # In[19]: # cross validation utils.cross_validate_dt_new(X, Y) # In[20]: # cross validation # utils.cross_validate_dt(X, Y) # In[21]: # Train using gini clf_gini = utils.train_using_gini(X_train, y_train) # print(X_train[1]) export_graphviz(clf_gini, out_file=graphviz_gini, filled=True, rounded=True, special_characters=True, feature_names=X_train.columns) # In[22]: # Prediction using gini y_pred_gini = utils.prediction(X_test, clf_gini) print("Results for gini algo") utils.cal_accuracy(y_test, y_pred_gini) # In[23]: # Train using entropy clf_entropy = utils.tarin_using_entropy(X_train, y_train) export_graphviz(clf_entropy, out_file=graphviz_entropy, filled=True, rounded=True, special_characters=True, feature_names=X_train.columns) # In[24]: # Prediction using entropy y_pred_entropy = utils.prediction(X_test, clf_entropy) print("Results for entropy algo") utils.cal_accuracy(y_test, y_pred_entropy)
[]
[]
[ "Q_SRC_ROOT" ]
[]
["Q_SRC_ROOT"]
python
1
0
park_api/crossdomain.py
from datetime import timedelta from flask import make_response, request, current_app from functools import update_wrapper def crossdomain(origin=None, methods=None, headers=None, max_age=21600, attach_to_all=True, automatic_options=True): if methods is not None: methods = ', '.join(sorted(x.upper() for x in methods)) if headers is not None and not isinstance(headers, str): headers = ', '.join(x.upper() for x in headers) if not isinstance(origin, str): origin = ', '.join(origin) if isinstance(max_age, timedelta): max_age = max_age.total_seconds() def get_methods(): if methods is not None: return methods options_resp = current_app.make_default_options_response() return options_resp.headers['allow'] def decorator(f): def wrapped_function(*args, **kwargs): if automatic_options and request.method == 'OPTIONS': resp = current_app.make_default_options_response() else: resp = make_response(f(*args, **kwargs)) if not attach_to_all and request.method != 'OPTIONS': return resp h = resp.headers h['Access-Control-Allow-Origin'] = origin h['Access-Control-Allow-Methods'] = get_methods() h['Access-Control-Max-Age'] = str(max_age) if headers is not None: h['Access-Control-Allow-Headers'] = headers return resp f.provide_automatic_options = False return update_wrapper(wrapped_function, f) return decorator
[]
[]
[]
[]
[]
python
null
null
null
pygraphblas/demo/dnn.py
import os from functools import wraps, partial from time import time from statistics import mean from pathlib import Path from pygraphblas import * from multiprocessing.pool import ThreadPool from multiprocessing import cpu_count NFEATURES = 60000 BIAS = {1024: -0.3, 4096: -0.35, 16384: -0.4, 65536: -0.45} def timing(f): @wraps(f) def wrap(*args, **kw): ts = time() result = f(*args, **kw) te = time() print('func:%r took: %2.4f' % (f.__name__, te-ts)) return result return wrap @timing def dnn(W, B, Y): for w, b in zip(W, B): Y = Y @ w with plus_plus: Y = Y @ b Y = Y.select('>0') M = Y.select('>', 32) if len(M): Y[M] = 32 return Y @timing def dnn2(W, B, Y): for w, b in zip(W, B): Y = Y.mxm(w, out=Y) with plus_plus: Y = Y.mxm(b, out=Y) Y.select('>0', out=Y) M = Y.select('>', 32) if len(M): Y[M] = 32 return Y @timing def load_images(neurons, dest): fname = '{}/sparse-images-{}.{}' binfile = fname.format(dest, neurons, 'ssb') if Path(binfile).exists(): return Matrix.from_binfile(binfile.encode('ascii')) images = Path(fname.format(dest, neurons, 'tsv')) with images.open() as i: m = Matrix.from_tsv(i, FP32, NFEATURES, neurons) m.to_binfile(binfile.encode('ascii')) return m def load_categories(neurons, nlayers, dest): fname = '{}/neuron{}-l{}-categories.tsv' cats = Path(fname.format(dest, neurons, nlayers)) result = Vector.from_type(BOOL, NFEATURES) with cats.open() as i: for line in i.readlines(): result[int(line.strip())-1] = True return result def load_layer(i, dest): fname = '{}/neuron{}/n{}-l{}.{}' binfile = fname.format(dest, neurons, neurons, str(i+1), 'ssb') if Path(binfile).exists(): return Matrix.from_binfile(binfile.encode('ascii')) l = Path(fname.format(dest, neurons, neurons, str(i+1), 'tsv')) with l.open() as f: m = Matrix.from_tsv(f, FP32, neurons, neurons) m.to_binfile(binfile.encode('ascii')) return m @timing def generate_layers(neurons, nlayers, dest): neurons = Path('{}/neuron{}'.format(dest, neurons)) with ThreadPool(cpu_count()) as pool: return pool.map(partial(load_layer, dest=dest), range(nlayers)) @timing def generate_bias(neurons, nlayers): result = [] for i in range(nlayers): bias = Matrix.from_type(FP32, neurons, neurons) for i in range(neurons): bias[i,i] = BIAS[neurons] bias.nvals # causes async completion result.append(bias) return result @timing def run(neurons, images, layers, bias, dest): result = dnn2(layers, bias, images) r = result.reduce_vector() cats = r.apply(lib.GxB_ONE_BOOL, out=Vector.from_type(BOOL, r.size)) truecats = load_categories(neurons, nlayers, dest) assert cats == truecats num_neurons = [1024, 4096, 16384, 65536] num_layers = [120, 480, 1920] if __name__ == '__main__': dest = os.getenv('DEST') neurons = os.getenv('NEURONS') nlayers = os.getenv('NLAYERS') if neurons and nlayers: neurons = int(neurons) nlayers = int(nlayers) images = load_images(neurons, dest) layers = generate_layers(neurons, nlayers, dest) bias = generate_bias(neurons, nlayers) run(neurons, images, layers, bias, dest) else: for neurons in num_neurons: print('Building layers for %s neurons' % neurons) layers = generate_layers(neurons, 1920, dest) bias = generate_bias(neurons, 1920) images = load_images(neurons, dest) for nlayers in num_layers: print('Benching %s neurons %s layers' % (neurons, nlayers)) run(neurons, images, layers[:nlayers], bias[:nlayers], dest)
[]
[]
[ "NEURONS", "NLAYERS", "DEST" ]
[]
["NEURONS", "NLAYERS", "DEST"]
python
3
0
pkg/operator/starter.go
package operator import ( "context" "fmt" "os" "strings" "time" "github.com/davecgh/go-spew/spew" "github.com/eparis/bugzilla" "github.com/openshift/library-go/pkg/controller/factory" slackgo "github.com/slack-go/slack" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" "k8s.io/klog" "github.com/mfojtik/bugzilla-operator/pkg/cache" "github.com/mfojtik/bugzilla-operator/pkg/operator/closecontroller" "github.com/mfojtik/bugzilla-operator/pkg/operator/config" "github.com/mfojtik/bugzilla-operator/pkg/operator/controller" "github.com/mfojtik/bugzilla-operator/pkg/operator/firstteamcommentcontroller" "github.com/mfojtik/bugzilla-operator/pkg/operator/newcontroller" "github.com/mfojtik/bugzilla-operator/pkg/operator/reporters/blockers" "github.com/mfojtik/bugzilla-operator/pkg/operator/reporters/closed" "github.com/mfojtik/bugzilla-operator/pkg/operator/reporters/incoming" "github.com/mfojtik/bugzilla-operator/pkg/operator/reporters/upcomingsprint" "github.com/mfojtik/bugzilla-operator/pkg/operator/resetcontroller" "github.com/mfojtik/bugzilla-operator/pkg/operator/stalecontroller" "github.com/mfojtik/bugzilla-operator/pkg/slack" "github.com/mfojtik/bugzilla-operator/pkg/slacker" ) const bugzillaEndpoint = "https://bugzilla.redhat.com" func Run(ctx context.Context, cfg config.OperatorConfig) error { if len(cfg.CachePath) > 0 { cache.Open(cfg.CachePath) } defer cache.Close() slackClient := slackgo.New(cfg.Credentials.DecodedSlackToken(), slackgo.OptionDebug(true)) // This slack client is used for debugging slackDebugClient := slack.NewChannelClient(slackClient, cfg.SlackAdminChannel, cfg.SlackAdminChannel, true) // This slack client posts only to the admin channel slackAdminClient := slack.NewChannelClient(slackClient, cfg.SlackAdminChannel, cfg.SlackAdminChannel, false) recorder := slack.NewRecorder(slackAdminClient, "BugzillaOperator") slackerInstance := slacker.NewSlacker(slackClient, slacker.Options{ ListenAddress: "0.0.0.0:3000", VerificationToken: cfg.Credentials.DecodedSlackVerificationToken(), }) slackerInstance.Command("say <message>", &slacker.CommandDefinition{ Description: "Say something.", Handler: func(req slacker.Request, w slacker.ResponseWriter) { msg := req.StringParam("message", "") w.Reply(msg) }, }) slackerInstance.DefaultCommand(func(req slacker.Request, w slacker.ResponseWriter) { w.Reply("Unknown command") }) recorder.Eventf("OperatorStarted", "Bugzilla Operator Started\n\n```\n%s\n```\n", spew.Sdump(cfg.Anonymize())) kubeConfig, err := rest.InClusterConfig() if err != nil { return err } kubeClient, err := kubernetes.NewForConfig(kubeConfig) if err != nil { return err } cmClient := kubeClient.CoreV1().ConfigMaps(os.Getenv("POD_NAMESPACE")) controllerContext := controller.NewControllerContext(newBugzillaClient(&cfg, slackDebugClient), slackAdminClient, slackDebugClient, cmClient) controllers := map[string]factory.Controller{ "stale": stalecontroller.NewStaleController(controllerContext, cfg, recorder), "stale-reset": resetcontroller.NewResetStaleController(controllerContext, cfg, recorder), "close-stale": closecontroller.NewCloseStaleController(controllerContext, cfg, recorder), "first-team-comment": firstteamcommentcontroller.NewFirstTeamCommentController(controllerContext, cfg, recorder), "new": newcontroller.NewNewBugController(controllerContext, cfg, recorder), } // TODO: enable by default cfg.DisabledControllers = append(cfg.DisabledControllers, "NewBugController") var scheduledReports []factory.Controller reportNames := sets.NewString() newReport := func(name string, ctx controller.ControllerContext, components, when []string) factory.Controller { switch name { case "blocker-bugs": return blockers.NewBlockersReporter(ctx, components, when, cfg, recorder) case "incoming-bugs": return incoming.NewIncomingReporter(ctx, when, cfg, recorder) case "closed-bugs": return closed.NewClosedReporter(ctx, components, when, cfg, recorder) case "upcoming-sprint": return upcomingsprint.NewUpcomingSprintReporter(controllerContext, components, when, cfg, recorder) default: return nil } } for _, ar := range cfg.Schedules { slackChannelClient := slack.NewChannelClient(slackClient, ar.SlackChannel, cfg.SlackAdminChannel, false) reporterContext := controller.NewControllerContext(newBugzillaClient(&cfg, slackDebugClient), slackChannelClient, slackDebugClient, cmClient) for _, r := range ar.Reports { if c := newReport(r, reporterContext, ar.Components, ar.When); c != nil { scheduledReports = append(scheduledReports, c) reportNames.Insert(r) } } } debugReportControllers := map[string]factory.Controller{} for _, r := range reportNames.List() { debugReportControllers[r] = newReport(r, controllerContext, cfg.Components.List(), nil) } controllerNames := sets.NewString() for n := range controllers { controllerNames.Insert(n) } // allow to manually trigger a controller to run out of its normal schedule runJob := func(debug bool) func(req slacker.Request, w slacker.ResponseWriter) { return func(req slacker.Request, w slacker.ResponseWriter) { job := req.StringParam("job", "") c, ok := controllers[job] if !ok { if !debug { w.Reply(fmt.Sprintf("Unknown job %q", job)) return } if c, ok = debugReportControllers[job]; !ok { w.Reply(fmt.Sprintf("Unknown job %q", job)) return } } ctx := ctx // shadow global ctx if debug { ctx = context.WithValue(ctx, "debug", debug) } startTime := time.Now() _, _, _, err := w.Client().SendMessage(req.Event().Channel, slackgo.MsgOptionPostEphemeral(req.Event().User), slackgo.MsgOptionText(fmt.Sprintf("Triggering job %q", job), false)) if err != nil { klog.Error(err) } if err := c.Sync(ctx, factory.NewSyncContext(job, recorder)); err != nil { recorder.Warningf("ReportError", "Job reported error: %v", err) return } _, _, _, err = w.Client().SendMessage(req.Event().Channel, slackgo.MsgOptionPostEphemeral(req.Event().User), slackgo.MsgOptionText(fmt.Sprintf("Finished job %q after %v", job, time.Since(startTime)), false)) if err != nil { klog.Error(err) } } } slackerInstance.Command("admin trigger <job>", &slacker.CommandDefinition{ Description: fmt.Sprintf("Trigger a job to run: %s", strings.Join(controllerNames.List(), ", ")), Handler: auth(cfg, runJob(false), "group:admins"), }) slackerInstance.Command("admin debug <job>", &slacker.CommandDefinition{ Description: fmt.Sprintf("Trigger a job to run in debug mode: %s", strings.Join(append(controllerNames.List(), reportNames.List()...), ", ")), Handler: auth(cfg, runJob(true), "group:admins"), }) slackerInstance.Command("report <job>", &slacker.CommandDefinition{ Description: fmt.Sprintf("Run a report and print result here: %s", strings.Join(reportNames.List(), ", ")), Handler: func(req slacker.Request, w slacker.ResponseWriter) { job := req.StringParam("job", "") reports := map[string]func(ctx context.Context, client cache.BugzillaClient) (string, error){ "blocker-bugs": func(ctx context.Context, client cache.BugzillaClient) (string, error) { // TODO: restrict components to one team report, _, err := blockers.Report(ctx, client, recorder, &cfg, cfg.Components.List()) return report, err }, "closed-bugs": func(ctx context.Context, client cache.BugzillaClient) (string, error) { // TODO: restrict components to one team return closed.Report(ctx, client, recorder, &cfg, cfg.Components.List()) }, "incoming-bugs": func(ctx context.Context, client cache.BugzillaClient) (string, error) { // TODO: restrict components to one team report, _, err := incoming.Report(ctx, client, recorder, &cfg) return report, err }, "upcoming-sprint": func(ctx context.Context, client cache.BugzillaClient) (string, error) { // TODO: restrict components to one team return upcomingsprint.Report(ctx, client, recorder, &cfg, cfg.Components.List()) }, // don't forget to also add new reports above in the trigger command } report, ok := reports[job] if !ok { w.Reply(fmt.Sprintf("Unknown report %q", job)) return } _, _, _, err := w.Client().SendMessage(req.Event().Channel, slackgo.MsgOptionPostEphemeral(req.Event().User), slackgo.MsgOptionText(fmt.Sprintf("Running job %q. This might take some seconds.", job), false)) if err != nil { klog.Error(err) } reply, err := report(context.TODO(), newBugzillaClient(&cfg, slackDebugClient)(true)) // report should never write anything to BZ if err != nil { _, _, _, err := w.Client().SendMessage(req.Event().Channel, slackgo.MsgOptionPostEphemeral(req.Event().User), slackgo.MsgOptionText(fmt.Sprintf("Error running report %v: %v", job, err), false)) if err != nil { klog.Error(err) } } else { w.Reply(reply) } }, }) seen := []string{} disabled := sets.NewString(cfg.DisabledControllers...) var all []factory.Controller for _, c := range controllers { all = append(all, c) } for _, c := range append(all, scheduledReports...) { seen = append(seen, c.Name()) if disabled.Has(c.Name()) { continue } go c.Run(ctx, 1) } go slackerInstance.Run(ctx) // sanity check list of disabled controllers unknown := disabled.Difference(sets.NewString(seen...)) if unknown.Len() > 0 { msg := fmt.Sprintf("Unknown disabled controllers in config: %v", unknown.List()) klog.Warning(msg) slackAdminClient.MessageAdminChannel(msg) } <-ctx.Done() return nil } func newBugzillaClient(cfg *config.OperatorConfig, slackDebugClient slack.ChannelClient) func(debug bool) cache.BugzillaClient { return func(debug bool) cache.BugzillaClient { c := cache.NewCachedBugzillaClient(bugzilla.NewClient(func() []byte { return []byte(cfg.Credentials.DecodedAPIKey()) }, bugzillaEndpoint).WithCGIClient(cfg.Credentials.DecodedUsername(), cfg.Credentials.DecodedPassword())) if debug { return &loggingReadOnlyClient{delegate: c, slackLoggingClient: slackDebugClient} } return c } }
[ "\"POD_NAMESPACE\"" ]
[]
[ "POD_NAMESPACE" ]
[]
["POD_NAMESPACE"]
go
1
0
silent.go
// +build silent package main import ( "io/ioutil" "log" "os" ) func init() { verbose := os.Getenv("GOCHATBOT_VERBOSE") if verbose != "1" { log.SetOutput(ioutil.Discard) } }
[ "\"GOCHATBOT_VERBOSE\"" ]
[]
[ "GOCHATBOT_VERBOSE" ]
[]
["GOCHATBOT_VERBOSE"]
go
1
0
server.go
package main import ( "log" "os" "github.com/ansrivas/fiberprometheus/v2" "github.com/gofiber/fiber/v2" "github.com/gofiber/fiber/v2/middleware/limiter" "github.com/gofiber/fiber/v2/middleware/logger" "github.com/gofiber/fiber/v2/middleware/requestid" "github.com/gofiber/template/html" ) func initServer() *fiber.App { engine := html.New("./views", ".html") app := fiber.New(fiber.Config{ Views: engine, }) // This here will appear as a label, one can also use // fiberprometheus.NewWith(servicename, namespace, subsystem ) prometheus := fiberprometheus.New("hello-world-service") prometheus.RegisterAt(app, "/metrics") app.Use(prometheus.Middleware) app.Static("/static", "./public") app.Use(logger.New()) app.Use(limiter.New()) app.Use(requestid.New()) app.Get("/text", func(c *fiber.Ctx) error { return c.SendString("Hello, World!") }) app.Get("/", func(c *fiber.Ctx) error { return c.Render("index", fiber.Map{ "Title": "Hello World", }) }) app.Use(func(c *fiber.Ctx) error { return c.Status(fiber.StatusNotFound).SendString("Sorry can't find that!") }) return app } func main() { port := os.Getenv("PORT") if os.Getenv("PORT") == "" { port = "3000" } app := initServer() log.Fatal(app.Listen(":" + port)) }
[ "\"PORT\"", "\"PORT\"" ]
[]
[ "PORT" ]
[]
["PORT"]
go
1
0
testing/scripts/run_android_wpt.py
#!/usr/bin/env vpython # Copyright 2019 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Runs Web Platform Tests (WPT) on Android browsers. This script supports running tests on the Chromium Waterfall by mapping isolated script flags to WPT flags. It is also useful for local reproduction by performing APK installation and configuring the browser to resolve test hosts. Be sure to invoke this executable directly rather than using python run_android_wpt.py so that WPT dependencies in Chromium vpython are found. If you need more advanced test control, please use the runner located at //third_party/blink/web_tests/external/wpt/wpt. Here's the mapping [isolate script flag] : [wpt flag] --isolated-script-test-output : --log-chromium --total-shards : --total-chunks --shard-index : -- this-chunk """ # TODO(aluo): Combine or factor out commons parts with run_wpt_tests.py script. import argparse import contextlib import json import logging import os import shutil import sys import common import wpt_common logger = logging.getLogger(__name__) SRC_DIR = os.path.abspath( os.path.join(os.path.dirname(__file__), os.pardir, os.pardir)) BUILD_ANDROID = os.path.join(SRC_DIR, 'build', 'android') BLINK_TOOLS_DIR = os.path.join( SRC_DIR, 'third_party', 'blink', 'tools') CATAPULT_DIR = os.path.join(SRC_DIR, 'third_party', 'catapult') DEFAULT_WPT = os.path.join(wpt_common.WEB_TESTS_DIR, 'external', 'wpt', 'wpt') PYUTILS = os.path.join(CATAPULT_DIR, 'common', 'py_utils') if PYUTILS not in sys.path: sys.path.append(PYUTILS) if BLINK_TOOLS_DIR not in sys.path: sys.path.append(BLINK_TOOLS_DIR) if BUILD_ANDROID not in sys.path: sys.path.append(BUILD_ANDROID) import devil_chromium from blinkpy.web_tests.port.android import ( PRODUCTS, PRODUCTS_TO_EXPECTATION_FILE_PATHS, ANDROID_WEBLAYER, ANDROID_WEBVIEW, CHROME_ANDROID, ANDROID_DISABLED_TESTS) from devil import devil_env from devil.android import apk_helper from devil.android import device_utils from devil.android.tools import system_app from devil.android.tools import webview_app from py_utils.tempfile_ext import NamedTemporaryDirectory class PassThroughArgs(argparse.Action): pass_through_args = [] def __call__(self, parser, namespace, values, option_string=None): if option_string: if self.nargs == 0: self.add_unique_pass_through_arg(option_string) elif self.nargs is None: self.add_unique_pass_through_arg('{}={}'.format(option_string, values)) else: raise ValueError("nargs {} not supported: {} {}".format( self.nargs, option_string, values)) @classmethod def add_unique_pass_through_arg(cls, arg): if arg not in cls.pass_through_args: cls.pass_through_args.append(arg) def _get_adapter(device): usage = '%(prog)s --product={' + ','.join(PRODUCTS) + '} ...' product_parser = argparse.ArgumentParser( add_help=False, prog='run_android_wpt.py', usage=usage) product_parser.add_argument( '--product', action='store', required=True, choices=PRODUCTS) options, _ = product_parser.parse_known_args() product = options.product if product == ANDROID_WEBLAYER: return WPTWeblayerAdapter(device) elif product == ANDROID_WEBVIEW: return WPTWebviewAdapter(device) else: return WPTClankAdapter(device) class WPTAndroidAdapter(wpt_common.BaseWptScriptAdapter): def __init__(self, device): self.pass_through_wpt_args = [] self.pass_through_binary_args = [] self._metadata_dir = None self._device = device super(WPTAndroidAdapter, self).__init__() # Arguments from add_extra_argumentsparse were added so # its safe to parse the arguments and set self._options self.parse_args() @property def rest_args(self): rest_args = super(WPTAndroidAdapter, self).rest_args # Here we add all of the arguments required to run WPT tests on Android. rest_args.extend([self.options.wpt_path]) # vpython has packages needed by wpt, so force it to skip the setup rest_args.extend(["--venv=../../", "--skip-venv-setup"]) rest_args.extend(["run", "--test-type=" + self.options.test_type, "--webdriver-binary", self.options.webdriver_binary, "--headless", "--no-pause-after-test", "--no-capture-stdio", "--no-manifest-download", ]) # if metadata was created then add the metadata directory # to the list of wpt arguments if self._metadata_dir: rest_args.extend(['--metadata', self._metadata_dir]) if self.options.verbose >= 3: rest_args.extend(["--log-mach=-", "--log-mach-level=debug", "--log-mach-verbose"]) if self.options.verbose >= 4: rest_args.extend(['--webdriver-arg=--verbose', '--webdriver-arg="--log-path=-"']) rest_args.extend(self.pass_through_wpt_args) return rest_args def _extra_metadata_builder_args(self): raise NotImplementedError def _maybe_build_metadata(self): metadata_builder_cmd = [ sys.executable, os.path.join(wpt_common.BLINK_TOOLS_DIR, 'build_wpt_metadata.py'), '--android-product', self.options.product, '--ignore-default-expectations', '--metadata-output-dir', self._metadata_dir, '--additional-expectations', ANDROID_DISABLED_TESTS, ] metadata_builder_cmd.extend(self._extra_metadata_builder_args()) return common.run_command(metadata_builder_cmd) def run_test(self): with NamedTemporaryDirectory() as self._metadata_dir, self._install_apks(): metadata_command_ret = self._maybe_build_metadata() if metadata_command_ret != 0: return metadata_command_ret return super(WPTAndroidAdapter, self).run_test() def _install_apks(self): raise NotImplementedError def clean_up_after_test_run(self): # Avoid having a dangling reference to the temp directory # which was deleted self._metadata_dir = None def add_extra_arguments(self, parser): # TODO: |pass_through_args| are broke and need to be supplied by way of # --binary-arg". class BinaryPassThroughArgs(PassThroughArgs): pass_through_args = self.pass_through_binary_args class WPTPassThroughArgs(PassThroughArgs): pass_through_args = self.pass_through_wpt_args # Add this so that product argument does not go in self._rest_args # when self.parse_args() is called parser.add_argument('--product', help=argparse.SUPPRESS) parser.add_argument('--webdriver-binary', required=True, help='Path of the webdriver binary. It needs to have' ' the same major version as the apk.') parser.add_argument('--wpt-path', default=DEFAULT_WPT, help='Controls the path of the WPT runner to use' ' (therefore tests). Defaults the revision rolled into' ' Chromium.') parser.add_argument('--test-type', default='testharness', help='Specify to experiment with other test types.' ' Currently only the default is expected to work.') parser.add_argument('--verbose', '-v', action='count', help='Verbosity level.') parser.add_argument('--include', metavar='TEST_OR_DIR', action=WPTPassThroughArgs, help='Test(s) to run, defaults to run all tests.') parser.add_argument('--list-tests', action=WPTPassThroughArgs, nargs=0, help="Don't run any tests, just print out a list of" ' tests that would be run.') parser.add_argument('--webdriver-arg', action=WPTPassThroughArgs, help='WebDriver args.') parser.add_argument('--log-wptreport', metavar='WPT_REPORT_FILE', action=WPTPassThroughArgs, help="Log wptreport with subtest details.") parser.add_argument('--log-raw', metavar='RAW_REPORT_FILE', action=WPTPassThroughArgs, help="Log raw report.") parser.add_argument('--log-html', metavar='HTML_REPORT_FILE', action=WPTPassThroughArgs, help="Log html report.") parser.add_argument('--log-xunit', metavar='XUNIT_REPORT_FILE', action=WPTPassThroughArgs, help="Log xunit report.") parser.add_argument('--enable-features', action=BinaryPassThroughArgs, help='Chromium features to enable during testing.') parser.add_argument('--disable-features', action=BinaryPassThroughArgs, help='Chromium features to disable during testing.') parser.add_argument('--disable-field-trial-config', action=BinaryPassThroughArgs, help='Disable test trials for Chromium features.') parser.add_argument('--force-fieldtrials', action=BinaryPassThroughArgs, help='Force trials for Chromium features.') parser.add_argument('--force-fieldtrial-params', action=BinaryPassThroughArgs, help='Force trial params for Chromium features.') class WPTWeblayerAdapter(WPTAndroidAdapter): WEBLAYER_SHELL_PKG = 'org.chromium.weblayer.shell' WEBLAYER_SUPPORT_PKG = 'org.chromium.weblayer.support' @contextlib.contextmanager def _install_apks(self): install_weblayer_shell_as_needed = maybe_install_user_apk( self._device, self.options.weblayer_shell, self.WEBLAYER_SHELL_PKG) install_weblayer_support_as_needed = maybe_install_user_apk( self._device, self.options.weblayer_support, self.WEBLAYER_SUPPORT_PKG) install_webview_provider_as_needed = maybe_install_webview_provider( self._device, self.options.webview_provider) with install_weblayer_shell_as_needed, \ install_weblayer_support_as_needed, \ install_webview_provider_as_needed: yield def _extra_metadata_builder_args(self): return [ '--additional-expectations', PRODUCTS_TO_EXPECTATION_FILE_PATHS[ANDROID_WEBLAYER]] def add_extra_arguments(self, parser): super(WPTWeblayerAdapter, self).add_extra_arguments(parser) parser.add_argument('--weblayer-shell', help='WebLayer Shell apk to install.') parser.add_argument('--weblayer-support', help='WebLayer Support apk to install.') parser.add_argument('--webview-provider', help='Webview provider apk to install.') @property def rest_args(self): args = super(WPTWeblayerAdapter, self).rest_args args.append(ANDROID_WEBLAYER) return args class WPTWebviewAdapter(WPTAndroidAdapter): SYSTEM_WEBVIEW_SHELL_PKG = 'org.chromium.webview_shell' @contextlib.contextmanager def _install_apks(self): install_shell_as_needed = maybe_install_user_apk( self._device, self.options.system_webview_shell, self.SYSTEM_WEBVIEW_SHELL_PKG) install_webview_provider_as_needed = maybe_install_webview_provider( self._device, self.options.webview_provider) with install_shell_as_needed, install_webview_provider_as_needed: yield def _extra_metadata_builder_args(self): return [ '--additional-expectations', PRODUCTS_TO_EXPECTATION_FILE_PATHS[ANDROID_WEBVIEW]] def add_extra_arguments(self, parser): super(WPTWebviewAdapter, self).add_extra_arguments(parser) parser.add_argument('--system-webview-shell', help=('System WebView Shell apk to install. If not ' 'specified then the on-device WebView apk ' 'will be used.')) parser.add_argument('--webview-provider', help='Webview provider APK to install.') @property def rest_args(self): args = super(WPTWebviewAdapter, self).rest_args args.append(ANDROID_WEBVIEW) return args class WPTClankAdapter(WPTAndroidAdapter): @contextlib.contextmanager def _install_apks(self): install_clank_as_needed = maybe_install_user_apk( self._device, self.options.chrome_apk) with install_clank_as_needed: yield def _extra_metadata_builder_args(self): return [ '--additional-expectations', PRODUCTS_TO_EXPECTATION_FILE_PATHS[CHROME_ANDROID]] def add_extra_arguments(self, parser): super(WPTClankAdapter, self).add_extra_arguments(parser) parser.add_argument( '--chrome-apk', help='Chrome apk to install.') parser.add_argument( '--chrome-package-name', help=('The package name of Chrome to test,' ' defaults to that of the compiled Chrome apk.')) @property def rest_args(self): args = super(WPTClankAdapter, self).rest_args if not self.options.chrome_package_name and not self.options.chrome_apk: raise Exception('Either the --chrome-package-name or --chrome-apk ' 'command line arguments must be used.') if not self.options.chrome_package_name: self.options.chrome_package_name = apk_helper.GetPackageName( self.options.chrome_apk) logger.info("Using Chrome apk's default package %s." % self.options.chrome_package_name) args.extend(['--package-name', self.options.chrome_package_name]) # add the product postional argument args.append(CHROME_ANDROID) return args def maybe_install_webview_provider(device, apk): if apk: logger.info('Will install WebView apk at ' + apk) return webview_app.UseWebViewProvider(device, apk) else: return no_op() def maybe_install_user_apk(device, apk, expected_pkg=None): """contextmanager to install apk on device. Args: device: DeviceUtils instance on which to install the apk. apk: Apk file path on host. expected_pkg: Optional, check that apk's package name matches. Returns: If apk evaluates to false, returns a do-nothing contextmanager. Otherwise, returns a contextmanager to install apk on device. """ if apk: pkg = apk_helper.GetPackageName(apk) if expected_pkg and pkg != expected_pkg: raise ValueError('{} has incorrect package name: {}, expected {}.'.format( apk, pkg, expected_pkg)) install_as_needed = app_installed(device, apk) logger.info('Will install ' + pkg + ' at ' + apk) else: install_as_needed = no_op() return install_as_needed @contextlib.contextmanager def app_installed(device, apk): pkg = apk_helper.GetPackageName(apk) device.Install(apk) try: yield finally: device.Uninstall(pkg) # Dummy contextmanager to simplify multiple optional managers. @contextlib.contextmanager def no_op(): yield # This is not really a "script test" so does not need to manually add # any additional compile targets. def main_compile_targets(args): json.dump([], args.output) def main(): devil_chromium.Initialize() devices = device_utils.DeviceUtils.HealthyDevices() if not devices: logger.error('There are no devices attached to this host. Exiting script.') return 1 # Only 1 device is supported for Android locally, this will work well with # sharding support via swarming infra. device = devices[0] adapter = _get_adapter(device) if adapter.options.verbose: if adapter.options.verbose == 1: logger.setLevel(logging.INFO) else: logger.setLevel(logging.DEBUG) # WPT setup for chrome and webview requires that PATH contains adb. platform_tools_path = os.path.dirname(devil_env.config.FetchPath('adb')) os.environ['PATH'] = ':'.join([platform_tools_path] + os.environ['PATH'].split(':')) return adapter.run_test() if __name__ == '__main__': # Conform minimally to the protocol defined by ScriptTest. if 'compile_targets' in sys.argv: funcs = { 'run': None, 'compile_targets': main_compile_targets, } sys.exit(common.run_script(sys.argv[1:], funcs)) logging.basicConfig(level=logging.WARNING) logger = logging.getLogger() sys.exit(main())
[]
[]
[ "PATH" ]
[]
["PATH"]
python
1
0
algo/02-compare-the-triplets/main.go
// https://www.hackerrank.com/challenges/compare-the-triplets/problem package main import ( "bufio" "fmt" "io" "os" "strconv" "strings" ) // Complete the compareTriplets function below. func compareTriplets(a []int32, b []int32) []int32 { var res = []int32{0, 0} for i := 0; i < 3; i++ { switch { case a[i] > b[i]: res[0]++ case a[i] < b[i]: res[1]++ default: // do nothing } } return res } func main() { reader := bufio.NewReaderSize(os.Stdin, 16*1024*1024) stdout, err := os.Create(os.Getenv("OUTPUT_PATH")) checkError(err) defer stdout.Close() writer := bufio.NewWriterSize(stdout, 16*1024*1024) aTemp := strings.Split(strings.TrimSpace(readLine(reader)), " ") var a []int32 for i := 0; i < 3; i++ { aItemTemp, err := strconv.ParseInt(aTemp[i], 10, 64) checkError(err) aItem := int32(aItemTemp) a = append(a, aItem) } bTemp := strings.Split(strings.TrimSpace(readLine(reader)), " ") var b []int32 for i := 0; i < 3; i++ { bItemTemp, err := strconv.ParseInt(bTemp[i], 10, 64) checkError(err) bItem := int32(bItemTemp) b = append(b, bItem) } result := compareTriplets(a, b) for i, resultItem := range result { fmt.Fprintf(writer, "%d", resultItem) if i != len(result)-1 { fmt.Fprintf(writer, " ") } } fmt.Fprintf(writer, "\n") writer.Flush() } func readLine(reader *bufio.Reader) string { str, _, err := reader.ReadLine() if err == io.EOF { return "" } return strings.TrimRight(string(str), "\r\n") } func checkError(err error) { if err != nil { panic(err) } }
[ "\"OUTPUT_PATH\"" ]
[]
[ "OUTPUT_PATH" ]
[]
["OUTPUT_PATH"]
go
1
0
pkg/joinserver/errors.go
// Copyright © 2019 The Things Network Foundation, The Things Industries B.V. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package joinserver import "go.thethings.network/lorawan-stack/pkg/errors" var ( errCheckMIC = errors.Define("check_mic", "MIC check failed") errComputeMIC = errors.DefineInvalidArgument("compute_mic", "failed to compute MIC") errDecodePayload = errors.DefineInvalidArgument("decode_payload", "failed to decode payload") errDeriveAppSKey = errors.Define("derive_app_s_key", "failed to derive application session key") errDeriveNwkSKeys = errors.Define("derive_nwk_s_keys", "failed to derive network session keys") errDevNonceTooHigh = errors.DefineInvalidArgument("dev_nonce_too_high", "DevNonce is too high") errDevNonceTooSmall = errors.DefineInvalidArgument("dev_nonce_too_small", "DevNonce is too small") errDuplicateIdentifiers = errors.DefineAlreadyExists("duplicate_identifiers", "a device identified by the identifiers already exists") errEncodePayload = errors.DefineInvalidArgument("encode_payload", "failed to encode payload") errEncryptPayload = errors.Define("encrypt_payload", "failed to encrypt JoinAccept") errEndDeviceRequest = errors.DefineInvalidArgument("end_device_request", "GetEndDeviceRequest is invalid") errForwardJoinRequest = errors.Define("forward_join_request", "failed to forward JoinRequest") errGenerateSessionKeyID = errors.Define("generate_session_key_id", "failed to generate session key ID") errDeviceNotFound = errors.DefineNotFound("device_not_found", "device not found") errInvalidIdentifiers = errors.DefineInvalidArgument("invalid_identifiers", "invalid identifiers") errJoinNonceTooHigh = errors.Define("join_nonce_too_high", "JoinNonce is too high") errMICMismatch = errors.DefineInvalidArgument("mic_mismatch", "MIC mismatch") errNetIDMismatch = errors.DefineInvalidArgument("net_id_mismatch", "NetID `{net_id}` does not match") errNoAppKey = errors.DefineCorruption("no_app_key", "no AppKey specified") errNoAppSKey = errors.DefineCorruption("no_app_s_key", "no AppSKey specified") errNoDevAddr = errors.DefineCorruption("no_dev_addr", "no DevAddr specified") errNoDevEUI = errors.DefineInvalidArgument("no_dev_eui", "no DevEUI specified") errNoFNwkSIntKey = errors.DefineCorruption("no_f_nwk_s_int_key", "no FNwkSIntKey specified") errNoJoinEUI = errors.DefineInvalidArgument("no_join_eui", "no JoinEUI specified") errNoJoinRequest = errors.DefineInvalidArgument("no_join_request", "no JoinRequest specified") errNoNwkKey = errors.DefineCorruption("no_nwk_key", "no NwkKey specified") errNoNwkSEncKey = errors.DefineCorruption("no_nwk_s_enc_key", "no NwkSEncKey specified") errNoNetID = errors.DefineFailedPrecondition("no_net_id", "no NetID specified") errNoPayload = errors.DefineInvalidArgument("no_payload", "no message payload specified") errNoRootKeys = errors.DefineCorruption("no_root_keys", "no root keys specified") errNoSNwkSIntKey = errors.DefineCorruption("no_s_nwk_s_int_key", "no SNwkSIntKey specified") errPayloadLengthMismatch = errors.DefineInvalidArgument("payload_length", "expected length of payload to be equal to 23 got {length}") errProvisionerNotFound = errors.DefineNotFound("provisioner_not_found", "provisioner `{id}` not found") errProvisionerDecode = errors.Define("provisioner_decode", "failed to decode provisioning data") errProvisionEntryCount = errors.DefineInvalidArgument("provision_entry_count", "expected `{expected}` but have `{actual}` entries to provision") errProvisioning = errors.DefineAborted("provisioning", "provisioning failed") errRegistryOperation = errors.DefineInternal("registry_operation", "registry operation failed") errReuseDevNonce = errors.DefineInvalidArgument("reuse_dev_nonce", "DevNonce has already been used") errUnauthenticated = errors.DefineUnauthenticated("unauthenticated", "unauthenticated") errAddressNotAuthorized = errors.DefinePermissionDenied("address_not_authorized", "address `{address}` is not authorized for the entity") errUnknownAppEUI = errors.Define("unknown_app_eui", "AppEUI specified is not known") errUnsupportedLoRaWANVersion = errors.DefineInvalidArgument("lorawan_version", "unsupported LoRaWAN version: {version}", "version") errWrongPayloadType = errors.DefineInvalidArgument("payload_type", "wrong payload type: {type}") )
[]
[]
[]
[]
[]
go
null
null
null
cmd/minikube/cmd/root.go
/* Copyright 2016 The Kubernetes Authors All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package cmd import ( "flag" "fmt" "os" "path/filepath" "runtime" "strings" "time" "github.com/spf13/cobra" "github.com/spf13/pflag" "github.com/spf13/viper" "k8s.io/klog/v2" "k8s.io/kubectl/pkg/util/templates" configCmd "k8s.io/minikube/cmd/minikube/cmd/config" "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/minikube/audit" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/constants" "k8s.io/minikube/pkg/minikube/detect" "k8s.io/minikube/pkg/minikube/exit" "k8s.io/minikube/pkg/minikube/localpath" "k8s.io/minikube/pkg/minikube/out" "k8s.io/minikube/pkg/minikube/reason" "k8s.io/minikube/pkg/minikube/translate" ) var dirs = [...]string{ localpath.MiniPath(), localpath.MakeMiniPath("certs"), localpath.MakeMiniPath("machines"), localpath.MakeMiniPath("cache"), localpath.MakeMiniPath("cache", "iso"), localpath.MakeMiniPath("config"), localpath.MakeMiniPath("addons"), localpath.MakeMiniPath("files"), localpath.MakeMiniPath("logs"), } // RootCmd represents the base command when called without any subcommands var RootCmd = &cobra.Command{ Use: "minikube", Short: "minikube quickly sets up a local Kubernetes cluster", Long: `minikube provisions and manages local Kubernetes clusters optimized for development workflows.`, PersistentPreRun: func(cmd *cobra.Command, args []string) { for _, path := range dirs { if err := os.MkdirAll(path, 0o777); err != nil { exit.Error(reason.HostHomeMkdir, "Error creating minikube directory", err) } } userName := viper.GetString(config.UserFlag) if !validateUsername(userName) { out.WarningT("User name '{{.username}}' is not valid", out.V{"username": userName}) exit.Message(reason.Usage, "User name must be 60 chars or less.") } }, } // Execute adds all child commands to the root command sets flags appropriately. // This is called by main.main(). It only needs to happen once to the rootCmd. func Execute() { defer audit.Log(time.Now()) // Check whether this is a windows binary (.exe) running inisde WSL. if runtime.GOOS == "windows" && detect.IsMicrosoftWSL() { var found = false for _, a := range os.Args { if a == "--force" { found = true break } } if !found { exit.Message(reason.WrongBinaryWSL, "You are trying to run windows .exe binary inside WSL, for better integration please use Linux binary instead (Download at https://minikube.sigs.k8s.io/docs/start/.). Otherwise if you still want to do this, you can do it using --force") } } _, callingCmd := filepath.Split(os.Args[0]) if callingCmd == "kubectl" { // If the user is using the minikube binary as kubectl, allow them to specify the kubectl context without also specifying minikube profile profile := "" for i, a := range os.Args { if a == "--context" { profile = fmt.Sprintf("--profile=%s", os.Args[i+1]) break } else if strings.HasPrefix(a, "--context=") { context := strings.Split(a, "=")[1] profile = fmt.Sprintf("--profile=%s", context) break } } if profile != "" { os.Args = append([]string{RootCmd.Use, callingCmd, profile, "--"}, os.Args[1:]...) } else { os.Args = append([]string{RootCmd.Use, callingCmd, "--"}, os.Args[1:]...) } } for _, c := range RootCmd.Commands() { c.Short = translate.T(c.Short) c.Long = translate.T(c.Long) c.Flags().VisitAll(func(f *pflag.Flag) { f.Usage = translate.T(f.Usage) }) c.SetUsageTemplate(usageTemplate()) } RootCmd.Short = translate.T(RootCmd.Short) RootCmd.Long = translate.T(RootCmd.Long) RootCmd.Flags().VisitAll(func(f *pflag.Flag) { f.Usage = translate.T(f.Usage) }) if runtime.GOOS != "windows" { // add minikube binaries to the path targetDir := localpath.MakeMiniPath("bin") addToPath(targetDir) } // Universally ensure that we never speak to the wrong DOCKER_HOST if err := oci.PointToHostDockerDaemon(); err != nil { klog.Errorf("oci env: %v", err) } if err := oci.PointToHostPodman(); err != nil { klog.Errorf("oci env: %v", err) } if err := RootCmd.Execute(); err != nil { // Cobra already outputs the error, typically because the user provided an unknown command. os.Exit(reason.ExProgramUsage) } } // usageTemplate just calls translate.T on the default usage template // explicitly using the raw string instead of calling c.UsageTemplate() // so the extractor can find this monstrosity of a string func usageTemplate() string { return fmt.Sprintf(`%s:{{if .Runnable}} {{.UseLine}}{{end}}{{if .HasAvailableSubCommands}} {{.CommandPath}} [command]{{end}}{{if gt (len .Aliases) 0}} %s: {{.NameAndAliases}}{{end}}{{if .HasExample}} %s: {{.Example}}{{end}}{{if .HasAvailableSubCommands}} %s:{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}} {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}} %s: {{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}} %s: {{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}} %s:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}} {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}} %s{{end}} `, translate.T("Usage"), translate.T("Aliases"), translate.T("Examples"), translate.T("Available Commands"), translate.T("Flags"), translate.T("Global Flags"), translate.T("Additional help topics"), translate.T(`Use "{{.CommandPath}} [command] --help" for more information about a command.`)) } func init() { klog.InitFlags(nil) // preset logtostderr and alsologtostderr only for test runs, for normal runs consider flags in main() if strings.HasPrefix(filepath.Base(os.Args[0]), "e2e-") || strings.HasSuffix(os.Args[0], "test") { if err := flag.Set("logtostderr", "false"); err != nil { klog.Warningf("Unable to set default flag value for logtostderr: %v", err) } if err := flag.Set("alsologtostderr", "false"); err != nil { klog.Warningf("Unable to set default flag value for alsologtostderr: %v", err) } } pflag.CommandLine.AddGoFlagSet(flag.CommandLine) // avoid `generate-docs_test.go` complaining about "Docs are not updated" RootCmd.PersistentFlags().StringP(config.ProfileName, "p", constants.DefaultClusterName, `The name of the minikube VM being used. This can be set to allow having multiple instances of minikube independently.`) RootCmd.PersistentFlags().StringP(configCmd.Bootstrapper, "b", "kubeadm", "The name of the cluster bootstrapper that will set up the Kubernetes cluster.") RootCmd.PersistentFlags().String(config.UserFlag, "", "Specifies the user executing the operation. Useful for auditing operations executed by 3rd party tools. Defaults to the operating system username.") groups := templates.CommandGroups{ { Message: translate.T("Basic Commands:"), Commands: []*cobra.Command{ startCmd, statusCmd, stopCmd, deleteCmd, dashboardCmd, pauseCmd, unpauseCmd, }, }, { Message: translate.T("Images Commands:"), Commands: []*cobra.Command{ dockerEnvCmd, podmanEnvCmd, cacheCmd, imageCmd, }, }, { Message: translate.T("Configuration and Management Commands:"), Commands: []*cobra.Command{ configCmd.AddonsCmd, configCmd.ConfigCmd, configCmd.ProfileCmd, updateContextCmd, }, }, { Message: translate.T("Networking and Connectivity Commands:"), Commands: []*cobra.Command{ serviceCmd, tunnelCmd, }, }, { Message: translate.T("Advanced Commands:"), Commands: []*cobra.Command{ mountCmd, sshCmd, kubectlCmd, nodeCmd, }, }, { Message: translate.T("Troubleshooting Commands:"), Commands: []*cobra.Command{ sshKeyCmd, sshHostCmd, ipCmd, logsCmd, updateCheckCmd, versionCmd, optionsCmd, }, }, } groups.Add(RootCmd) // Ungrouped commands will show up in the "Other Commands" section RootCmd.AddCommand(completionCmd) templates.ActsAsRootCommand(RootCmd, []string{"options"}, groups...) if err := viper.BindPFlags(RootCmd.PersistentFlags()); err != nil { exit.Error(reason.InternalBindFlags, "Unable to bind flags", err) } translate.DetermineLocale() cobra.OnInitialize(initConfig) } // initConfig reads in config file and ENV variables if set. func initConfig() { configPath := localpath.ConfigFile() viper.SetConfigFile(configPath) viper.SetConfigType("json") if err := viper.ReadInConfig(); err != nil { // This config file is optional, so don't emit errors if missing if _, ok := err.(viper.ConfigFileNotFoundError); !ok { klog.Warningf("Error reading config file at %s: %v", configPath, err) } } setupViper() } func setupViper() { viper.SetEnvPrefix(minikubeEnvPrefix) // Replaces '-' in flags with '_' in env variables // e.g. iso-url => $ENVPREFIX_ISO_URL viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_")) viper.AutomaticEnv() viper.SetDefault(config.WantUpdateNotification, true) viper.SetDefault(config.ReminderWaitPeriodInHours, 24) viper.SetDefault(config.WantReportError, false) viper.SetDefault(config.WantReportErrorPrompt, true) viper.SetDefault(config.WantKubectlDownloadMsg, true) viper.SetDefault(config.WantNoneDriverWarning, true) viper.SetDefault(config.ShowDriverDeprecationNotification, true) viper.SetDefault(config.ShowBootstrapperDeprecationNotification, true) } func addToPath(dir string) { new := fmt.Sprintf("%s:%s", dir, os.Getenv("PATH")) klog.Infof("Updating PATH: %s", dir) os.Setenv("PATH", new) } func validateUsername(name string) bool { return len(name) <= 60 }
[ "\"PATH\"" ]
[]
[ "PATH" ]
[]
["PATH"]
go
1
0
Bot/__init__.py
#!/usr/bin/env python3 # This is bot coded by FoxmanTech and used for educational purposes only # https://github.com/samebanezar001 # Copyright FOXMANTECH # Thank you https://github.com/pyrogram/pyrogram import os import logging logging.basicConfig(level=logging.INFO, handlers=[logging.FileHandler('log.txt'), logging.StreamHandler()], format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" ) LOGGER = logging.getLogger(__name__) logging.getLogger("pyrogram").setLevel(logging.WARNING) ENV = bool(os.environ.get('ENV', False)) try: if ENV: AUTH_USER = [] BOT_TOKEN = os.environ.get('BOT_TOKEN') APP_ID = os.environ.get('APP_ID') API_HASH = os.environ.get('API_HASH') API_KEY = os.environ.get('API_KEY') API_EMAIL = os.environ.get('API_EMAIL') GET_AUTH_USER = os.environ.get('AUTH_USER') for i in GET_AUTH_USER.split(','): AUTH_USER.append(int(i)) print(AUTH_USER) else: from sample_config import Config BOT_TOKEN = Config.BOT_TOKEN APP_ID = Config.APP_ID API_HASH = Config.API_HASH API_KEY = Config.API_KEY API_EMAIL = Config.API_EMAIL AUTH_USER = Config.AUTH_USERS print(AUTH_USER) except KeyError: LOGGER.error('One or more configuration values are missing exiting now.') exit(1) class Msg: source = "\nsource:https://github.com/samebanezar001/File-Link-Bot" start = "\n<b>This bot uploads telegram files to MixDrop.co,File.io.\nAdmin: @Foxmantech002</b>" error = "something is went wrong\n{error} \ncontact admin @Foxmantech002" help = "Usage: <b>Send any file and the bot will upload it to MixDrop.co,File.io</b>"
[]
[]
[ "AUTH_USER", "API_KEY", "ENV", "BOT_TOKEN", "APP_ID", "API_EMAIL", "API_HASH" ]
[]
["AUTH_USER", "API_KEY", "ENV", "BOT_TOKEN", "APP_ID", "API_EMAIL", "API_HASH"]
python
7
0
Source/Git/wb_git_callback_client_win32.py
''' ==================================================================== Copyright (c) 2016-2017 Barry A Scott. All rights reserved. This software is licensed as described in the file LICENSE.txt, which you should have received as part of this distribution. ==================================================================== wb_git_callback_client_win32.py called with argv[1:] as the prompt expects a single line output as response. ''' import sys import os import ctypes class WbGitcallback: def __init__( self ): self.pipe_name = r'\\.\pipe\SCM Workbench GIT callback' def callback( self, argv ): if argv[1] == 'askpass': return self.askPass( argv[2] ) elif argv[1] == 'editor': return self.editor( argv[2] ) elif argv[1] == 'sequence-editor': return self.sequenceEditor( argv[2] ) else: print( 'Error: Unknown callback command: %r' % (argv[1:],) ) return 1 def askPass( self, prompt ): rc, reply = self.sendRequest( 'askpass', prompt ) if reply is not None: print( reply ) return rc def editor( self, filename ): rc, reply = self.sendRequest( 'editor', filename ) if reply is not None and reply != '': print( reply ) return rc def sequenceEditor( self, filename ): rc, reply = self.sendRequest( 'sequence-editor', filename ) if reply is not None and reply != '': print( reply ) return rc def sendRequest( self, facility, param ): request = '%s\0%s' % (facility, param) request = request.encode( 'utf-8' ) buf_size = ctypes.c_int( 256 ) buf_result = ctypes.create_string_buffer( buf_size.value ) rc = ctypes.windll.kernel32.CallNamedPipeW( self.pipe_name, request, len(request), buf_result, buf_size, ctypes.byref( buf_size ), 0 ) if rc == 0: err = ctypes.windll.kernel32.GetLastError() if err == 2: return 1, None errmsg = self.__getErrorMessage( err ) with open( os.path.join( os.environ['USERPROFILE'], 'wb_scm_git_callback.log' ), 'a' ) as f: f.write( 'Error: CallNamedPipeA rc=%d err=%d errmsg=%r\n' % (rc, err, errmsg) ) return 1, None else: reply = buf_result.raw[:buf_size.value].decode( 'utf-8' ) return int(reply[0]), reply[1:] def __getErrorMessage( self, err ): FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000 FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200 errmsg_size = ctypes.c_int( 256 ) errmsg = ctypes.create_string_buffer( errmsg_size.value + 1 ) rc = ctypes.windll.kernel32.FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, # __in DWORD dwFlags, None, # __in_opt LPCVOID lpSource, err, # __in DWORD dwMessageId, 0, # __in DWORD dwLanguageId, errmsg, # __out LPTSTR lpBuffer, errmsg_size, # __in DWORD nSize, None # __in_opt va_list *Arguments ) if rc == 0: return 'error 0x%8.8x' % (err,) return errmsg.value if __name__ == '__main__': sys.exit( WbGitcallback().callback( sys.argv ) )
[]
[]
[ "USERPROFILE" ]
[]
["USERPROFILE"]
python
1
0
examples/sendListMessage/main.go
package main import ( "encoding/gob" "fmt" "os" "time" "github.com/Rhymen/go-whatsapp/binary/proto" qrcodeTerminal "github.com/Baozisoftware/qrcode-terminal-go" "github.com/Rhymen/go-whatsapp" ) func main() { //create new WhatsApp connection wac, err := whatsapp.NewConn(5 * time.Second) if err != nil { fmt.Fprintf(os.Stderr, "error creating connection: %v\n", err) return } err = login(wac) if err != nil { fmt.Fprintf(os.Stderr, "error logging in: %v\n", err) return } <-time.After(6 * time.Second) previousMessage := "How about u" quotedMessage := proto.Message{ Conversation: &previousMessage, } ContextInfo := whatsapp.ContextInfo{ QuotedMessage: &quotedMessage, QuotedMessageID: "", //Original message ID Participant: "", //Who sent the original message } var Section = []whatsapp.Section{ { Title: "Section title 1", Rows: []whatsapp.Row{{ Title: "Row title 1", Description: "Row description 1", RowId: "rowid1", // no white space in rowid }, { Title: "Row title 2", Description: "Row description 2", RowId: "rowId2", }, }, }, } Section = append(Section, whatsapp.Section{ Title: "Section title 2", Rows: []whatsapp.Row{ { Title: "Row title 3", Description: "Row description 3", RowId: "rowId3", }, }, }, ) msg := whatsapp.ListMessage{ Info: whatsapp.MessageInfo{ RemoteJid: "[email protected]", }, ContextInfo: ContextInfo, Title: "This is List *title*", Description: "This is List _description_", ButtonText: "This is List buttonText", // ButtonText dosn't support html tag FooterText: "This is List footerText", // this isn't actually showing in whatsapp web ListType: proto.ListMessage_SINGLE_SELECT, Sections: Section, } msgId, err := wac.Send(msg) if err != nil { fmt.Fprintf(os.Stderr, "error sending message: %v", err) os.Exit(1) } else { fmt.Println("Message Sent -> ID : " + msgId) <-time.After(3 * time.Second) } } func login(wac *whatsapp.Conn) error { //load saved session session, err := readSession() if err == nil { //restore session session, err = wac.RestoreWithSession(session) if err != nil { return fmt.Errorf("restoring failed: %v\n", err) } } else { //no saved session -> regular login qr := make(chan string) go func() { terminal := qrcodeTerminal.New() terminal.Get(<-qr).Print() }() session, err = wac.Login(qr) if err != nil { return fmt.Errorf("error during login: %v\n", err) } } //save session err = writeSession(session) if err != nil { return fmt.Errorf("error saving session: %v\n", err) } return nil } func readSession() (whatsapp.Session, error) { session := whatsapp.Session{} file, err := os.Open(os.TempDir() + "/whatsappSession2.gob") if err != nil { return session, err } defer file.Close() decoder := gob.NewDecoder(file) err = decoder.Decode(&session) if err != nil { return session, err } return session, nil } func writeSession(session whatsapp.Session) error { file, err := os.Create(os.TempDir() + "/whatsappSession.gob") if err != nil { return err } defer file.Close() encoder := gob.NewEncoder(file) err = encoder.Encode(session) if err != nil { return err } return nil }
[]
[]
[]
[]
[]
go
null
null
null
vendor/github.com/lucaslorentz/caddy-docker-proxy/plugin/loader.go
package plugin import ( "bytes" "context" "flag" "log" "os" "time" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" "github.com/docker/docker/client" "github.com/mholt/caddy" ) var pollingInterval = 30 * time.Second func init() { flag.DurationVar(&pollingInterval, "docker-polling-interval", 30*time.Second, "Interval caddy should manually check docker for a new caddyfile") } // DockerLoader generates caddy files from docker swarm information type DockerLoader struct { initialized bool dockerClient *client.Client generator *CaddyfileGenerator timer *time.Timer skipEvents bool input caddy.CaddyfileInput } // CreateDockerLoader creates a docker loader func CreateDockerLoader() *DockerLoader { return &DockerLoader{ input: caddy.CaddyfileInput{ ServerTypeName: "http", }, } } // Load returns the current caddy file input func (dockerLoader *DockerLoader) Load(serverType string) (caddy.Input, error) { if serverType != "http" { return nil, nil } if !dockerLoader.initialized { dockerLoader.initialized = true dockerClient, err := client.NewEnvClient() if err != nil { log.Printf("Docker connection failed: %v", err) return nil, nil } dockerPing, err := dockerClient.Ping(context.Background()) if err != nil { log.Printf("Docker ping failed: %v", err) return nil, nil } dockerClient.NegotiateAPIVersionPing(dockerPing) dockerLoader.dockerClient = dockerClient dockerLoader.generator = CreateGenerator( WrapDockerClient(dockerClient), CreateDockerUtils(), GetGeneratorOptions(), ) if pollingIntervalEnv := os.Getenv("CADDY_DOCKER_POLLING_INTERVAL"); pollingIntervalEnv != "" { if p, err := time.ParseDuration(pollingIntervalEnv); err != nil { log.Printf("Failed to parse CADDY_DOCKER_POLLING_INTERVAL: %v", err) } else { pollingInterval = p } } log.Printf("[INFO] Docker polling interval: %v", pollingInterval) dockerLoader.timer = time.AfterFunc(pollingInterval, func() { dockerLoader.update(true) }) dockerLoader.update(false) go dockerLoader.monitorEvents() } return dockerLoader.input, nil } func (dockerLoader *DockerLoader) monitorEvents() { args := filters.NewArgs() args.Add("scope", "swarm") args.Add("scope", "local") args.Add("type", "service") args.Add("type", "container") args.Add("type", "config") eventsChan, errorChan := dockerLoader.dockerClient.Events(context.Background(), types.EventsOptions{ Filters: args, }) for { select { case event := <-eventsChan: if dockerLoader.skipEvents { continue } update := (event.Type == "container" && event.Action == "start") || (event.Type == "container" && event.Action == "stop") || (event.Type == "container" && event.Action == "die") || (event.Type == "service" && event.Action == "create") || (event.Type == "service" && event.Action == "update") || (event.Type == "service" && event.Action == "remove") || (event.Type == "config" && event.Action == "create") || (event.Type == "config" && event.Action == "remove") if update { dockerLoader.skipEvents = true dockerLoader.timer.Reset(100 * time.Millisecond) } case err := <-errorChan: log.Println(err) } } } func (dockerLoader *DockerLoader) update(reloadIfChanged bool) bool { dockerLoader.timer.Reset(pollingInterval) dockerLoader.skipEvents = false newContents := dockerLoader.generator.GenerateCaddyFile() if bytes.Equal(dockerLoader.input.Contents, newContents) { return false } newInput := caddy.CaddyfileInput{ ServerTypeName: "http", Contents: newContents, } if err := caddy.ValidateAndExecuteDirectives(newInput, nil, true); err != nil { log.Printf("[ERROR] CaddyFile error: %s", err) log.Printf("[INFO] Wrong CaddyFile:\n%s", newContents) } else { log.Printf("[INFO] New CaddyFile:\n%s", newInput.Contents) dockerLoader.input = newInput if reloadIfChanged { ReloadCaddy(dockerLoader) } } return true }
[ "\"CADDY_DOCKER_POLLING_INTERVAL\"" ]
[]
[ "CADDY_DOCKER_POLLING_INTERVAL" ]
[]
["CADDY_DOCKER_POLLING_INTERVAL"]
go
1
0
src/werkzeug/_reloader.py
import os import subprocess import sys import threading import time from itertools import chain from typing import Any from typing import Optional from ._internal import _log def _iter_module_files(): """This iterates over all relevant Python files. It goes through all loaded files from modules, all files in folders of already loaded modules as well as all files reachable through a package. """ # The list is in case sys.modules is modified during iteration. for module in list(sys.modules.values()): if module is None: continue filename = getattr(module, "__file__", None) if filename: if os.path.isdir(filename) and os.path.exists( os.path.join(filename, "__init__.py") ): filename = os.path.join(filename, "__init__.py") old = None while not os.path.isfile(filename): old = filename filename = os.path.dirname(filename) if filename == old: break else: if filename[-4:] in (".pyc", ".pyo"): filename = filename[:-1] yield filename def _find_observable_paths(extra_files=None): """Finds all paths that should be observed.""" rv = { os.path.dirname(os.path.abspath(x)) if os.path.isfile(x) else os.path.abspath(x) for x in sys.path } for filename in extra_files or (): rv.add(os.path.dirname(os.path.abspath(filename))) for module in list(sys.modules.values()): fn = getattr(module, "__file__", None) if fn is None: continue fn = os.path.abspath(fn) rv.add(os.path.dirname(fn)) return _find_common_roots(rv) def _get_args_for_reloading(): """Determine how the script was executed, and return the args needed to execute it again in a new process. """ rv = [sys.executable] py_script = sys.argv[0] args = sys.argv[1:] # Need to look at main module to determine how it was executed. __main__ = sys.modules["__main__"] # The value of __package__ indicates how Python was called. It may # not exist if a setuptools script is installed as an egg. It may be # set incorrectly for entry points created with pip on Windows. if getattr(__main__, "__package__", None) is None or ( os.name == "nt" and __main__.__package__ == "" and not os.path.exists(py_script) and os.path.exists(f"{py_script}.exe") ): # Executed a file, like "python app.py". py_script = os.path.abspath(py_script) if os.name == "nt": # Windows entry points have ".exe" extension and should be # called directly. if not os.path.exists(py_script) and os.path.exists(f"{py_script}.exe"): py_script += ".exe" if ( os.path.splitext(sys.executable)[1] == ".exe" and os.path.splitext(py_script)[1] == ".exe" ): rv.pop(0) rv.append(py_script) else: # Executed a module, like "python -m werkzeug.serving". if sys.argv[0] == "-m": # Flask works around previous behavior by putting # "-m flask" in sys.argv. # TODO remove this once Flask no longer misbehaves args = sys.argv else: if os.path.isfile(py_script): # Rewritten by Python from "-m script" to "/path/to/script.py". py_module = __main__.__package__ name = os.path.splitext(os.path.basename(py_script))[0] if name != "__main__": py_module += f".{name}" else: # Incorrectly rewritten by pydevd debugger from "-m script" to "script". py_module = py_script rv.extend(("-m", py_module.lstrip("."))) rv.extend(args) return rv def _find_common_roots(paths): """Out of some paths it finds the common roots that need monitoring.""" paths = [x.split(os.path.sep) for x in paths] root = {} for chunks in sorted(paths, key=len, reverse=True): node = root for chunk in chunks: node = node.setdefault(chunk, {}) node.clear() rv = set() def _walk(node, path): for prefix, child in node.items(): _walk(child, path + (prefix,)) if not node: rv.add("/".join(path)) _walk(root, ()) return rv class ReloaderLoop: extra_files: Any interval: float name: Optional[str] = None # Patched during tests. Wrapping with `staticmethod` is required in # case `time.sleep` has been replaced by a non-c function (e.g. by # `eventlet.monkey_patch`) before we get here _sleep = staticmethod(time.sleep) def __init__(self, extra_files: Optional[Any] = None, interval: float = 1): self.extra_files = {os.path.abspath(x) for x in extra_files or ()} self.interval = interval def run(self): pass def restart_with_reloader(self): """Spawn a new Python interpreter with the same arguments as the current one, but running the reloader thread. """ while 1: _log("info", f" * Restarting with {self.name}") args = _get_args_for_reloading() new_environ = os.environ.copy() new_environ["WERKZEUG_RUN_MAIN"] = "true" exit_code = subprocess.call(args, env=new_environ, close_fds=False) if exit_code != 3: return exit_code def trigger_reload(self, filename): self.log_reload(filename) sys.exit(3) def log_reload(self, filename): filename = os.path.abspath(filename) _log("info", f" * Detected change in {filename!r}, reloading") class StatReloaderLoop(ReloaderLoop): name: Any = "stat" def run(self): mtimes = {} while 1: for filename in chain(_iter_module_files(), self.extra_files): try: mtime = os.stat(filename).st_mtime except OSError: continue old_time = mtimes.get(filename) if old_time is None: mtimes[filename] = mtime continue elif mtime > old_time: self.trigger_reload(filename) self._sleep(self.interval) class WatchdogReloaderLoop(ReloaderLoop): observable_paths: Any name: Any observer_class: Any event_handler: Any should_reload: Any def __init__(self, *args, **kwargs): ReloaderLoop.__init__(self, *args, **kwargs) from watchdog.observers import Observer from watchdog.events import FileSystemEventHandler self.observable_paths = set() def _check_modification(filename): if filename in self.extra_files: self.trigger_reload(filename) dirname = os.path.dirname(filename) if dirname.startswith(tuple(self.observable_paths)): if filename.endswith((".pyc", ".pyo", ".py")): self.trigger_reload(filename) class _CustomHandler(FileSystemEventHandler): def on_created(self, event): _check_modification(event.src_path) def on_modified(self, event): _check_modification(event.src_path) def on_moved(self, event): _check_modification(event.src_path) _check_modification(event.dest_path) def on_deleted(self, event): _check_modification(event.src_path) reloader_name = Observer.__name__.lower() if reloader_name.endswith("observer"): reloader_name = reloader_name[:-8] reloader_name += " reloader" self.name = reloader_name self.observer_class = Observer self.event_handler = _CustomHandler() self.should_reload = False def trigger_reload(self, filename): # This is called inside an event handler, which means throwing # SystemExit has no effect. # https://github.com/gorakhargosh/watchdog/issues/294 self.should_reload = True self.log_reload(filename) def run(self): watches = {} observer = self.observer_class() observer.start() try: while not self.should_reload: to_delete = set(watches) paths = _find_observable_paths(self.extra_files) for path in paths: if path not in watches: try: watches[path] = observer.schedule( self.event_handler, path, recursive=True ) except OSError: # Clear this path from list of watches We don't want # the same error message showing again in the next # iteration. watches[path] = None to_delete.discard(path) for path in to_delete: watch = watches.pop(path, None) if watch is not None: observer.unschedule(watch) self.observable_paths = paths self._sleep(self.interval) finally: observer.stop() observer.join() sys.exit(3) reloader_loops: Any = {"stat": StatReloaderLoop, "watchdog": WatchdogReloaderLoop} try: __import__("watchdog.observers") except ImportError: reloader_loops["auto"] = reloader_loops["stat"] else: reloader_loops["auto"] = reloader_loops["watchdog"] def ensure_echo_on(): """Ensure that echo mode is enabled. Some tools such as PDB disable it which causes usability issues after a reload.""" # tcgetattr will fail if stdin isn't a tty if not sys.stdin.isatty(): return try: import termios except ImportError: return attributes = termios.tcgetattr(sys.stdin) if not attributes[3] & termios.ECHO: attributes[3] |= termios.ECHO termios.tcsetattr(sys.stdin, termios.TCSANOW, attributes) def run_with_reloader( main_func, extra_files: Optional[Any] = None, interval: float = 1, reloader_type: str = "auto", ): """Run the given function in an independent Python interpreter.""" import signal reloader = reloader_loops[reloader_type](extra_files, interval) signal.signal(signal.SIGTERM, lambda *args: sys.exit(0)) try: if os.environ.get("WERKZEUG_RUN_MAIN") == "true": ensure_echo_on() t = threading.Thread(target=main_func, args=()) t.setDaemon(True) t.start() reloader.run() else: sys.exit(reloader.restart_with_reloader()) except KeyboardInterrupt: pass
[]
[]
[ "WERKZEUG_RUN_MAIN" ]
[]
["WERKZEUG_RUN_MAIN"]
python
1
0
web/tests/utils/test_pq.py
import pytest import sys import pdb class TestPriorityQueue: def test_add(self, pq): test_val = '123456' pq.add(test_val) val = pq.pop() pq.add(test_val) assert val == test_val def test_max_length(self, pq): test_vals = range(pq.MAX_QUEUE_LENGTH + 1) for t in test_vals: pq.add(t) assert len(pq) == pq.MAX_QUEUE_LENGTH def test_priority_order(self, pq): pq.add('a', priority=0) pq.add('b', priority=1) pq.add('c', priority=2) pq.add('d', priority=3) assert pq.pop() == 'd' def test_priority_order_remove(self, pq): pq.add('a', priority=0) pq.add('b', priority=1) pq.add('c', priority=2) pq.add('d', priority=3) val1 = pq.pop(remove=True) val2 = pq.pop() assert val1 == 'd' assert val2 == 'c' def test_score(self, pq): pq.add('a', priority=0) pq.add('b', priority=1) assert pq.get_score('b') == 1 assert len(pq) == 2 def test_remove_lowest(self, pq): pq.add('a', priority=0) pq.add('b', priority=1) pq.remove_lowest_priority() assert len(pq) == 1 assert pq.pop() == 'b' def test_update_priority(self, pq): pq.add('a', priority=0) pq.add('b', priority=1) pq.increment_priority('b') assert pq.get_score('b') == 2 pq.increment_priority('b', incr=10) # increment by 10 assert pq.get_score('b') == 12 def test_key_removal(self, pq): pq.add('a', priority=0) pq.add('b', priority=1) pq.remove('b') assert len(pq) == 1 assert pq.pop() == 'a' def test_ordering_in_same_priority_values(self, pq): pq.add('a', priority=0) pq.add('b', priority=0) pq.add('c', priority=0) pq.add('d', priority=0) assert pq.pop() == 'd' def test_multi_pop(self, pq): pq.add('e', priority=3) pq.add('a', priority=0) pq.add('b', priority=1) pq.add('c', priority=2) pq.add('d', priority=0) items = pq.multi_pop(3) assert items == ['e', 'c', 'b'] def test_rank(self, pq): pq.add('a', priority=3) pq.add('b', priority=0) assert pq.get_rank('a') == 0 assert pq.get_rank('b') == 1 def test_multi_pop_with_scores(self, pq): pq.add('e', priority=3) pq.add('a', priority=0) pq.add('b', priority=1) pq.add('c', priority=2) pq.add('d', priority=0) items = pq.multi_pop(3, with_scores=True) keys = [k for k, v in items] values = [v for k, v in items] assert keys == ['e', 'c', 'b'] assert values == [3, 2, 1] def test_multi_pop_with_sampling(self, pq): pq.add('e', priority=3) pq.add('a', priority=0) pq.add('b', priority=1) pq.add('c', priority=2) pq.add('d', priority=0) items = pq.multi_pop(3, sample_from=5, with_scores=True) keys = [k for k, v in items] values = [v for k, v in items] assert len(keys) == 3 assert len(values) == 3 assert set(keys) == set(['e', 'b', 'c']) # true because probabilties for others are zero if __name__ == "__main__": # if running outside of docker, make sure redis is running on localhost import os; os.environ["REDIS_HOST"] = "localhost" pytest.main(['-s', '-m', 'focus']) # pytest.main(['-s'])
[]
[]
[ "REDIS_HOST" ]
[]
["REDIS_HOST"]
python
1
0
src/recommendationservice/recommendation_server.py
#!/usr/bin/python # # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import random import time import traceback from concurrent import futures import googleclouddebugger import googlecloudprofiler from google.auth.exceptions import DefaultCredentialsError import grpc from opencensus.ext.stackdriver import trace_exporter as stackdriver_exporter from opencensus.ext.grpc import server_interceptor from opencensus.trace import samplers from opencensus.common.transports.async_ import AsyncTransport import demo_pb2 import demo_pb2_grpc from grpc_health.v1 import health_pb2 from grpc_health.v1 import health_pb2_grpc from logger import getJSONLogger logger = getJSONLogger('recommendationservice-server') def initStackdriverProfiling(): project_id = None try: project_id = os.environ["GCP_PROJECT_ID"] except KeyError: # Environment variable not set pass for retry in range(1, 4): try: if project_id: googlecloudprofiler.start( service='recommendation_server', service_version='1.0.0', verbose=0, project_id=project_id) else: googlecloudprofiler.start( service='recommendation_server', service_version='1.0.0', verbose=0) logger.info("Successfully started Stackdriver Profiler.") return except (BaseException) as exc: logger.info( "Unable to start Stackdriver Profiler Python agent. " + str(exc)) if (retry < 4): logger.info( "Sleeping %d seconds to retry Stackdriver Profiler agent initialization" % (retry*10)) time.sleep(1) else: logger.warning( "Could not initialize Stackdriver Profiler after retrying, giving up") return class RecommendationService(demo_pb2_grpc.RecommendationServiceServicer): def ListRecommendations(self, request, context): max_responses = 5 # fetch list of products from product catalog stub cat_response = product_catalog_stub.ListProducts(demo_pb2.Empty()) product_ids = [x.id for x in cat_response.products] filtered_products = list(set(product_ids)-set(request.product_ids)) num_products = len(filtered_products) num_return = min(max_responses, num_products) # sample list of indicies to return indices = random.sample(range(num_products), num_return) # fetch product ids from indices prod_list = [filtered_products[i] for i in indices] logger.info( "[Recv ListRecommendations] product_ids={}".format(prod_list)) # build and return response response = demo_pb2.ListRecommendationsResponse() response.product_ids.extend(prod_list) return response def Check(self, request, context): return health_pb2.HealthCheckResponse( status=health_pb2.HealthCheckResponse.SERVING) def Watch(self, request, context): return health_pb2.HealthCheckResponse( status=health_pb2.HealthCheckResponse.UNIMPLEMENTED) if __name__ == "__main__": logger.info("initializing recommendationservice") try: if "DISABLE_PROFILER" in os.environ: raise KeyError() else: logger.info("Profiler enabled.") initStackdriverProfiling() except KeyError: logger.info("Profiler disabled.") try: if "DISABLE_TRACING" in os.environ: raise KeyError() else: logger.info("Tracing enabled.") sampler = samplers.AlwaysOnSampler() exporter = stackdriver_exporter.StackdriverExporter( project_id=os.environ.get('GCP_PROJECT_ID'), transport=AsyncTransport) tracer_interceptor = server_interceptor.OpenCensusServerInterceptor( sampler, exporter) except (KeyError, DefaultCredentialsError): logger.info("Tracing disabled.") tracer_interceptor = server_interceptor.OpenCensusServerInterceptor() try: if "DISABLE_DEBUGGER" in os.environ: raise KeyError() else: logger.info("Debugger enabled.") try: googleclouddebugger.enable( module='recommendationserver', version='1.0.0' ) except (Exception, DefaultCredentialsError): logger.error("Could not enable debugger") logger.error(traceback.print_exc()) pass except (Exception, DefaultCredentialsError): logger.info("Debugger disabled.") port = os.environ.get('PORT', "8080") catalog_addr = os.environ.get('PRODUCT_CATALOG_SERVICE_ADDR', '') if catalog_addr == "": raise Exception( 'PRODUCT_CATALOG_SERVICE_ADDR environment variable not set') logger.info("product catalog address: " + catalog_addr) channel = grpc.insecure_channel(catalog_addr) product_catalog_stub = demo_pb2_grpc.ProductCatalogServiceStub(channel) # create gRPC server server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), interceptors=(tracer_interceptor,)) # add class to gRPC server service = RecommendationService() demo_pb2_grpc.add_RecommendationServiceServicer_to_server(service, server) health_pb2_grpc.add_HealthServicer_to_server(service, server) # start server logger.info("listening on port: " + port) server.add_insecure_port('[::]:'+port) server.start() # keep alive try: while True: time.sleep(10000) except KeyboardInterrupt: server.stop(0)
[]
[]
[ "PORT", "GCP_PROJECT_ID", "PRODUCT_CATALOG_SERVICE_ADDR" ]
[]
["PORT", "GCP_PROJECT_ID", "PRODUCT_CATALOG_SERVICE_ADDR"]
python
3
0
plugin.go
package main import ( "fmt" "io" "io/ioutil" "os" "os/exec" "os/user" "path/filepath" "regexp" "strconv" "strings" "sync" "time" "github.com/Sirupsen/logrus" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/credentials/stscreds" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/sts" ) type ( // Config holds input parameters for the plugin Config struct { Actions []string Vars map[string]string Secrets map[string]string InitOptions InitOptions FmtOptions FmtOptions Assertions Assertions Cacert string Sensitive bool RoleARN string RootDir string Parallelism int Targets []string VarFiles []string TerraformDataDir string } // Netrc is credentials for cloning Netrc struct { Machine string Login string Password string } // InitOptions include options for the Terraform's init command InitOptions struct { BackendConfig []string `json:"backend-config"` Lock *bool `json:"lock"` LockTimeout string `json:"lock-timeout"` } // FmtOptions fmt options for the Terraform's fmt command FmtOptions struct { List *bool `json:"list"` Write *bool `json:"write"` Diff *bool `json:"diff"` Check *bool `json:"check"` } // Assertions will check number of expected additions, changes and deletions after terraform plan Assertions struct { AdditionsExact int `json:"additions_exact"` ChangesExact int `json:"changes_exact"` DeletionsExact int `json:"deletions_exact"` } // Plugin represents the plugin instance to be executed Plugin struct { Config Config Netrc Netrc Terraform Terraform } ) // Exec executes the plugin func (p Plugin) Exec() error { // Install specified version of terraform if p.Terraform.Version != "" { err := installTerraform(p.Terraform.Version) if err != nil { return err } } if p.Config.RoleARN != "" { assumeRole(p.Config.RoleARN) } // writing the .netrc file with Github credentials in it. err := writeNetrc(p.Netrc.Machine, p.Netrc.Login, p.Netrc.Password) if err != nil { return err } var terraformDataDir string = ".terraform" if p.Config.TerraformDataDir != "" { terraformDataDir = p.Config.TerraformDataDir os.Setenv("TF_DATA_DIR", p.Config.TerraformDataDir) } var commands []*exec.Cmd commands = append(commands, exec.Command("terraform", "version")) CopyTfEnv() if p.Config.Cacert != "" { commands = append(commands, installCaCert(p.Config.Cacert)) } commands = append(commands, deleteCache(terraformDataDir)) commands = append(commands, initCommand(p.Config.InitOptions)) commands = append(commands, getModules()) // Add commands listed from Actions for _, action := range p.Config.Actions { switch action { case "fmt": commands = append(commands, tfFmt(p.Config)) case "validate": commands = append(commands, tfValidate(p.Config)) case "plan": commands = append(commands, tfPlan(p.Config, false)) case "plan-destroy": commands = append(commands, tfPlan(p.Config, true)) case "apply": commands = append(commands, tfApply(p.Config)) case "destroy": commands = append(commands, tfDestroy(p.Config)) default: return fmt.Errorf("valid actions are: fmt, validate, plan, apply, plan-destroy, destroy. You provided %s", action) } } commands = append(commands, deleteCache(terraformDataDir)) for _, c := range commands { if c.Dir == "" { wd, err := os.Getwd() if err == nil { c.Dir = wd } } if p.Config.RootDir != "" { c.Dir = c.Dir + "/" + p.Config.RootDir } if !p.Config.Sensitive { trace(c) } // Directly pass strerr to standard c.Stderr = os.Stderr // Capture stdout to use for assertions var stdout []byte var errStdout error stdoutIn, _ := c.StdoutPipe() err := c.Start() if err != nil { logrus.WithFields(logrus.Fields{ "error": err, }).Fatal("Failed to execute a command") } // cmd.Wait() should be called only after we finish reading // from stdoutIn and stderrIn. // wg ensures that we finish var wg sync.WaitGroup wg.Add(1) go func() { stdout, errStdout = copyAndCapture(os.Stdout, stdoutIn) wg.Done() }() wg.Wait() err = c.Wait() if err != nil { logrus.WithFields(logrus.Fields{ "error": err, }).Fatal("Failed to run a command") } if errStdout != nil { logrus.WithFields(logrus.Fields{ "error": errStdout, }).Fatal("Failed to capture stdout or stderr") } // Evaluate assertions only when running terraform plan if c.Args[1] == "plan" { p.evaluateAssertions(string(stdout)) } logrus.Debug("Command completed successfully") } return nil } func (p Plugin) evaluateAssertions(planOutput string) { var additions = 0 var changes = 0 var deletions = 0 updateToDateRe := regexp.MustCompile(`No changes\. Infrastructure is up-to-date\.`) if !updateToDateRe.MatchString(planOutput) { // Check if assertions are met based on "Plan: X to add, X to change, X to destroy." in output planRe := regexp.MustCompile(`(?P<Additions>[0-9]+) to add, (?P<Changes>[0-9]+) to change, (?P<Deletions>[0-9]+) to destroy\.`) matches := planRe.FindStringSubmatch(planOutput) if len(matches) != 4 { logrus.Fatal("Unexpected number of matches in terraform output when evaluating assertions") } additions, _ = strconv.Atoi(matches[1]) changes, _ = strconv.Atoi(matches[2]) deletions, _ = strconv.Atoi(matches[3]) } if p.Config.Assertions.AdditionsExact > -1 { if additions != p.Config.Assertions.AdditionsExact { logrus.Fatal(fmt.Sprintf("FATAL: Expected %d additions but saw %d additions on terraform plan", p.Config.Assertions.AdditionsExact, additions)) } else { fmt.Println(fmt.Sprintf("INFO: As expected saw %d additions on terraform plan.", additions)) } } if p.Config.Assertions.ChangesExact > -1 { if changes != p.Config.Assertions.ChangesExact { logrus.Fatal(fmt.Sprintf("FATAL: Expected %d changes but saw %d changes on terraform plan", p.Config.Assertions.ChangesExact, changes)) } else { fmt.Println(fmt.Sprintf("INFO: As expected saw %d changes on terraform plan.", changes)) } } if p.Config.Assertions.DeletionsExact > -1 { if deletions != p.Config.Assertions.DeletionsExact { logrus.Fatal(fmt.Sprintf("FATAL: Expected %d deletions but saw %d deletions on terraform plan", p.Config.Assertions.DeletionsExact, deletions)) } else { fmt.Println(fmt.Sprintf("INFO: As expected saw %d deletions on terraform plan.", deletions)) } } } func copyAndCapture(w io.Writer, r io.Reader) ([]byte, error) { var out []byte buf := make([]byte, 1024, 1024) for { n, err := r.Read(buf[:]) if n > 0 { d := buf[:n] out = append(out, d...) _, err := w.Write(d) if err != nil { return out, err } } if err != nil { // Read returns io.EOF at the end of file, which is not an error for us if err == io.EOF { err = nil } return out, err } } } // CopyTfEnv creates copies of TF_VAR_ to lowercase func CopyTfEnv() { tfVar := regexp.MustCompile(`^TF_VAR_.*$`) for _, e := range os.Environ() { pair := strings.SplitN(e, "=", 2) if tfVar.MatchString(pair[0]) { name := strings.Split(pair[0], "TF_VAR_") os.Setenv(fmt.Sprintf("TF_VAR_%s", strings.ToLower(name[1])), pair[1]) } } } func assumeRole(roleArn string) { client := sts.New(session.New()) duration := time.Hour * 1 stsProvider := &stscreds.AssumeRoleProvider{ Client: client, Duration: duration, RoleARN: roleArn, RoleSessionName: "drone", } value, err := credentials.NewCredentials(stsProvider).Get() if err != nil { logrus.WithFields(logrus.Fields{ "error": err, }).Fatal("Error assuming role!") } os.Setenv("AWS_ACCESS_KEY_ID", value.AccessKeyID) os.Setenv("AWS_SECRET_ACCESS_KEY", value.SecretAccessKey) os.Setenv("AWS_SESSION_TOKEN", value.SessionToken) } func deleteCache(terraformDataDir string) *exec.Cmd { return exec.Command( "rm", "-rf", terraformDataDir, ) } func getModules() *exec.Cmd { return exec.Command( "terraform", "get", ) } func initCommand(config InitOptions) *exec.Cmd { args := []string{ "init", } for _, v := range config.BackendConfig { args = append(args, fmt.Sprintf("-backend-config=%s", v)) } // True is default in TF if config.Lock != nil { args = append(args, fmt.Sprintf("-lock=%t", *config.Lock)) } // "0s" is default in TF if config.LockTimeout != "" { args = append(args, fmt.Sprintf("-lock-timeout=%s", config.LockTimeout)) } // Fail Terraform execution on prompt args = append(args, "-input=false") return exec.Command( "terraform", args..., ) } func installCaCert(cacert string) *exec.Cmd { ioutil.WriteFile("/usr/local/share/ca-certificates/ca_cert.crt", []byte(cacert), 0644) return exec.Command( "update-ca-certificates", ) } func trace(cmd *exec.Cmd) { fmt.Println("$", strings.Join(cmd.Args, " ")) } func tfApply(config Config) *exec.Cmd { args := []string{ "apply", } for _, v := range config.Targets { args = append(args, "--target", fmt.Sprintf("%s", v)) } if config.Parallelism > 0 { args = append(args, fmt.Sprintf("-parallelism=%d", config.Parallelism)) } if config.InitOptions.Lock != nil { args = append(args, fmt.Sprintf("-lock=%t", *config.InitOptions.Lock)) } if config.InitOptions.LockTimeout != "" { args = append(args, fmt.Sprintf("-lock-timeout=%s", config.InitOptions.LockTimeout)) } args = append(args, getTfoutPath()) return exec.Command( "terraform", args..., ) } func tfDestroy(config Config) *exec.Cmd { args := []string{ "destroy", } for _, v := range config.Targets { args = append(args, fmt.Sprintf("-target=%s", v)) } args = append(args, varFiles(config.VarFiles)...) args = append(args, vars(config.Vars)...) if config.Parallelism > 0 { args = append(args, fmt.Sprintf("-parallelism=%d", config.Parallelism)) } if config.InitOptions.Lock != nil { args = append(args, fmt.Sprintf("-lock=%t", *config.InitOptions.Lock)) } if config.InitOptions.LockTimeout != "" { args = append(args, fmt.Sprintf("-lock-timeout=%s", config.InitOptions.LockTimeout)) } args = append(args, "-force") return exec.Command( "terraform", args..., ) } func tfPlan(config Config, destroy bool) *exec.Cmd { args := []string{ "plan", } if destroy { args = append(args, "-destroy") } else { args = append(args, fmt.Sprintf("-out=%s", getTfoutPath())) } for _, v := range config.Targets { args = append(args, "--target", fmt.Sprintf("%s", v)) } args = append(args, varFiles(config.VarFiles)...) args = append(args, vars(config.Vars)...) if config.Parallelism > 0 { args = append(args, fmt.Sprintf("-parallelism=%d", config.Parallelism)) } if config.InitOptions.Lock != nil { args = append(args, fmt.Sprintf("-lock=%t", *config.InitOptions.Lock)) } if config.InitOptions.LockTimeout != "" { args = append(args, fmt.Sprintf("-lock-timeout=%s", config.InitOptions.LockTimeout)) } return exec.Command( "terraform", args..., ) } func tfValidate(config Config) *exec.Cmd { args := []string{ "validate", } for _, v := range config.VarFiles { args = append(args, fmt.Sprintf("-var-file=%s", v)) } for k, v := range config.Vars { args = append(args, "-var", fmt.Sprintf("%s=%s", k, v)) } return exec.Command( "terraform", args..., ) } func tfFmt(config Config) *exec.Cmd { args := []string{ "fmt", } if config.FmtOptions.List != nil { args = append(args, fmt.Sprintf("-list=%t", *config.FmtOptions.List)) } if config.FmtOptions.Write != nil { args = append(args, fmt.Sprintf("-write=%t", *config.FmtOptions.Write)) } if config.FmtOptions.Diff != nil { args = append(args, fmt.Sprintf("-diff=%t", *config.FmtOptions.Diff)) } if config.FmtOptions.Check != nil { args = append(args, fmt.Sprintf("-check=%t", *config.FmtOptions.Check)) } return exec.Command( "terraform", args..., ) } func getTfoutPath() string { terraformDataDir := os.Getenv("TF_DATA_DIR") if terraformDataDir == ".terraform" || terraformDataDir == "" { return "plan.tfout" } else { return fmt.Sprintf("%s.plan.tfout", terraformDataDir) } } func vars(vs map[string]string) []string { var args []string for k, v := range vs { args = append(args, "-var", fmt.Sprintf("%s=%s", k, v)) } return args } func varFiles(vfs []string) []string { var args []string for _, v := range vfs { args = append(args, fmt.Sprintf("-var-file=%s", v)) } return args } // helper function to write a netrc file. // The following code comes from the official Git plugin for Drone: // https://github.com/drone-plugins/drone-git/blob/8386effd2fe8c8695cf979427f8e1762bd805192/utils.go#L43-L68 func writeNetrc(machine, login, password string) error { if machine == "" { return nil } out := fmt.Sprintf( netrcFile, machine, login, password, ) home := "/root" u, err := user.Current() if err == nil { home = u.HomeDir } path := filepath.Join(home, ".netrc") return ioutil.WriteFile(path, []byte(out), 0600) } const netrcFile = ` machine %s login %s password %s `
[ "\"TF_DATA_DIR\"" ]
[]
[ "TF_DATA_DIR" ]
[]
["TF_DATA_DIR"]
go
1
0
depend/zcash/qa/zcash/smoke_tests.py
#!/usr/bin/env python3 # # Execute the standard smoke tests for Zcash releases. # import argparse import datetime import os import requests import subprocess import sys import time import traceback from decimal import Decimal from slickrpc import Proxy from slickrpc.exc import RpcException DEFAULT_FEE = Decimal('0.0001') URL_FAUCET_DONATION = 'https://faucet.testnet.z.cash/donations' URL_FAUCET_TAP = 'https://faucet.testnet.z.cash/' # # Smoke test definitions # # (case, expected_mainnet, expected_testnet) SMOKE_TESTS = [ # zcashd start/stop/restart flows ('1a', True, True), # zcashd start ('1b', True, True), # Graceful zcashd stop ('1c', True, True), # Ungraceful zcashd stop ('1d', True, True), # zcashd start; graceful zcashd stop; zcashd start ('1e', True, True), # zcashd start; ungraceful zcashd stop; zcashd start # Control ('2a', True, True), # Run getinfo ('2b', True, True), # Run help # Address generation ('3a', True, True), # Generate a Sprout z-addr ('3b', True, True), # Generate multiple Sprout z-addrs ('3c', True, True), # Generate a t-addr ('3d', True, True), # Generate multiple t-addrs ('3e', True, True), # Generate a Sapling z-addr ('3f', True, True), # Generate multiple Sapling z-addrs # Transactions ('4a', True, True ), # Send funds from Sprout z-addr to same Sprout z-addr ('4b', True, True ), # Send funds from Sprout z-addr to a different Sprout z-addr ('4c', True, True ), # Send funds from Sprout z-addr to a t-addr ('4d', True, True ), # Send funds from t-addr to Sprout z-addr ('4e', True, True ), # Send funds from t-addr to t-addr ('4f', True, True ), # Send funds from t-addr to Sapling z-addr ('4g', True, True ), # Send funds from Sapling z-addr to same Sapling z-addr ('4h', True, True ), # Send funds from Sapling z-addr to a different Sapling z-addr ('4i', True, True ), # Send funds from Sapling z-addr to a t-addr ('4j', False, False), # Send funds from Sprout z-addr to Sapling z-addr ('4k', True, True ), # Send funds from Sprout z-addr to multiple Sprout z-addrs ('4l', True, True ), # Send funds from Sprout z-addr to multiple t-addrs ('4m', True, True ), # Send funds from Sprout z-addr to t-addr and Sprout z-addrs ('4n', False, False), # Send funds from Sprout z-addr to t-addr and Sapling z-addr ('4o', False, False), # Send funds from Sprout z-addr to multiple Sapling z-addrs ('4p', True, True ), # Send funds from t-addr to multiple t-addrs ('4q', True, True ), # Send funds from t-addr to multiple Sprout z-addrs ('4r', True, True ), # Send funds from t-addr to multiple Sapling z-addrs ('4s', False, False), # Send funds from t-addr to Sprout z-addr and Sapling z-addr ('4t', True, True ), # Send funds from Sapling z-addr to multiple Sapling z-addrs ('4u', False, False), # Send funds from Sapling z-addr to multiple Sprout z-addrs ('4v', True, True ), # Send funds from Sapling z-addr to multiple t-addrs ('4w', True, True ), # Send funds from Sapling z-addr to t-addr and Sapling z-addr ('4x', False, False), # Send funds from Sapling z-addr to Sapling z-addr and Sprout z-addr ('4y', True, True ), # Send funds from t-addr to Sprout z-addr using z_mergetoaddress ('4z', True, True ), # Send funds from 2 different t-addrs to Sprout z-addr using z_mergetoaddress ('4aa', False, False), # Send funds from the same 2 t-addrs to Sprout z-addr using z_mergetoaddress ('4bb', True, True ), # Send funds from 2 different t-addrs to Sapling z-addr using z_mergetoaddress ('4cc', True, True ), # Send funds from t-addr to Sapling z-addr using z_mergetoaddress ('4dd', True, True ), # Send funds from t-addr and Sprout z-addr to Sprout z-addr using z_mergetoaddress ('4ee', True, True ), # Send funds from t-addr and Sapling z-addr to Sapling z-addr using z_mergetoaddress ('4ff', True, True ), # Send funds from Sprout z-addr and Sprout z-addr to Sprout z-addr using z_mergetoaddress ('4gg', True, True ), # Send funds from Sapling z-addr and Sapling z-addr to Sapling z-addr using z_mergetoaddress # Wallet ('5a', True, True), # After generating multiple z-addrs, run z_listaddresses ('5b', True, True), # Run z_validateaddress with a Sprout z-addr ('5c', True, True), # Run z_validateaddress with a Sapling z-addr ('5d', True, True), # After a transaction, run z_listunspent ('5e', True, True), # After a transaction, run z_listreceivedbyaddress ('5f', True, True), # After a transaction, run z_getbalance ('5g', True, True), # After a transaction, run z_gettotalbalance ('5h', True, True), # Run z_exportkey using a Sprout z-addr ('5i', True, True), # Run z_importkey using the zkey from a Sprout z-addr ('5j', True, True), # Run z_exportkey using a Sapling z-addr ('5k', True, True), # Run z_importkey using the zkey from a Sapling z-addr ('5l', True, True), # Run z_exportwallet ('5m', True, True), # Run z_importwallet ('5n', True, True), # Run z_shieldcoinbase ('5o', True, True), # Run getwalletinfo # Network ('6a', True, True), # Run getpeerinfo ('6b', True, True), # Run getnetworkinfo ('6c', True, False), # Run getdeprecationinfo ('6d', True, True), # Run getconnectioncount ('6e', True, True), # Run getaddednodeinfo # Mining ('7a', True, True), # Run getblocksubsidy ('7b', True, True), # Run getblocktemplate ('7c', True, True), # Run getmininginfo ('7d', True, True), # Run getnetworkhashps ('7e', True, True), # Run getnetworksolps ] TIME_STARTED = datetime.datetime.now() # # Test helpers # def run_cmd(results, case, zcash, name, args=[]): print('----- %s -----' % (datetime.datetime.now() - TIME_STARTED)) print('%s $ zcash-cli %s %s' % ( case.ljust(3), name, ' '.join([str(arg) for arg in args], ))) try: res = zcash.__getattr__(name)(*args) print(res) print() if results is not None and len(case) > 0: results[case] = True return res except RpcException as e: print('ERROR: %s' % str(e)) if results is not None and len(case) > 0: results[case] = False return None def wait_for_balance(zcash, zaddr, expected=None): print('Waiting for funds to %s...' % zaddr) unconfirmed_balance = Decimal(zcash.z_getbalance(zaddr, 0)).quantize(Decimal('1.00000000')) print('Expecting: %s; Unconfirmed Balance: %s' % (expected, unconfirmed_balance)) if expected is not None and unconfirmed_balance != expected: print('WARNING: Unconfirmed balance does not match expected balance') # Default timeout is 15 minutes ttl = 900 while True: balance = Decimal(zcash.z_getbalance(zaddr)).quantize(Decimal('1.00000000')) if (expected is not None and balance == unconfirmed_balance) or (expected is None and balance > 0): print('Received %s' % balance) return balance time.sleep(1) ttl -= 1 if ttl == 0: if zcash.automated: # Reset timeout ttl = 300 else: # Ask user if they want to keep waiting print() print('Balance: %s Expected: %s' % (balance, expected)) ret = input('Do you wish to continue waiting? (Y/n) ') if ret.lower() == 'n': print('Address contained %s at timeout' % balance) return balance else: # Wait another 5 minutes before asking again ttl = 300 def wait_and_check_balance(results, case, zcash, addr, expected): balance = wait_for_balance(zcash, addr, expected) if balance != expected and results is not None and len(case) > 0: results[case] = False return balance def wait_for_txid_operation(zcash, opid, timeout=300): print('Waiting for async operation %s' % opid) result = None for _ in iter(range(timeout)): results = zcash.z_getoperationresult([opid]) if len(results) > 0: result = results[0] break time.sleep(1) status = result['status'] if status == 'failed': print('Operation failed') print(result['error']['message']) return None elif status == 'success': txid = result['result']['txid'] print('txid: %s' % txid) return txid def async_txid_cmd(results, case, zcash, name, args=[]): opid = run_cmd(results, case, zcash, name, args) # Some async commands return a dictionary containing the opid if isinstance(opid, dict): opid = opid['opid'] if opid is None: if results is not None and len(case) > 0: results[case] = False return None txid = wait_for_txid_operation(zcash, opid) if txid is None: if results is not None and len(case) > 0: results[case] = False return txid def z_sendmany(results, case, zcash, from_addr, recipients): return async_txid_cmd(results, case, zcash, 'z_sendmany', [ from_addr, [{ 'address': to_addr, 'amount': amount, } for (to_addr, amount) in recipients] ]) def check_z_sendmany(results, case, zcash, from_addr, recipients): txid = z_sendmany(results, case, zcash, from_addr, recipients) if txid is None: return [Decimal('0')] return [wait_and_check_balance(results, case, zcash, to_addr, amount) for (to_addr, amount) in recipients] def check_z_sendmany_parallel(results, zcash, runs): # First attempt to create all the transactions txids = [(run, z_sendmany(results, run[0], zcash, run[1], run[2])) for run in runs] # Then wait for balance updates caused by successful transactions return [ wait_and_check_balance(results, run[0], zcash, to_addr, amount) if txid is not None else Decimal('0') for (run, txid) in txids for (to_addr, amount) in run[2]] def z_mergetoaddress(results, case, zcash, from_addrs, to_addr): return async_txid_cmd(results, case, zcash, 'z_mergetoaddress', [from_addrs, to_addr]) def check_z_mergetoaddress(results, case, zcash, from_addrs, to_addr, amount): txid = z_mergetoaddress(results, case, zcash, from_addrs, to_addr) if txid is None: return Decimal('0') return wait_and_check_balance(results, case, zcash, to_addr, amount) def check_z_mergetoaddress_parallel(results, zcash, runs): # First attempt to create all the transactions txids = [(run, z_mergetoaddress(results, run[0], zcash, run[1], run[2])) for run in runs] # Then wait for balance updates caused by successful transactions return [ wait_and_check_balance(results, run[0], zcash, run[2], run[3]) if txid is not None else Decimal('0') for (run, txid) in txids] def tap_zfaucet(addr): with requests.Session() as session: # Get token to request TAZ from faucet with a given zcash address response = session.get(URL_FAUCET_TAP) if response.status_code != 200: print("Error establishing session at:", URL_FAUCET_TAP) os.sys.exit(1) csrftoken = response.cookies['csrftoken'] # Request TAZ from the faucet data_params = dict(csrfmiddlewaretoken=csrftoken, address=addr) response2 = session.post(URL_FAUCET_TAP, data=data_params, headers=dict(Referer=URL_FAUCET_TAP)) if response2.status_code != 200: print("Error tapping faucet at:", URL_FAUCET_TAP) os.sys.exit(1) def get_zfaucet_addrs(): with requests.Session() as session: response = session.get(URL_FAUCET_DONATION) if response.status_code != 200: print("Error establishing session at:", URL_FAUCET_DONATION) os.sys.exit(1) data = response.json() return data def get_zfaucet_taddr(): return get_zfaucet_addrs()["t_address"] def get_zfaucet_zsapaddr(): # At the time of writing this, it appears these(keys) are backwards return get_zfaucet_addrs()["z_address_legacy"] def get_zfaucet_zsproutaddr(): # At the time of writing this, it appears these(keys) are backwards return get_zfaucet_addrs()["z_address_sapling"] # # Test runners # def simple_commands(zcash): results = {} run_cmd(results, '2a', zcash, 'getinfo'), run_cmd(results, '2b', zcash, 'help'), run_cmd(results, '5o', zcash, 'getwalletinfo'), run_cmd(results, '6a', zcash, 'getpeerinfo'), run_cmd(results, '6b', zcash, 'getnetworkinfo'), run_cmd(results, '6c', zcash, 'getdeprecationinfo'), run_cmd(results, '6d', zcash, 'getconnectioncount'), run_cmd(results, '6e', zcash, 'getaddednodeinfo', [False]), run_cmd(results, '7a', zcash, 'getblocksubsidy'), run_cmd(results, '7c', zcash, 'getmininginfo'), run_cmd(results, '7d', zcash, 'getnetworkhashps'), run_cmd(results, '7e', zcash, 'getnetworksolps'), return results def transaction_chain(zcash): results = {} # Generate the various addresses we will use sprout_zaddr_1 = run_cmd(results, '3a', zcash, 'z_getnewaddress', ['sprout']) sprout_zaddr_2 = run_cmd(results, '3b', zcash, 'z_getnewaddress', ['sprout']) sprout_zaddr_3 = run_cmd(results, '3b', zcash, 'z_getnewaddress', ['sprout']) taddr_1 = run_cmd(results, '3c', zcash, 'getnewaddress') taddr_2 = run_cmd(results, '3d', zcash, 'getnewaddress') taddr_3 = run_cmd(results, '3d', zcash, 'getnewaddress') taddr_4 = run_cmd(results, '3d', zcash, 'getnewaddress') taddr_5 = run_cmd(results, '3d', zcash, 'getnewaddress') sapling_zaddr_1 = run_cmd(results, '3e', zcash, 'z_getnewaddress', ['sapling']) sapling_zaddr_2 = run_cmd(results, '3f', zcash, 'z_getnewaddress', ['sapling']) sapling_zaddr_3 = run_cmd(results, '3f', zcash, 'z_getnewaddress', ['sapling']) # Check that the zaddrs are all listed zaddrs = run_cmd(results, '5a', zcash, 'z_listaddresses') if (sprout_zaddr_1 not in zaddrs or sprout_zaddr_2 not in zaddrs or sapling_zaddr_1 not in zaddrs or sapling_zaddr_2 not in zaddrs): results['5a'] = False # Validate the addresses ret = run_cmd(results, '5b', zcash, 'z_validateaddress', [sprout_zaddr_1]) if not ret['isvalid'] or ret['type'] != 'sprout': results['5b'] = False ret = run_cmd(results, '5c', zcash, 'z_validateaddress', [sapling_zaddr_1]) if not ret['isvalid'] or ret['type'] != 'sapling': results['5c'] = False # Set up beginning and end of the chain print('#') print('# Initialising transaction chain') print('#') print() if zcash.use_faucet: print('Tapping the testnet faucet for testing funds...') chain_end = get_zfaucet_taddr() tap_zfaucet(sprout_zaddr_1) print('Done! Leftover funds will be sent back to the faucet.') else: chain_end = input('Type or paste transparent address where leftover funds should be sent: ') if not zcash.validateaddress(chain_end)['isvalid']: print('Invalid transparent address') return results print() print('Please send at least 0.01 ZEC/TAZ to the following address:') print(sprout_zaddr_1) print() input('Press Enter once the funds have been sent.') print() # Wait to receive starting balance sprout_balance = wait_for_balance(zcash, sprout_zaddr_1) starting_balance = sprout_balance # # Start the transaction chain! # print() print('#') print('# Starting transaction chain') print('#') print() try: # # First, split the funds across all three pools # # Sprout -> taddr taddr_balance = check_z_sendmany( results, '4c', zcash, sprout_zaddr_1, [(taddr_1, (starting_balance / Decimal('10')) * Decimal('6'))])[0] sprout_balance -= taddr_balance + DEFAULT_FEE balance = Decimal(run_cmd(results, '5f', zcash, 'z_getbalance', [sprout_zaddr_1])).quantize(Decimal('1.00000000')) if balance != sprout_balance: results['5f'] = False # taddr -> Sapling # Send it all here because z_sendmany pick a new t-addr for change sapling_balance = check_z_sendmany( results, '4f', zcash, taddr_1, [(sapling_zaddr_1, taddr_balance - DEFAULT_FEE)])[0] taddr_balance = Decimal('0') # Sapling -> taddr taddr_balance = check_z_sendmany( results, '4i', zcash, sapling_zaddr_1, [(taddr_1, (starting_balance / Decimal('10')) * Decimal('3'))])[0] sapling_balance -= taddr_balance + DEFAULT_FEE # # Intra-pool tests # # Sprout -> same Sprout # Sapling -> same Sapling (sprout_balance, sapling_balance) = check_z_sendmany_parallel(results, zcash, [ ('4a', sprout_zaddr_1, [(sprout_zaddr_1, sprout_balance - DEFAULT_FEE)]), ('4g', sapling_zaddr_1, [(sapling_zaddr_1, sapling_balance - DEFAULT_FEE)]), ]) # Sprout -> different Sprout # taddr -> different taddr # Sapling -> different Sapling (sprout_balance, taddr_balance, sapling_balance) = check_z_sendmany_parallel(results, zcash, [ ('4b', sprout_zaddr_1, [(sprout_zaddr_2, sprout_balance - DEFAULT_FEE)]), ('4e', taddr_1, [(taddr_2, taddr_balance - DEFAULT_FEE)]), ('4h', sapling_zaddr_1, [(sapling_zaddr_2, sapling_balance - DEFAULT_FEE)]), ]) # Sprout -> multiple Sprout # taddr -> multiple taddr # Sapling -> multiple Sapling check_z_sendmany_parallel(results, zcash, [ ('4k', sprout_zaddr_2, [ (sprout_zaddr_1, starting_balance / Decimal('10')), (sprout_zaddr_3, starting_balance / Decimal('10')), ]), ('4p', taddr_2, [ (taddr_1, starting_balance / Decimal('10')), (taddr_3, taddr_balance - (starting_balance / Decimal('10')) - DEFAULT_FEE), ]), ('4t', sapling_zaddr_2, [ (sapling_zaddr_1, starting_balance / Decimal('10')), (sapling_zaddr_3, starting_balance / Decimal('10')), ]), ]) sprout_balance -= DEFAULT_FEE taddr_balance -= DEFAULT_FEE sapling_balance -= DEFAULT_FEE # multiple Sprout -> Sprout # multiple Sapling -> Sapling # multiple taddr -> taddr check_z_mergetoaddress_parallel(results, zcash, [ ('4ff', [sprout_zaddr_1, sprout_zaddr_3], sprout_zaddr_2, sprout_balance - DEFAULT_FEE), ('4gg', [sapling_zaddr_1, sapling_zaddr_3], sapling_zaddr_2, sapling_balance - DEFAULT_FEE), ('', [taddr_1, taddr_3], taddr_2, taddr_balance - DEFAULT_FEE), ]) sprout_balance -= DEFAULT_FEE sapling_balance -= DEFAULT_FEE taddr_balance -= DEFAULT_FEE # # Now test a bunch of failing cases # # Sprout -> Sapling txid = z_sendmany(results, '4j', zcash, sprout_zaddr_2, [(sapling_zaddr_1, sprout_balance - DEFAULT_FEE)]) if txid is not None: print('Should have failed') return results # Sprout -> taddr and Sapling txid = z_sendmany(results, '4n', zcash, sprout_zaddr_2, [ (taddr_2, starting_balance / Decimal('10')), (sapling_zaddr_1, starting_balance / Decimal('10')), ]) if txid is not None: print('Should have failed') return results # Sprout -> multiple Sapling txid = z_sendmany(results, '4o', zcash, sprout_zaddr_2, [ (sapling_zaddr_1, starting_balance / Decimal('10')), (sapling_zaddr_2, starting_balance / Decimal('10')), ]) if txid is not None: print('Should have failed') return results # taddr -> Sprout and Sapling txid = z_sendmany(results, '4s', zcash, taddr_2, [ (sprout_zaddr_1, starting_balance / Decimal('10')), (sapling_zaddr_1, starting_balance / Decimal('10')), ]) if txid is not None: print('Should have failed') return results # Sapling -> multiple Sprout txid = z_sendmany(results, '4u', zcash, sapling_zaddr_2, [ (sprout_zaddr_1, starting_balance / Decimal('10')), (sprout_zaddr_2, starting_balance / Decimal('10')), ]) if txid is not None: print('Should have failed') return results # Sapling -> Sapling and Sprout txid = z_sendmany(results, '4x', zcash, sapling_zaddr_2, [ (sapling_zaddr_1, starting_balance / Decimal('10')), (sprout_zaddr_1, starting_balance / Decimal('10')), ]) if txid is not None: print('Should have failed') return results # multiple same taddr -> Sprout txid = z_mergetoaddress(results, '4aa', zcash, [taddr_2, taddr_2], sprout_zaddr_2) if txid is not None: print('Should have failed') return results # # Inter-pool tests # # Sprout -> taddr and Sprout # Sapling -> taddr and Sapling check_z_sendmany_parallel(results, zcash, [ ('4m', sprout_zaddr_2, [ (taddr_1, starting_balance / Decimal('10')), (sprout_zaddr_1, starting_balance / Decimal('10')), ]), ('4w', sapling_zaddr_2, [ (taddr_3, starting_balance / Decimal('10')), (sapling_zaddr_1, starting_balance / Decimal('10')), ]), ]) sprout_balance -= (starting_balance / Decimal('10')) + DEFAULT_FEE sapling_balance -= (starting_balance / Decimal('10')) + DEFAULT_FEE taddr_balance += (starting_balance / Decimal('10')) * Decimal('2') # taddr and Sprout -> Sprout # taddr and Sapling -> Sapling check_z_mergetoaddress_parallel(results, zcash, [ ('4dd', [taddr_1, sprout_zaddr_1], sprout_zaddr_2, sprout_balance + (starting_balance / Decimal('10')) - DEFAULT_FEE), ('4ee', [taddr_3, sapling_zaddr_1], sapling_zaddr_2, sapling_balance + (starting_balance / Decimal('10')) - DEFAULT_FEE), ]) sprout_balance += (starting_balance / Decimal('10')) - DEFAULT_FEE sapling_balance += (starting_balance / Decimal('10')) - DEFAULT_FEE taddr_balance -= (starting_balance / Decimal('10')) * Decimal('2') # Sprout -> multiple taddr # Sapling -> multiple taddr check_z_sendmany_parallel(results, zcash, [ ('4l', sprout_zaddr_2, [ (taddr_1, (starting_balance / Decimal('10'))), (taddr_3, (starting_balance / Decimal('10'))), ]), ('4v', sapling_zaddr_2, [ (taddr_4, (starting_balance / Decimal('10'))), (taddr_5, (starting_balance / Decimal('10'))), ]), ]) sprout_balance -= ((starting_balance / Decimal('10')) * Decimal('2')) + DEFAULT_FEE sapling_balance -= ((starting_balance / Decimal('10')) * Decimal('2')) + DEFAULT_FEE taddr_balance += (starting_balance / Decimal('10')) * Decimal('4') # multiple taddr -> Sprout # multiple taddr -> Sapling check_z_mergetoaddress_parallel(results, zcash, [ ('4z', [taddr_1, taddr_3], sprout_zaddr_2, sprout_balance + ((starting_balance / Decimal('10')) * Decimal('2')) - DEFAULT_FEE), ('4bb', [taddr_4, taddr_5], sapling_zaddr_2, sapling_balance + ((starting_balance / Decimal('10')) * Decimal('2')) - DEFAULT_FEE), ]) sprout_balance += ((starting_balance / Decimal('10')) * Decimal('2')) - DEFAULT_FEE sapling_balance += ((starting_balance / Decimal('10')) * Decimal('2')) - DEFAULT_FEE taddr_balance -= (starting_balance / Decimal('10')) * Decimal('4') # taddr -> Sprout check_z_sendmany_parallel(results, zcash, [ ('4d', taddr_2, [(sprout_zaddr_3, taddr_balance - DEFAULT_FEE)]), ]) sprout_balance += taddr_balance - DEFAULT_FEE taddr_balance = Decimal('0') # multiple Sprout -> taddr # multiple Sapling -> taddr check_z_mergetoaddress_parallel(None, zcash, [ ('', [sprout_zaddr_1, sprout_zaddr_2, sprout_zaddr_3], taddr_1, sprout_balance - DEFAULT_FEE), ('', [sapling_zaddr_1, sapling_zaddr_2, sapling_zaddr_3], taddr_2, sapling_balance - DEFAULT_FEE), ]) taddr_balance = sprout_balance + sapling_balance - (2 * DEFAULT_FEE) sprout_balance = Decimal('0') sapling_balance = Decimal('0') # taddr -> multiple Sprout # taddr -> multiple Sapling taddr_1_balance = Decimal(zcash.z_getbalance(taddr_1)).quantize(Decimal('1.00000000')) taddr_2_balance = Decimal(zcash.z_getbalance(taddr_2)).quantize(Decimal('1.00000000')) check_z_sendmany_parallel(results, zcash, [ ('4q', taddr_1, [ (sprout_zaddr_1, (starting_balance / Decimal('10'))), (sprout_zaddr_2, taddr_1_balance - (starting_balance / Decimal('10')) - DEFAULT_FEE), ]), ('4r', taddr_2, [ (sapling_zaddr_1, (starting_balance / Decimal('10'))), (sapling_zaddr_2, taddr_2_balance - (starting_balance / Decimal('10')) - DEFAULT_FEE), ]), ]) sprout_balance = taddr_1_balance - DEFAULT_FEE sapling_balance = taddr_2_balance - DEFAULT_FEE taddr_balance = Decimal('0') # multiple Sprout -> taddr # multiple Sapling -> taddr check_z_mergetoaddress_parallel(None, zcash, [ ('', [sprout_zaddr_1, sprout_zaddr_2], taddr_1, sprout_balance - DEFAULT_FEE), ('', [sapling_zaddr_1, sapling_zaddr_2], taddr_2, sapling_balance - DEFAULT_FEE), ]) taddr_balance = sprout_balance + sapling_balance - (Decimal('2') * DEFAULT_FEE) sprout_balance = Decimal('0') sapling_balance = Decimal('0') # z_mergetoaddress taddr -> Sprout # z_mergetoaddress taddr -> Sapling taddr_1_balance = Decimal(zcash.z_getbalance(taddr_1)).quantize(Decimal('1.00000000')) taddr_2_balance = Decimal(zcash.z_getbalance(taddr_2)).quantize(Decimal('1.00000000')) check_z_mergetoaddress_parallel(results, zcash, [ ('4y', [taddr_1], sprout_zaddr_1, taddr_1_balance - DEFAULT_FEE), ('4cc', [taddr_2], sapling_zaddr_1, taddr_2_balance - DEFAULT_FEE), ]) sprout_balance = taddr_1_balance - DEFAULT_FEE sapling_balance = taddr_2_balance - DEFAULT_FEE taddr_balance = Decimal('0') except Exception as e: print('Error: %s' % e) traceback.print_exc() finally: # # End the chain by returning the remaining funds # print() print('#') print('# Finishing transaction chain') print('#') all_addrs = [ sprout_zaddr_1, sprout_zaddr_2, sprout_zaddr_3, taddr_1, taddr_2, taddr_3, taddr_4, taddr_5, sapling_zaddr_1, sapling_zaddr_2, sapling_zaddr_3, ] print() print('Waiting for all transactions to be mined') for addr in all_addrs: balance = Decimal(zcash.z_getbalance(addr, 0)).quantize(Decimal('1.00000000')) if balance > 0: wait_for_balance(zcash, addr, balance) print() print('Returning remaining balance minus fees') for addr in all_addrs: balance = Decimal(zcash.z_getbalance(addr)).quantize(Decimal('1.00000000')) if balance > 0: z_sendmany(None, '', zcash, addr, [(chain_end, balance - DEFAULT_FEE)]) return results # # Test stages # STAGES = [ 'simple-commands', 'transaction-chain' ] STAGE_COMMANDS = { 'simple-commands': simple_commands, 'transaction-chain': transaction_chain, } def run_stage(stage, zcash): print('Running stage %s' % stage) print('=' * (len(stage) + 14)) print() cmd = STAGE_COMMANDS[stage] if cmd is not None: ret = cmd(zcash) else: print('WARNING: stage not yet implemented, skipping') ret = {} print() print('-' * (len(stage) + 15)) print('Finished stage %s' % stage) print() return ret # # Zcash wrapper # class ZcashNode(object): def __init__(self, args, zcashd=None, zcash_cli=None): if zcashd is None: zcashd = os.getenv('ZCASHD', 'zcashd') if zcash_cli is None: zcash_cli = os.getenv('ZCASHCLI', 'zcash-cli') self.__datadir = args.datadir self.__wallet = args.wallet self.__testnet = not args.mainnet self.__zcashd = zcashd self.__zcash_cli = zcash_cli self.__process = None self.__proxy = None self.automated = args.automate self.use_faucet = args.faucet def start(self, extra_args=None, timewait=None): if self.__proxy is not None: raise RuntimeError('Already started') rpcuser = 'st' rpcpassword = 'st' args = [ self.__zcashd, '-datadir=%s' % self.__datadir, '-wallet=%s' % self.__wallet, '-rpcuser=%s' % rpcuser, '-rpcpassword=%s' % rpcpassword, '-showmetrics=0', '-experimentalfeatures', '-zmergetoaddress', ] if self.__testnet: args.append('-testnet=1') if extra_args is not None: args.extend(extra_args) self.__process = subprocess.Popen(args) cli_args = [ self.__zcash_cli, '-datadir=%s' % self.__datadir, '-rpcuser=%s' % rpcuser, '-rpcpassword=%s' % rpcpassword, '-rpcwait', ] if self.__testnet: cli_args.append('-testnet=1') cli_args.append('getblockcount') devnull = open('/dev/null', 'w+') if os.getenv('PYTHON_DEBUG', ''): print('start_node: zcashd started, calling zcash-cli -rpcwait getblockcount') subprocess.check_call(cli_args, stdout=devnull) if os.getenv('PYTHON_DEBUG', ''): print('start_node: calling zcash-cli -rpcwait getblockcount returned') devnull.close() rpcuserpass = '%s:%s' % (rpcuser, rpcpassword) rpchost = '127.0.0.1' rpcport = 18232 if self.__testnet else 8232 url = 'http://%s@%s:%d' % (rpcuserpass, rpchost, rpcport) if timewait is not None: self.__proxy = Proxy(url, timeout=timewait) else: self.__proxy = Proxy(url) def stop(self): if self.__proxy is None: raise RuntimeError('Not running') self.__proxy.stop() self.__process.wait() self.__proxy = None self.__process = None def __getattr__(self, name): if self.__proxy is None: raise RuntimeError('Not running') return self.__proxy.__getattr__(name) # # Test driver # def main(): parser = argparse.ArgumentParser() parser.add_argument('--automate', action='store_true', help='Run the smoke tests without a user present') parser.add_argument('--list-stages', dest='list', action='store_true') parser.add_argument('--mainnet', action='store_true', help='Use mainnet instead of testnet') parser.add_argument('--use-faucet', dest='faucet', action='store_true', help='Use testnet faucet as source of funds') parser.add_argument('--wallet', default='wallet.dat', help='Wallet file to use (within data directory)') parser.add_argument('datadir', help='Data directory to use for smoke testing', default=None) parser.add_argument('stage', nargs='*', default=STAGES, help='One of %s' % STAGES) args = parser.parse_args() # Check for list if args.list: for s in STAGES: print(s) sys.exit(0) # Check validity of stages for s in args.stage: if s not in STAGES: print("Invalid stage '%s' (choose from %s)" % (s, STAGES)) sys.exit(1) # Don't allow using the default wallet.dat in mainnet mode if args.mainnet and args.wallet == 'wallet.dat': print('Cannot use wallet.dat as wallet file when running mainnet tests. Keep your funds safe!') sys.exit(1) # Testnet faucet cannot be used in mainnet mode if args.mainnet and args.faucet: print('Cannot use testnet faucet when running mainnet tests.') sys.exit(1) # Enforce correctly-configured automatic mode if args.automate: if args.mainnet: print('Cannot yet automate mainnet tests.') sys.exit(1) if not args.faucet: print('--automate requires --use-faucet') sys.exit(1) # Start zcashd zcash = ZcashNode(args) print('Start time: %s' % TIME_STARTED) print('Starting zcashd...') zcash.start() print() # Run the stages results = {} for s in args.stage: results.update(run_stage(s, zcash)) # Stop zcashd print('Stopping zcashd...') zcash.stop() passed = True print() print('========================') print(' Results') print('========================') print('Case | Expected | Actual') print('========================') for test_case in SMOKE_TESTS: case = test_case[0] expected = test_case[1 if args.mainnet else 2] if case in results: actual = results[case] actual_str = '%s%s' % ( 'Passed' if actual else 'Failed', '' if expected == actual else '!!!' ) passed &= (expected == actual) else: actual_str = ' N/A' print('%s | %s | %s' % ( case.ljust(4), ' Passed ' if expected else ' Failed ', actual_str )) if not passed: print() print("!!! One or more smoke test stages failed !!!") sys.exit(1) if __name__ == '__main__': main()
[]
[]
[ "ZCASHD", "PYTHON_DEBUG", "ZCASHCLI" ]
[]
["ZCASHD", "PYTHON_DEBUG", "ZCASHCLI"]
python
3
0
pytorch_lightning/accelerators/gpu.py
# Copyright The PyTorch Lightning team. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import logging import os from typing import Any import torch import pytorch_lightning as pl from pytorch_lightning.accelerators.accelerator import Accelerator from pytorch_lightning.plugins import DataParallelPlugin from pytorch_lightning.utilities.exceptions import MisconfigurationException _log = logging.getLogger(__name__) class GPUAccelerator(Accelerator): """ Accelerator for GPU devices. """ def setup(self, trainer: 'pl.Trainer', model: 'pl.LightningModule') -> None: """ Raises: MisconfigurationException: If the selected device is not GPU. """ if "cuda" not in str(self.root_device): raise MisconfigurationException(f"Device should be GPU, got {self.root_device} instead") self.set_nvidia_flags(trainer.local_rank) torch.cuda.set_device(self.root_device) return super().setup(trainer, model) def on_train_start(self) -> None: # clear cache before training # use context because of: # https://discuss.pytorch.org/t/out-of-memory-when-i-use-torch-cuda-empty-cache/57898 with torch.cuda.device(self.root_device): torch.cuda.empty_cache() def teardown(self) -> None: self.lightning_module.cpu() # clean up memory with torch.cuda.device(self.root_device): torch.cuda.empty_cache() @staticmethod def set_nvidia_flags(local_rank: int) -> None: # set the correct cuda visible devices (using pci order) os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" all_gpu_ids = ",".join([str(x) for x in range(torch.cuda.device_count())]) devices = os.getenv("CUDA_VISIBLE_DEVICES", all_gpu_ids) _log.info(f"LOCAL_RANK: {local_rank} - CUDA_VISIBLE_DEVICES: [{devices}]") def to_device(self, batch: Any) -> Any: # no need to transfer batch to device in DP mode # TODO: Add support to allow batch transfer to device in Lightning for DP mode. if not isinstance(self.training_type_plugin, DataParallelPlugin): batch = super().to_device(batch) return batch
[]
[]
[ "CUDA_DEVICE_ORDER", "CUDA_VISIBLE_DEVICES" ]
[]
["CUDA_DEVICE_ORDER", "CUDA_VISIBLE_DEVICES"]
python
2
0
machine-learning-scripts/examples/tf2-gtsrb-cnn-simple.py
# # Traffic sign classification with CNNs # # In this notebook, we'll train a convolutional neural network (CNN, # ConvNet) to classify images of traffic signs from [The German # Traffic Sign Recognition # Benchmark](http://benchmark.ini.rub.de/?section=gtsrb&subsection=news) # using TensorFlow 2.0 / Keras. This notebook is largely based on the # blog post [Building powerful image classification models using very # little # data](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html) by François Chollet. # # **Note that using a GPU with this notebook is highly recommended.** # # First, the needed imports. import os import datetime import pathlib import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.callbacks import TensorBoard import numpy as np from PIL import Image print('Using Tensorflow version: {}, and Keras version: {}.'.format( tf.__version__, keras.__version__)) # # Data # # The training dataset consists of 5535 images of traffic signs of # varying size. There are 43 different types of traffic signs. In # addition, the validation consists of 999. if 'DATADIR' in os.environ: DATADIR = os.environ['DATADIR'] else: DATADIR = "/scratch/project_2003747/data/" datapath = os.path.join(DATADIR, "gtsrb/train-5535/") assert os.path.exists(datapath), "Data not found at "+datapath nimages = dict() (nimages['train'], nimages['validation']) = (5535, 999) # ### Parameters INPUT_IMAGE_SIZE = [75, 75, 3] BATCH_SIZE = 50 NUM_CLASSES = 43 # ### Image paths and labels def get_paths(dataset): data_root = pathlib.Path(datapath+dataset) image_paths = list(data_root.glob('*/*')) image_paths = [str(path) for path in image_paths] image_count = len(image_paths) assert image_count == nimages[dataset], \ "Found {} images, expected {}".format(image_count, nimages[dataset]) return image_paths image_paths = dict() image_paths['train'] = get_paths('train') image_paths['validation'] = get_paths('validation') label_names = sorted(item.name for item in pathlib.Path(datapath+'train').glob('*/') if item.is_dir()) label_to_index = dict((name, index) for index, name in enumerate(label_names)) def get_labels(dataset): return [label_to_index[pathlib.Path(path).parent.name] for path in image_paths[dataset]] image_labels = dict() image_labels['train'] = get_labels('train') image_labels['validation'] = get_labels('validation') # ### Data augmentation # # We need to resize all training and validation images to a fixed # size. # # Then, to make the most of our limited number of training examples, # we'll apply random transformations (crop and horizontal flip) to # them each time we are looping over them. This way, we "augment" our # training dataset to contain more data. There are various # transformations readily available in TensorFlow, see # [tf.image](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/image) # for more information. def _load_image(path, label): image = Image.open(path.numpy()) return np.array(image), label def load_image(path, label): return tf.py_function(_load_image, (path, label), (tf.float32, tf.int32)) def preprocess_image(image, augment): image.set_shape([None, None, None]) if augment: image = tf.image.resize(image, [80, 80]) image = tf.image.random_crop(image, INPUT_IMAGE_SIZE) #image = tf.image.random_flip_left_right(image) image = tf.image.random_brightness(image, 0.1) image = tf.clip_by_value(image, 0.0, 255.0) else: image = tf.image.resize(image, INPUT_IMAGE_SIZE[:2]) image /= 255.0 # normalize to [0,1] range image.set_shape(INPUT_IMAGE_SIZE) return image def process_and_augment_image(image, label): label.set_shape([]) return preprocess_image(image, True), label def process_and_not_augment_image(image, label): label.set_shape([]) return preprocess_image(image, False), label # ### TF Datasets train_dataset = tf.data.Dataset.from_tensor_slices( (image_paths['train'], image_labels['train'])) train_dataset = train_dataset.map(load_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) train_dataset = train_dataset.map(process_and_augment_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) train_dataset = train_dataset.shuffle(500).batch(BATCH_SIZE, drop_remainder=True) validation_dataset = tf.data.Dataset.from_tensor_slices( (image_paths['validation'], image_labels['validation'])) validation_dataset = validation_dataset.map(load_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) validation_dataset = validation_dataset.map(process_and_not_augment_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) validation_dataset = validation_dataset.batch(BATCH_SIZE, drop_remainder=True) # ## Train a small CNN from scratch # # Similarly as with MNIST digits, we can start from scratch and train # a CNN for the classification task. # # ### Initialization inputs = keras.Input(shape=INPUT_IMAGE_SIZE) x = layers.Conv2D(32, (3, 3), activation='relu')(inputs) x = layers.MaxPooling2D(pool_size=(2, 2))(x) x = layers.Conv2D(32, (3, 3), activation='relu')(x) x = layers.MaxPooling2D(pool_size=(2, 2))(x) x = layers.Conv2D(64, (3, 3), activation='relu')(x) x = layers.MaxPooling2D(pool_size=(2, 2))(x) x = layers.Flatten()(x) x = layers.Dense(128, activation='relu')(x) x = layers.Dropout(0.5)(x) outputs = layers.Dense(43, activation='softmax')(x) model = keras.Model(inputs=inputs, outputs=outputs, name="gtsrb-cnn-simple") model.compile(loss='sparse_categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) print(model.summary()) # ### Learning # We'll use TensorBoard to visualize our progress during training. logdir = os.path.join(os.getcwd(), "logs", "gtsrb-cnn-simple-" + datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) print('TensorBoard log directory:', logdir) os.makedirs(logdir) callbacks = [TensorBoard(log_dir=logdir)] epochs = 20 history = model.fit(train_dataset, epochs=epochs, validation_data=validation_dataset, callbacks=callbacks, verbose=2) fname = "gtsrb-cnn-simple.h5" print('Saving model to', fname) model.save(fname)
[]
[]
[ "DATADIR" ]
[]
["DATADIR"]
python
1
0
inference_speed.py
import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' import tensorflow as tf from dataset.dataloader import load_tfds from time import time import argparse from nets.simple_basline import SimpleBaseline from nets.evopose2d import EvoPose from nets.hrnet import HRNet from utils import detect_hardware def speed_test(strategy, cfg, split='val', n=1000): with strategy.scope(): if cfg.MODEL.TYPE == 'simple_baseline': model = SimpleBaseline(cfg) elif cfg.MODEL.TYPE == 'hrnet': model = HRNet(cfg) elif cfg.MODEL.TYPE == 'evopose': model = EvoPose(cfg) cfg.DATASET.OUTPUT_SHAPE = model.output_shape[1:] ds = load_tfds(cfg, split, det=cfg.VAL.DET, predict_kp=True, drop_remainder=cfg.VAL.DROP_REMAINDER) ds = strategy.experimental_distribute_dataset(ds) @tf.function def predict(imgs, flip=False): if flip: imgs = imgs[:, :, ::-1, :] return model(imgs, training=False) for count, batch in enumerate(ds): if count == 1: # skip first pass ti = time() _, imgs, _, _, scores = batch hms = strategy.run(predict, args=(imgs,)).numpy() if cfg.VAL.FLIP: flip_hms = strategy.run(predict, args=(imgs, True,)).numpy() flip_hms = flip_hms[:, :, ::-1, :] tmp = flip_hms.copy() for i in range(len(cfg.DATASET.KP_FLIP)): flip_hms[:, :, :, i] = tmp[:, :, :, cfg.DATASET.KP_FLIP[i]] # shift to align features flip_hms[:, :, 1:, :] = flip_hms[:, :, 0:-1, :].copy() hms = (hms + flip_hms) / 2. if count == n: break print('FPS: {:.5f}'.format((n * cfg.VAL.BATCH_SIZE) / (time() - ti))) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--cpu', action='store_true') parser.add_argument('--gpu', action='store_true') parser.add_argument('--tpu', default='') parser.add_argument('-c', '--cfg', required=True) # yaml parser.add_argument('-bs', '--batch-size', type=int, default=1) parser.add_argument('-n', type=int, default=1000) args = parser.parse_args() from dataset.coco import cn as cfg cfg.merge_from_file('configs/' + args.cfg) cfg.MODEL.NAME = args.cfg.split('.')[0] cfg.VAL.BATCH_SIZE = args.batch_size if args.cpu: strategy = tf.distribute.OneDeviceStrategy('/CPU:0') elif args.gpu: strategy = tf.distribute.OneDeviceStrategy('/GPU:0') else: tpu, strategy = detect_hardware(args.tpu) tf.config.optimizer.set_experimental_options({'disable_meta_optimizer': True}) speed_test(strategy, cfg, split='val', n=args.n)
[]
[]
[ "TF_CPP_MIN_LOG_LEVEL" ]
[]
["TF_CPP_MIN_LOG_LEVEL"]
python
1
0
analyze.py
# BirdWeather edits by @timsterc # Other edits by @CaiusX and @mcguirepr89 import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' os.environ['CUDA_VISIBLE_DEVICES'] = '' try: import tflite_runtime.interpreter as tflite except: from tensorflow import lite as tflite import argparse import operator import librosa import numpy as np import math import time from decimal import Decimal import json ############################################################################### import requests import mysql.connector ############################################################################### import datetime import pytz from tzlocal import get_localzone from pathlib import Path def loadModel(): global INPUT_LAYER_INDEX global OUTPUT_LAYER_INDEX global MDATA_INPUT_INDEX global CLASSES print('LOADING TF LITE MODEL...', end=' ') # Load TFLite model and allocate tensors. interpreter = tflite.Interpreter(model_path='model/BirdNET_6K_GLOBAL_MODEL.tflite',num_threads=2) interpreter.allocate_tensors() # Get input and output tensors. input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() # Get input tensor index INPUT_LAYER_INDEX = input_details[0]['index'] MDATA_INPUT_INDEX = input_details[1]['index'] OUTPUT_LAYER_INDEX = output_details[0]['index'] # Load labels CLASSES = [] with open('model/labels.txt', 'r') as lfile: for line in lfile.readlines(): CLASSES.append(line.replace('\n', '')) print('DONE!') return interpreter def loadCustomSpeciesList(path): slist = [] if os.path.isfile(path): with open(path, 'r') as csfile: for line in csfile.readlines(): slist.append(line.replace('\r', '').replace('\n', '')) return slist def splitSignal(sig, rate, overlap, seconds=3.0, minlen=1.5): # Split signal with overlap sig_splits = [] for i in range(0, len(sig), int((seconds - overlap) * rate)): split = sig[i:i + int(seconds * rate)] # End of signal? if len(split) < int(minlen * rate): break # Signal chunk too short? Fill with zeros. if len(split) < int(rate * seconds): temp = np.zeros((int(rate * seconds))) temp[:len(split)] = split split = temp sig_splits.append(split) return sig_splits def readAudioData(path, overlap, sample_rate=48000): print('READING AUDIO DATA...', end=' ', flush=True) # Open file with librosa (uses ffmpeg or libav) sig, rate = librosa.load(path, sr=sample_rate, mono=True, res_type='kaiser_fast') # Split audio into 3-second chunks chunks = splitSignal(sig, rate, overlap) print('DONE! READ', str(len(chunks)), 'CHUNKS.') return chunks def convertMetadata(m): # Convert week to cosine if m[2] >= 1 and m[2] <= 48: m[2] = math.cos(math.radians(m[2] * 7.5)) + 1 else: m[2] = -1 # Add binary mask mask = np.ones((3,)) if m[0] == -1 or m[1] == -1: mask = np.zeros((3,)) if m[2] == -1: mask[2] = 0.0 return np.concatenate([m, mask]) def custom_sigmoid(x, sensitivity=1.0): return 1 / (1.0 + np.exp(-sensitivity * x)) def predict(sample, interpreter, sensitivity): # Make a prediction interpreter.set_tensor(INPUT_LAYER_INDEX, np.array(sample[0], dtype='float32')) interpreter.set_tensor(MDATA_INPUT_INDEX, np.array(sample[1], dtype='float32')) interpreter.invoke() prediction = interpreter.get_tensor(OUTPUT_LAYER_INDEX)[0] # Apply custom sigmoid p_sigmoid = custom_sigmoid(prediction, sensitivity) # Get label and scores for pooled predictions p_labels = dict(zip(CLASSES, p_sigmoid)) # Sort by score p_sorted = sorted(p_labels.items(), key=operator.itemgetter(1), reverse=True) # Remove species that are on blacklist for i in range(min(10, len(p_sorted))): if p_sorted[i][0] in ['Human_Human', 'Non-bird_Non-bird', 'Noise_Noise']: p_sorted[i] = (p_sorted[i][0], 0.0) # Only return first the top ten results return p_sorted[:10] def analyzeAudioData(chunks, lat, lon, week, sensitivity, overlap, interpreter): detections = {} start = time.time() print('ANALYZING AUDIO...', end=' ', flush=True) # Convert and prepare metadata mdata = convertMetadata(np.array([lat, lon, week])) mdata = np.expand_dims(mdata, 0) # Parse every chunk pred_start = 0.0 for c in chunks: # Prepare as input signal sig = np.expand_dims(c, 0) # Make prediction p = predict([sig, mdata], interpreter, sensitivity) # Save result and timestamp pred_end = pred_start + 3.0 detections[str(pred_start) + ';' + str(pred_end)] = p pred_start = pred_end - overlap print('DONE! Time', int((time.time() - start) * 10) / 10.0, 'SECONDS') return detections def writeResultsToFile(detections, min_conf, path): print('WRITING RESULTS TO', path, '...', end=' ') rcnt = 0 with open(path, 'w') as rfile: rfile.write('Start (s);End (s);Scientific name;Common name;Confidence\n') for d in detections: for entry in detections[d]: if entry[1] >= min_conf and (entry[0] in WHITE_LIST or len(WHITE_LIST) == 0): rfile.write(d + ';' + entry[0].replace('_', ';') + ';' + str(entry[1]) + '\n') rcnt += 1 print('DONE! WROTE', rcnt, 'RESULTS.') def main(): global WHITE_LIST # Parse passed arguments parser = argparse.ArgumentParser() parser.add_argument('--i', help='Path to input file.') parser.add_argument('--o', default='result.csv', help='Path to output file. Defaults to result.csv.') parser.add_argument('--lat', type=float, default=-1, help='Recording location latitude. Set -1 to ignore.') parser.add_argument('--lon', type=float, default=-1, help='Recording location longitude. Set -1 to ignore.') parser.add_argument('--week', type=int, default=-1, help='Week of the year when the recording was made. Values in [1, 48] (4 weeks per month). Set -1 to ignore.') parser.add_argument('--overlap', type=float, default=0.0, help='Overlap in seconds between extracted spectrograms. Values in [0.0, 2.9]. Defaults tp 0.0.') parser.add_argument('--sensitivity', type=float, default=1.0, help='Detection sensitivity; Higher values result in higher sensitivity. Values in [0.5, 1.5]. Defaults to 1.0.') parser.add_argument('--min_conf', type=float, default=0.1, help='Minimum confidence threshold. Values in [0.01, 0.99]. Defaults to 0.1.') parser.add_argument('--custom_list', default='', help='Path to text file containing a list of species. Not used if not provided.') parser.add_argument('--birdweather_id', default='99999', help='Private Station ID for BirdWeather.') args = parser.parse_args() # Load model interpreter = loadModel() # Load custom species list if not args.custom_list == '': WHITE_LIST = loadCustomSpeciesList(args.custom_list) else: WHITE_LIST = [] birdweather_id = args.birdweather_id # Read audio data audioData = readAudioData(args.i, args.overlap) # Get Date/Time from filename in case Pi gets behind #now = datetime.now() full_file_name = args.i file_name = Path(full_file_name).stem file_date = file_name.split('-birdnet-')[0] file_time = file_name.split('-birdnet-')[1] date_time_str = file_date + ' ' + file_time date_time_obj = datetime.datetime.strptime(date_time_str, '%Y-%m-%d %H:%M:%S') #print('Date:', date_time_obj.date()) #print('Time:', date_time_obj.time()) print('Date-time:', date_time_obj) now = date_time_obj current_date = now.strftime("%Y/%m/%d") current_time = now.strftime("%H:%M:%S") current_iso8601 = now.astimezone(get_localzone()).isoformat() week_number = int(now.strftime("%V")) week = max(1, min(week_number, 48)) sensitivity = max(0.5, min(1.0 - (args.sensitivity - 1.0), 1.5)) # Process audio data and get detections detections = analyzeAudioData(audioData, args.lat, args.lon, week, sensitivity, args.overlap, interpreter) # Write detections to output file min_conf = max(0.01, min(args.min_conf, 0.99)) writeResultsToFile(detections, min_conf, args.o) ############################################################################### ############################################################################### soundscape_uploaded = False # Write detections to Database for i in detections: print("\n", detections[i][0],"\n") with open('BirdDB.txt', 'a') as rfile: for d in detections: print("\n", "Database Entry", "\n") for entry in detections[d]: if entry[1] >= min_conf and (entry[0] in WHITE_LIST or len(WHITE_LIST) == 0): rfile.write(str(current_date) + ';' + str(current_time) + ';' + entry[0].replace('_', ';') + ';' \ + str(entry[1]) +";" + str(args.lat) + ';' + str(args.lon) + ';' + str(min_conf) + ';' + str(week) + ';' \ + str(sensitivity) +';' + str(args.overlap) + '\n') def insert_variables_into_table(Date, Time, Sci_Name, Com_Name, Confidence, Lat, Lon, Cutoff, Week, Sens, Overlap): try: connection = mysql.connector.connect(host='localhost', database='birds', user='birder', password='birdnet') cursor = connection.cursor() mySql_insert_query = """INSERT INTO detections (Date, Time, Sci_Name, Com_Name, Confidence, Lat, Lon, Cutoff, Week, Sens, Overlap) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) """ record = (Date, Time, Sci_Name, Com_Name, Confidence, Lat, Lon, Cutoff, Week, Sens, Overlap) cursor.execute(mySql_insert_query, record) connection.commit() print("Record inserted successfully into detections table") except mysql.connector.Error as error: print("Failed to insert record into detections table {}".format(error)) finally: if connection.is_connected(): connection.close() print("MySQL connection is closed") species = entry[0] sci_name,com_name = species.split('_') insert_variables_into_table(str(current_date), str(current_time), sci_name, com_name, \ str(entry[1]), str(args.lat), str(args.lon), str(min_conf), str(week), \ str(args.sensitivity), str(args.overlap)) print(str(current_date) + ';' + str(current_time) + ';' + entry[0].replace('_', ';') + ';' + str(entry[1]) +";" + str(args.lat) + ';' + str(args.lon) + ';' + str(min_conf) + ';' + str(week) + ';' + str(args.sensitivity) +';' + str(args.overlap) + '\n') if birdweather_id != "99999": if soundscape_uploaded is False: # POST soundscape to server soundscape_url = "https://app.birdweather.com/api/v1/stations/" + birdweather_id + "/soundscapes" + "?timestamp=" + current_iso8601 with open(args.i, 'rb') as f: wav_data = f.read() response = requests.post(url=soundscape_url, data=wav_data, headers={'Content-Type': 'application/octet-stream'}) print("Soundscape POST Response Status - ", response.status_code) sdata = response.json() soundscape_id = sdata['soundscape']['id'] soundscape_uploaded = True # POST detection to server detection_url = "https://app.birdweather.com/api/v1/stations/" + birdweather_id + "/detections" start_time = d.split(';')[0] end_time = d.split(';')[1] post_begin = "{ " now_p_start = now + datetime.timedelta(seconds=float(start_time)) current_iso8601 = now_p_start.astimezone(get_localzone()).isoformat() post_timestamp = "\"timestamp\": \"" + current_iso8601 + "\"," post_lat = "\"lat\": " + str(args.lat) + "," post_lon = "\"lon\": " + str(args.lon) + "," post_soundscape_id = "\"soundscapeId\": " + str(soundscape_id) + "," post_soundscape_start_time = "\"soundscapeStartTime\": " + start_time + "," post_soundscape_end_time = "\"soundscapeEndTime\": " + end_time + "," post_commonName = "\"commonName\": \"" + entry[0].split('_')[1] + "\"," post_scientificName = "\"scientificName\": \"" + entry[0].split('_')[0] + "\"," post_algorithm = "\"algorithm\": " + "\"alpha\"" + "," post_confidence = "\"confidence\": " + str(entry[1]) post_end = " }" post_json = post_begin + post_timestamp + post_lat + post_lon + post_soundscape_id + post_soundscape_start_time + post_soundscape_end_time + post_commonName + post_scientificName + post_algorithm + post_confidence + post_end print(post_json) response = requests.post(detection_url, json=json.loads(post_json)) print("Detection POST Response Status - ", response.status_code) #time.sleep(3) ############################################################################### ############################################################################### if __name__ == '__main__': main() # Example calls # python3 analyze.py --i 'example/XC558716 - Soundscape.mp3' --lat 35.4244 --lon -120.7463 --week 18 # python3 analyze.py --i 'example/XC563936 - Soundscape.mp3' --lat 47.6766 --lon -122.294 --week 11 --overlap 1.5 --min_conf 0.25 --sensitivity 1.25 --custom_list 'example/custom_species_list.txt'
[]
[]
[ "CUDA_VISIBLE_DEVICES", "TF_CPP_MIN_LOG_LEVEL" ]
[]
["CUDA_VISIBLE_DEVICES", "TF_CPP_MIN_LOG_LEVEL"]
python
2
0
utils/dependency_management.py
#!/usr/bin/env python # -*- coding: utf-8 -*- ########################################################################### # Copyright (c), The AiiDA team. All rights reserved. # # This file is part of the AiiDA code. # # # # The code is hosted on GitHub at https://github.com/aiidateam/aiida-core # # For further information on the license, see the LICENSE.txt file # # For further information please visit http://www.aiida.net # ########################################################################### """Utility CLI to manage dependencies for aiida-core.""" import os import sys import re import json import subprocess from pathlib import Path from collections import OrderedDict, defaultdict from pkg_resources import Requirement, parse_requirements from packaging.utils import canonicalize_name import click import yaml import tomlkit as toml ROOT = Path(__file__).resolve().parent.parent # repository root SETUPTOOLS_CONDA_MAPPINGS = { 'psycopg2-binary': 'psycopg2', 'graphviz': 'python-graphviz', } CONDA_IGNORE = [] GITHUB_ACTIONS = os.environ.get('GITHUB_ACTIONS') == 'true' class DependencySpecificationError(click.ClickException): """Indicates an issue in a dependency specification.""" def _load_setup_cfg(): """Load the setup configuration from the 'setup.json' file.""" try: with open(ROOT / 'setup.json') as setup_json_file: return json.load(setup_json_file) except json.decoder.JSONDecodeError as error: # pylint: disable=no-member raise DependencySpecificationError(f"Error while parsing 'setup.json' file: {error}") except FileNotFoundError: raise DependencySpecificationError("The 'setup.json' file is missing!") def _load_environment_yml(): """Load the conda environment specification from the 'environment.yml' file.""" try: with open(ROOT / 'environment.yml') as file: return yaml.load(file, Loader=yaml.SafeLoader) except yaml.error.YAMLError as error: raise DependencySpecificationError(f"Error while parsing 'environment.yml':\n{error}") except FileNotFoundError as error: raise DependencySpecificationError(str(error)) def _setuptools_to_conda(req): """Map package names from setuptools to conda where necessary. In case that the same underlying dependency is listed under different names on PyPI and conda-forge. """ for pattern, replacement in SETUPTOOLS_CONDA_MAPPINGS.items(): if re.match(pattern, str(req)): req = Requirement.parse(re.sub(pattern, replacement, str(req))) break # markers are not supported by conda req.marker = None # We need to parse the modified required again, to ensure consistency. return Requirement.parse(str(req)) def _find_linenos_of_requirements_in_setup_json(requirements): """Determine the line numbers of requirements specified in 'setup.json'. Returns a dict that maps a requirement, e.g., `numpy~=1.15.0` to the line numbers at which said requirement is defined within the 'setup.json' file. """ linenos = defaultdict(list) with open(ROOT / 'setup.json') as setup_json_file: lines = list(setup_json_file) # Determine the lines that correspond to affected requirements in setup.json. for requirement in requirements: for lineno, line in enumerate(lines): if str(requirement) in line: linenos[requirement].append(lineno) return linenos class _Entry: """Helper class to check whether a given distribution fulfills a requirement.""" def __init__(self, requirement): self._req = requirement def fulfills(self, requirement): """Returns True if this entry fullfills the requirement.""" return canonicalize_name(self._req.name) == canonicalize_name(requirement.name) \ and self._req.specs[0][1] in requirement.specifier def _parse_working_set(entries): for req in parse_requirements(entries): yield _Entry(req) @click.group() def cli(): """Manage dependencies of the aiida-core package.""" @cli.command('generate-environment-yml') def generate_environment_yml(): """Generate 'environment.yml' file.""" # needed for ordered dict, see https://stackoverflow.com/a/52621703 yaml.add_representer( OrderedDict, lambda self, data: yaml.representer.SafeRepresenter.represent_dict(self, data.items()), Dumper=yaml.SafeDumper ) # Read the requirements from 'setup.json' setup_cfg = _load_setup_cfg() install_requirements = [Requirement.parse(r) for r in setup_cfg['install_requires']] # python version cannot be overriden from outside environment.yml # (even if it is not specified at all in environment.yml) # https://github.com/conda/conda/issues/9506 conda_requires = ['python~=3.7'] for req in install_requirements: if req.name == 'python' or any(re.match(ignore, str(req)) for ignore in CONDA_IGNORE): continue conda_requires.append(str(_setuptools_to_conda(req))) environment = OrderedDict([ ('name', 'aiida'), ('channels', ['conda-forge', 'defaults']), ('dependencies', conda_requires), ]) with open(ROOT / 'environment.yml', 'w') as env_file: env_file.write('# Usage: conda env create -n myenvname -f environment.yml\n') yaml.safe_dump( environment, env_file, explicit_start=True, default_flow_style=False, encoding='utf-8', allow_unicode=True ) @cli.command() def update_pyproject_toml(): """Generate a 'pyproject.toml' file, or update an existing one. This function generates/updates the ``build-system`` section, to be consistent with the 'setup.json' file. """ # read the current file toml_path = ROOT / 'pyproject.toml' if toml_path.exists(): pyproject = toml.loads(toml_path.read_text(encoding='utf8')) else: pyproject = {} # Read the requirements from 'setup.json' setup_cfg = _load_setup_cfg() install_requirements = [Requirement.parse(r) for r in setup_cfg['install_requires']] for requirement in install_requirements: if requirement.name == 'reentry': reentry_requirement = requirement break else: raise DependencySpecificationError("Failed to find reentry requirement in 'setup.json'.") # update the build-system key pyproject.setdefault('build-system', {}) pyproject['build-system'].update({ 'requires': ['setuptools>=40.8.0,<50', 'wheel', str(reentry_requirement), 'fastentrypoints~=0.12'], 'build-backend': 'setuptools.build_meta:__legacy__', }) # write the new file toml_path.write_text(toml.dumps(pyproject), encoding='utf8') @cli.command() @click.pass_context def generate_all(ctx): """Generate all dependent requirement files.""" ctx.invoke(generate_environment_yml) ctx.invoke(update_pyproject_toml) @cli.command('validate-environment-yml', help="Validate 'environment.yml'.") def validate_environment_yml(): # pylint: disable=too-many-branches """Validate that 'environment.yml' is consistent with 'setup.json'.""" # Read the requirements from 'setup.json' and 'environment.yml'. setup_cfg = _load_setup_cfg() install_requirements = [Requirement.parse(r) for r in setup_cfg['install_requires']] python_requires = Requirement.parse('python' + setup_cfg['python_requires']) environment_yml = _load_environment_yml() try: assert environment_yml['name'] == 'aiida', "environment name should be 'aiida'." assert environment_yml['channels'] == [ 'conda-forge', 'defaults' ], "channels should be 'conda-forge', 'defaults'." except AssertionError as error: raise DependencySpecificationError(f"Error in 'environment.yml': {error}") try: conda_dependencies = {Requirement.parse(d) for d in environment_yml['dependencies']} except TypeError as error: raise DependencySpecificationError(f"Error while parsing requirements from 'environment_yml': {error}") # Attempt to find the specification of Python among the 'environment.yml' dependencies. for dependency in conda_dependencies: if dependency.name == 'python': # Found the Python dependency specification conda_python_dependency = dependency conda_dependencies.remove(dependency) break else: # Failed to find Python dependency specification raise DependencySpecificationError("Did not find specification of Python version in 'environment.yml'.") # The Python version specified in 'setup.json' should be listed as trove classifiers. for spec in conda_python_dependency.specifier: expected_classifier = 'Programming Language :: Python :: ' + spec.version if expected_classifier not in setup_cfg['classifiers']: raise DependencySpecificationError(f"Trove classifier '{expected_classifier}' missing from 'setup.json'.") # The Python version should be specified as supported in 'setup.json'. if not any(spec.version >= other_spec.version for other_spec in python_requires.specifier): raise DependencySpecificationError( f"Required Python version {spec.version} from 'environment.yaml' is not consistent with " + "required version in 'setup.json'." ) break else: raise DependencySpecificationError(f"Missing specifier: '{conda_python_dependency}'.") # Check that all requirements specified in the setup.json file are found in the # conda environment specification. for req in install_requirements: if any(re.match(ignore, str(req)) for ignore in CONDA_IGNORE): continue # skip explicitly ignored packages try: conda_dependencies.remove(_setuptools_to_conda(req)) except KeyError: raise DependencySpecificationError(f"Requirement '{req}' not specified in 'environment.yml'.") # The only dependency left should be the one for Python itself, which is not part of # the install_requirements for setuptools. if conda_dependencies: raise DependencySpecificationError( "The 'environment.yml' file contains dependencies that are missing " "in 'setup.json':\n- {}".format('\n- '.join(map(str, conda_dependencies))) ) click.secho('Conda dependency specification is consistent.', fg='green') @cli.command('validate-pyproject-toml', help="Validate 'pyproject.toml'.") def validate_pyproject_toml(): """Validate that 'pyproject.toml' is consistent with 'setup.json'.""" # Read the requirements from 'setup.json' setup_cfg = _load_setup_cfg() install_requirements = [Requirement.parse(r) for r in setup_cfg['install_requires']] for requirement in install_requirements: if requirement.name == 'reentry': reentry_requirement = requirement break else: raise DependencySpecificationError("Failed to find reentry requirement in 'setup.json'.") pyproject_file = ROOT / 'pyproject.toml' if not pyproject_file.exists(): raise DependencySpecificationError("The 'pyproject.toml' file is missing!") pyproject = toml.loads(pyproject_file.read_text(encoding='utf8')) pyproject_requires = [Requirement.parse(r) for r in pyproject['build-system']['requires']] if reentry_requirement not in pyproject_requires: raise DependencySpecificationError(f"Missing requirement '{reentry_requirement}' in 'pyproject.toml'.") click.secho('Pyproject.toml dependency specification is consistent.', fg='green') @cli.command('validate-all', help='Validate consistency of all requirements.') @click.pass_context def validate_all(ctx): """Validate consistency of all requirement specifications of the package. Validates that the specification of requirements/dependencies is consistent across the following files: - setup.py - setup.json - environment.yml - pyproject.toml """ ctx.invoke(validate_environment_yml) ctx.invoke(validate_pyproject_toml) @cli.command() @click.argument('extras', nargs=-1) @click.option( '--github-annotate/--no-github-annotate', default=True, hidden=True, help='Control whether to annotate files with context-specific warnings ' 'as part of a GitHub actions workflow. Note: Requires environment ' 'variable GITHUB_ACTIONS=true .' ) def check_requirements(extras, github_annotate): # pylint disable: too-many-locals-too-many-branches """Check the 'requirements/*.txt' files. Checks that the environments specified in the requirements files match all the dependencies specified in 'setup.json. The arguments allow to specify which 'extra' requirements to expect. Use 'DEFAULT' to select 'atomic_tools', 'docs', 'notebook', 'rest', and 'tests'. """ if len(extras) == 1 and extras[0] == 'DEFAULT': extras = ['atomic_tools', 'docs', 'notebook', 'rest', 'tests'] # Read the requirements from 'setup.json' setup_cfg = _load_setup_cfg() install_requires = setup_cfg['install_requires'] for extra in extras: install_requires.extend(setup_cfg['extras_require'][extra]) install_requires = set(parse_requirements(install_requires)) not_installed = defaultdict(list) for fn_req in (ROOT / 'requirements').iterdir(): match = re.match(r'.*-py-(.*)\.txt', str(fn_req)) if not match: continue env = {'python_version': match.groups()[0]} required = {r for r in install_requires if r.marker is None or r.marker.evaluate(env)} with open(fn_req) as req_file: working_set = list(_parse_working_set(req_file)) installed = {req for req in required for entry in working_set if entry.fulfills(req)} for dependency in required.difference(installed): not_installed[dependency].append(fn_req) if any(not_installed.values()): setup_json_linenos = _find_linenos_of_requirements_in_setup_json(not_installed) # Format error message to be presented to user. error_msg = ["The requirements/ files are missing dependencies specified in the 'setup.json' file.", ''] for dependency, fn_reqs in not_installed.items(): src = 'setup.json:' + ','.join(str(lineno + 1) for lineno in setup_json_linenos[dependency]) error_msg.append(f'{src}: No match for dependency `{dependency}` in:') for fn_req in sorted(fn_reqs): error_msg.append(f' - {fn_req.relative_to(ROOT)}') if GITHUB_ACTIONS: # Set the step ouput error message which can be used, e.g., for display as part of an issue comment. print('::set-output name=error::' + '%0A'.join(error_msg)) if GITHUB_ACTIONS and github_annotate: # Annotate the setup.json file with specific warnings. for dependency, fn_reqs in not_installed.items(): for lineno in setup_json_linenos[dependency]: print( f'::warning file=setup.json,line={lineno+1}::' f"No match for dependency '{dependency}' in: " + ','.join(str(fn_req.relative_to(ROOT)) for fn_req in fn_reqs) ) raise DependencySpecificationError('\n'.join(error_msg)) click.secho("Requirements files appear to be in sync with specifications in 'setup.json'.", fg='green') @cli.command() @click.argument('extras', nargs=-1) def pip_install_extras(extras): """Install extra requirements. For example: pip-install-extras docs This will install *only* the extra the requirements for docs, but without triggering the installation of the main installations requirements of the aiida-core package. """ # Read the requirements from 'setup.json' setup_cfg = _load_setup_cfg() to_install = set() for key in extras: to_install.update(Requirement.parse(r) for r in setup_cfg['extras_require'][key]) cmd = [sys.executable, '-m', 'pip', 'install'] + [str(r) for r in to_install] subprocess.run(cmd, check=True) if __name__ == '__main__': cli() # pylint: disable=no-value-for-parameter
[]
[]
[ "GITHUB_ACTIONS" ]
[]
["GITHUB_ACTIONS"]
python
1
0
modules/core/src/test/java/org/apache/ignite/testframework/GridTestUtils.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.ignite.testframework; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FilenameFilter; import java.io.IOException; import java.io.InputStream; import java.lang.annotation.Annotation; import java.lang.ref.ReferenceQueue; import java.lang.ref.SoftReference; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.net.InetAddress; import java.net.MulticastSocket; import java.net.ServerSocket; import java.nio.file.attribute.PosixFilePermission; import java.security.AccessController; import java.security.GeneralSecurityException; import java.security.KeyStore; import java.security.PrivilegedAction; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.EnumSet; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Queue; import java.util.Random; import java.util.Set; import java.util.Timer; import java.util.TimerTask; import java.util.UUID; import java.util.concurrent.Callable; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicBoolean; import javax.cache.CacheException; import javax.cache.configuration.Factory; import javax.net.ssl.KeyManagerFactory; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManager; import org.apache.ignite.Ignite; import org.apache.ignite.IgniteCache; import org.apache.ignite.IgniteCheckedException; import org.apache.ignite.IgniteException; import org.apache.ignite.IgniteLogger; import org.apache.ignite.Ignition; import org.apache.ignite.cache.query.annotations.QuerySqlFunction; import org.apache.ignite.cluster.ClusterNode; import org.apache.ignite.internal.IgniteEx; import org.apache.ignite.internal.IgniteFutureCancelledCheckedException; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.IgniteInterruptedCheckedException; import org.apache.ignite.internal.IgniteKernal; import org.apache.ignite.internal.client.ssl.GridSslBasicContextFactory; import org.apache.ignite.internal.client.ssl.GridSslContextFactory; import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion; import org.apache.ignite.internal.processors.cache.GridCacheContext; import org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCacheAdapter; import org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionTopology; import org.apache.ignite.internal.processors.cache.distributed.near.GridNearCacheAdapter; import org.apache.ignite.internal.processors.cache.verify.IdleVerifyResultV2; import org.apache.ignite.internal.processors.odbc.ClientListenerProcessor; import org.apache.ignite.internal.processors.port.GridPortRecord; import org.apache.ignite.internal.util.GridBusyLock; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.lang.GridAbsClosure; import org.apache.ignite.internal.util.lang.GridAbsPredicate; import org.apache.ignite.internal.util.lang.IgnitePair; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.G; import org.apache.ignite.internal.util.typedef.T2; import org.apache.ignite.internal.util.typedef.X; import org.apache.ignite.internal.util.typedef.internal.LT; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.lang.IgniteFuture; import org.apache.ignite.lang.IgniteInClosure; import org.apache.ignite.lang.IgnitePredicate; import org.apache.ignite.lang.IgniteRunnable; import org.apache.ignite.plugin.extensions.communication.Message; import org.apache.ignite.spi.discovery.DiscoverySpiCustomMessage; import org.apache.ignite.spi.discovery.DiscoverySpiListener; import org.apache.ignite.ssl.SslContextFactory; import org.apache.ignite.testframework.config.GridTestProperties; import org.apache.ignite.testframework.junits.GridAbstractTest; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; /** * Utility class for tests. */ public final class GridTestUtils { /** Default busy wait sleep interval in milliseconds. */ public static final long DFLT_BUSYWAIT_SLEEP_INTERVAL = 200; /** */ public static final long DFLT_TEST_TIMEOUT = 5 * 60 * 1000; /** */ static final String ALPHABETH = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890_"; /** * Hook object intervenes to discovery message handling * and thus allows to make assertions or other actions like skipping certain discovery messages. */ public static class DiscoveryHook { /** * @param msg Message. */ public void handleDiscoveryMessage(DiscoverySpiCustomMessage msg) { } /** * @param ignite Ignite. */ public void ignite(IgniteEx ignite) { // No-op. } } /** * Injects {@link DiscoveryHook} into handling logic. */ public static final class DiscoverySpiListenerWrapper implements DiscoverySpiListener { /** */ private final DiscoverySpiListener delegate; /** */ private final DiscoveryHook hook; /** * @param delegate Delegate. * @param hook Hook. */ private DiscoverySpiListenerWrapper(DiscoverySpiListener delegate, DiscoveryHook hook) { this.hook = hook; this.delegate = delegate; } /** {@inheritDoc} */ @Override public IgniteFuture<?> onDiscovery(int type, long topVer, ClusterNode node, Collection<ClusterNode> topSnapshot, @Nullable Map<Long, Collection<ClusterNode>> topHist, @Nullable DiscoverySpiCustomMessage spiCustomMsg) { hook.handleDiscoveryMessage(spiCustomMsg); return delegate.onDiscovery(type, topVer, node, topSnapshot, topHist, spiCustomMsg); } /** {@inheritDoc} */ @Override public void onLocalNodeInitialized(ClusterNode locNode) { delegate.onLocalNodeInitialized(locNode); } /** * @param delegate Delegate. * @param discoveryHook Discovery hook. */ public static DiscoverySpiListener wrap(DiscoverySpiListener delegate, DiscoveryHook discoveryHook) { return new DiscoverySpiListenerWrapper(delegate, discoveryHook); } } /** Test parameters scale factor util. */ public static final class SF extends ScaleFactorUtil { } /** */ private static final Map<Class<?>, String> addrs = new HashMap<>(); /** */ private static final Map<Class<? extends GridAbstractTest>, Integer> mcastPorts = new HashMap<>(); /** */ private static final Map<Class<? extends GridAbstractTest>, Integer> discoPorts = new HashMap<>(); /** */ private static final Map<Class<? extends GridAbstractTest>, Integer> commPorts = new HashMap<>(); /** */ private static int[] addr; /** */ private static final int default_mcast_port = 50000; /** */ private static final int max_mcast_port = 54999; /** */ private static final int default_comm_port = 45000; /** */ private static final int max_comm_port = 49999; /** */ private static final int default_disco_port = 55000; /** */ private static final int max_disco_port = 59999; /** */ private static int mcastPort = default_mcast_port; /** */ private static int discoPort = default_disco_port; /** */ private static int commPort = default_comm_port; /** */ private static final GridBusyLock busyLock = new GridBusyLock(); /** */ public static final ConcurrentMap<IgnitePair<UUID>, IgnitePair<Queue<Message>>> msgMap = new ConcurrentHashMap<>(); /** * Ensure singleton. */ private GridTestUtils() { // No-op. } /** * @param from From node ID. * @param to To node ID. * @param msg Message. * @param sent Sent or received. */ public static void addMessage(UUID from, UUID to, Message msg, boolean sent) { IgnitePair<UUID> key = new IgnitePair<>(from, to); IgnitePair<Queue<Message>> val = msgMap.get(key); if (val == null) { IgnitePair<Queue<Message>> old = msgMap.putIfAbsent(key, val = new IgnitePair<Queue<Message>>( new ConcurrentLinkedQueue<Message>(), new ConcurrentLinkedQueue<Message>())); if (old != null) val = old; } (sent ? val.get1() : val.get2()).add(msg); } /** * Dumps all messages tracked with {@link #addMessage(UUID, UUID, Message, boolean)} to std out. */ public static void dumpMessages() { for (Map.Entry<IgnitePair<UUID>, IgnitePair<Queue<Message>>> entry : msgMap.entrySet()) { U.debug("\n" + entry.getKey().get1() + " [sent to] " + entry.getKey().get2()); for (Message message : entry.getValue().get1()) U.debug("\t" + message); U.debug(entry.getKey().get2() + " [received from] " + entry.getKey().get1()); for (Message message : entry.getValue().get2()) U.debug("\t" + message); } } // static { // new Thread(new Runnable() { // @Override public void run() { // JOptionPane.showMessageDialog(null, "Close this to dump messages."); // // dumpMessages(); // } // }).start(); // } /** * Checks that string {@param str} doesn't contains substring {@param substr}. Logs both strings * and throws {@link java.lang.AssertionError}, if contains. * * @param log Logger (optional). * @param str String. * @param substr Substring. */ public static void assertNotContains(@Nullable IgniteLogger log, String str, String substr) { try { assertFalse(str.contains(substr)); } catch (AssertionError e) { U.warn(log, String.format("String contain substring: '%s', but shouldn't:", substr)); U.warn(log, "String:"); U.warn(log, str); throw e; } } /** * Checks that string {@param str} contains substring {@param substr}. Logs both strings * and throws {@link java.lang.AssertionError}, if not. * * @param log Logger (optional). * @param str String. * @param substr Substring. */ public static void assertContains(@Nullable IgniteLogger log, String str, String substr) { try { assertTrue(str != null && str.contains(substr)); } catch (AssertionError e) { U.warn(log, String.format("String does not contain substring: '%s':", substr)); U.warn(log, "String:"); U.warn(log, str); throw e; } } /** * Checks that collection {@param col} contains string {@param str}. Logs collection, string * and throws {@link java.lang.AssertionError}, if not. * * @param log Logger (optional). * @param col Collection. * @param str String. */ public static <C extends Collection<String>> void assertContains(@Nullable IgniteLogger log, C col, String str) { try { assertTrue(col.contains(str)); } catch (AssertionError e) { U.warn(log, String.format("Collection does not contain string: '%s':", str)); U.warn(log, "Collection:"); U.warn(log, col); throw e; } } /** * Checks that collection {@param col} doesn't contains string {@param str}. Logs collection, string * and throws {@link java.lang.AssertionError}, if contains. * * @param log Logger (optional). * @param col Collection. * @param str String. */ public static <C extends Collection<String>> void assertNotContains(@Nullable IgniteLogger log, C col, String str) { try { assertFalse(col.contains(str)); } catch (AssertionError e) { U.warn(log, String.format("Collection contain string: '%s' but shouldn't:", str)); U.warn(log, "Collection:"); U.warn(log, col); throw e; } } /** * Checks whether callable throws expected exception or not. * * @param log Logger (optional). * @param call Callable. * @param cls Exception class. * @param msg Exception message (optional). If provided exception message * and this message should be equal. * @return Thrown throwable. */ public static Throwable assertThrows(@Nullable IgniteLogger log, Callable<?> call, Class<? extends Throwable> cls, @Nullable String msg) { assert call != null; assert cls != null; try { call.call(); } catch (Throwable e) { if (cls != e.getClass() && !cls.isAssignableFrom(e.getClass())) { if (e.getClass() == CacheException.class && e.getCause() != null && e.getCause().getClass() == cls) e = e.getCause(); else { U.error(log, "Unexpected exception.", e); fail("Exception class is not as expected [expected=" + cls + ", actual=" + e.getClass() + ']', e); } } if (msg != null && (e.getMessage() == null || !e.getMessage().contains(msg))) { U.error(log, "Unexpected exception message.", e); fail("Exception message is not as expected [expected=" + msg + ", actual=" + e.getMessage() + ']', e); } if (log != null) { if (log.isInfoEnabled()) log.info("Caught expected exception: " + e.getMessage()); } else X.println("Caught expected exception: " + e.getMessage()); return e; } throw new AssertionError("Exception has not been thrown."); } /** * Checks whether callable throws an exception with specified cause. * * @param log Logger (optional). * @param call Callable. * @param cls Exception class. * @param msg Exception message (optional). If provided exception message * and this message should be equal. * @return Thrown throwable. */ public static Throwable assertThrowsAnyCause(@Nullable IgniteLogger log, Callable<?> call, Class<? extends Throwable> cls, @Nullable String msg) { assert call != null; assert cls != null; try { call.call(); } catch (Throwable e) { Throwable t = e; while (t != null) { if (cls == t.getClass() && (msg == null || (t.getMessage() != null && t.getMessage().contains(msg)))) { if (log != null && log.isInfoEnabled()) log.info("Caught expected exception: " + t.getMessage()); return t; } t = t.getCause(); } fail("Unexpected exception", e); } throw new AssertionError("Exception has not been thrown."); } /** * Checks whether callable throws expected exception or its child or not. * * @param log Logger (optional). * @param call Callable. * @param cls Exception class. * @param msg Exception message (optional). If provided exception message * and this message should be equal. * @return Thrown throwable. */ @Nullable public static Throwable assertThrowsInherited(@Nullable IgniteLogger log, Callable<?> call, Class<? extends Throwable> cls, @Nullable String msg) { assert call != null; assert cls != null; try { call.call(); } catch (Throwable e) { if (!cls.isAssignableFrom(e.getClass())) fail("Exception class is not as expected [expected=" + cls + ", actual=" + e.getClass() + ']', e); if (msg != null && (e.getMessage() == null || !e.getMessage().startsWith(msg))) fail("Exception message is not as expected [expected=" + msg + ", actual=" + e.getMessage() + ']', e); if (log != null) { if (log.isDebugEnabled()) log.debug("Caught expected exception: " + e.getMessage()); } else X.println("Caught expected exception: " + e.getMessage()); return e; } throw new AssertionError("Exception has not been thrown."); } /** * Checks whether callable throws exception, which is itself of a specified * class, or has a cause of the specified class. * * @param runnable Runnable. * @param cls Expected class. * @return Thrown throwable. */ @Nullable public static Throwable assertThrowsWithCause(Runnable runnable, Class<? extends Throwable> cls) { return assertThrowsWithCause(new Callable<Integer>() { @Override public Integer call() throws Exception { runnable.run(); return 0; } }, cls); } /** * Checks whether callable throws exception, which is itself of a specified * class, or has a cause of the specified class. * * @param call Callable. * @param cls Expected class. * @return Thrown throwable. */ @Nullable public static Throwable assertThrowsWithCause(Callable<?> call, Class<? extends Throwable> cls) { assert call != null; assert cls != null; try { call.call(); } catch (Throwable e) { if (!X.hasCause(e, cls)) fail("Exception is neither of a specified class, nor has a cause of the specified class: " + cls, e); return e; } throw new AssertionError("Exception has not been thrown."); } /** * Checks whether closure throws exception, which is itself of a specified * class, or has a cause of the specified class. * * @param call Closure. * @param p Parameter passed to closure. * @param cls Expected class. * @return Thrown throwable. */ public static <P> Throwable assertThrowsWithCause(IgniteInClosure<P> call, P p, Class<? extends Throwable> cls) { assert call != null; assert cls != null; try { call.apply(p); } catch (Throwable e) { if (!X.hasCause(e, cls)) fail("Exception is neither of a specified class, nor has a cause of the specified class: " + cls, e); return e; } throw new AssertionError("Exception has not been thrown."); } /** * Asserts that the specified runnable completes within the specified timeout. * * @param msg Assertion message in case of timeout. * @param timeout Timeout. * @param timeUnit Timeout {@link TimeUnit}. * @param runnable {@link Runnable} to check. * @throws Exception In case of any exception distinct from {@link TimeoutException}. */ public static void assertTimeout(String msg, long timeout, TimeUnit timeUnit, Runnable runnable) throws Exception { ExecutorService executorSvc = Executors.newSingleThreadExecutor(); Future<?> fut = executorSvc.submit(runnable); try { fut.get(timeout, timeUnit); } catch (TimeoutException ignored) { fail(msg, null); } finally { executorSvc.shutdownNow(); } } /** * Asserts that the specified runnable completes within the specified timeout. * * @param timeout Timeout. * @param timeUnit Timeout {@link TimeUnit}. * @param runnable {@link Runnable} to check. * @throws Exception In case of any exception distinct from {@link TimeoutException}. */ public static void assertTimeout(long timeout, TimeUnit timeUnit, Runnable runnable) throws Exception { assertTimeout("Timeout occurred.", timeout, timeUnit, runnable); } /** * Throw assertion error with specified error message and initialized cause. * * @param msg Error message. * @param cause Error cause. * @return Assertion error. */ private static AssertionError fail(String msg, @Nullable Throwable cause) { AssertionError e = new AssertionError(msg); if (cause != null) e.initCause(cause); throw e; } /** * Checks whether object's method call throws expected exception or not. * * @param log Logger (optional). * @param cls Exception class. * @param msg Exception message (optional). If provided exception message * and this message should be equal. * @param obj Object to invoke method for. * @param mtd Object's method to invoke. * @param params Method parameters. * @return Thrown throwable. */ @Nullable public static Throwable assertThrows(@Nullable IgniteLogger log, Class<? extends Throwable> cls, @Nullable String msg, final Object obj, final String mtd, final Object... params) { return assertThrows(log, new Callable() { @Override public Object call() throws Exception { return invoke(obj, mtd, params); } }, cls, msg); } /** * Asserts that each element in iterable has one-to-one correspondence with a * predicate from list. * * @param it Input iterable of elements. * @param ps Array of predicates (by number of elements in iterable). */ public static <T> void assertOneToOne(Iterable<T> it, IgnitePredicate<T>... ps) { Collection<IgnitePredicate<T>> ps0 = new ArrayList<>(Arrays.asList(ps)); Collection<T2<IgnitePredicate<T>, T>> passed = new ArrayList<>(); for (T elem : it) { for (T2<IgnitePredicate<T>, T> p : passed) { if (p.get1().apply(elem)) throw new AssertionError("Two elements match one predicate [elem1=" + p.get2() + ", elem2=" + elem + ", pred=" + p.get1() + ']'); } IgnitePredicate<T> matched = null; for (IgnitePredicate<T> p : ps0) { if (p.apply(elem)) { if (matched != null) throw new AssertionError("Element matches more than one predicate [elem=" + elem + ", pred1=" + p + ", pred2=" + matched + ']'); matched = p; } } if (matched == null) // None matched. throw new AssertionError("The element does not match [elem=" + elem + ", numRemainingPreds=" + ps0.size() + ']'); ps0.remove(matched); passed.add(new T2<>(matched, elem)); } } /** * Every invocation of this method will never return a * repeating multicast port for a different test case. * * @param cls Class. * @return Next multicast port. */ public static synchronized int getNextMulticastPort(Class<? extends GridAbstractTest> cls) { Integer portRet = mcastPorts.get(cls); if (portRet != null) return portRet; int startPort = mcastPort; while (true) { if (mcastPort >= max_mcast_port) mcastPort = default_mcast_port; else mcastPort++; if (startPort == mcastPort) break; portRet = mcastPort; MulticastSocket sock = null; try { sock = new MulticastSocket(portRet); break; } catch (IOException ignored) { // No-op. } finally { U.closeQuiet(sock); } } // Cache port to be reused by the same test. mcastPorts.put(cls, portRet); return portRet; } /** * Every invocation of this method will never return a * repeating communication port for a different test case. * * @param cls Class. * @return Next communication port. */ public static synchronized int getNextCommPort(Class<? extends GridAbstractTest> cls) { Integer portRet = commPorts.get(cls); if (portRet != null) return portRet; if (commPort >= max_comm_port) commPort = default_comm_port; else // Reserve 10 ports per test. commPort += 10; portRet = commPort; // Cache port to be reused by the same test. commPorts.put(cls, portRet); return portRet; } /** * Every invocation of this method will never return a * repeating discovery port for a different test case. * * @param cls Class. * @return Next discovery port. */ public static synchronized int getNextDiscoPort(Class<? extends GridAbstractTest> cls) { Integer portRet = discoPorts.get(cls); if (portRet != null) return portRet; if (discoPort >= max_disco_port) discoPort = default_disco_port; else discoPort += 10; portRet = discoPort; // Cache port to be reused by the same test. discoPorts.put(cls, portRet); return portRet; } /** * @return Free communication port number on localhost. * @throws IOException If unable to find a free port. */ public static int getFreeCommPort() throws IOException { for (int port = default_comm_port; port < max_comm_port; port++) { try (ServerSocket sock = new ServerSocket(port)) { return sock.getLocalPort(); } catch (IOException ignored) { // No-op. } } throw new IOException("Unable to find a free communication port."); } /** * Every invocation of this method will never return a * repeating multicast group for a different test case. * * @param cls Class. * @return Next multicast group. */ public static synchronized String getNextMulticastGroup(Class<?> cls) { String addrStr = addrs.get(cls); if (addrStr != null) return addrStr; // Increment address. if (addr[3] == 255) { if (addr[2] == 255) assert false; else { addr[2] += 1; addr[3] = 1; } } else addr[3] += 1; // Convert address to string. StringBuilder b = new StringBuilder(15); for (int i = 0; i < addr.length; i++) { b.append(addr[i]); if (i < addr.length - 1) b.append('.'); } addrStr = b.toString(); // Cache address to be reused by the same test. addrs.put(cls, addrStr); return addrStr; } /** * Runs runnable object in specified number of threads. * * @param run Target runnable. * @param threadNum Number of threads. * @param threadName Thread name. * @return Execution time in milliseconds. * @throws Exception Thrown if at least one runnable execution failed. */ public static long runMultiThreaded(Runnable run, int threadNum, String threadName) throws Exception { return runMultiThreaded(makeCallable(run, null), threadNum, threadName); } /** * Runs runnable object in specified number of threads. * * @param run Target runnable. * @param threadNum Number of threads. * @param threadName Thread name. * @return Future for the run. Future returns execution time in milliseconds. */ public static IgniteInternalFuture<Long> runMultiThreadedAsync(Runnable run, int threadNum, String threadName) { return runMultiThreadedAsync(makeCallable(run, null), threadNum, threadName); } /** * Runs callable object in specified number of threads. * * @param call Callable. * @param threadNum Number of threads. * @param threadName Thread names. * @return Execution time in milliseconds. * @throws Exception If failed. */ public static long runMultiThreaded(Callable<?> call, int threadNum, String threadName) throws Exception { List<Callable<?>> calls = Collections.<Callable<?>>nCopies(threadNum, call); return runMultiThreaded(calls, threadName); } /** * @param call Closure that receives thread index. * @param threadNum Number of threads. * @param threadName Thread names. * @return Execution time in milliseconds. * @throws Exception If failed. */ public static long runMultiThreaded(final IgniteInClosure<Integer> call, int threadNum, String threadName) throws Exception { List<Callable<?>> calls = new ArrayList<>(threadNum); for (int i = 0; i < threadNum; i++) { final int idx = i; calls.add(new Callable<Void>() { @Override public Void call() throws Exception { call.apply(idx); return null; } }); } return runMultiThreaded(calls, threadName); } /** * Runs callable object in specified number of threads. * * @param call Callable. * @param threadNum Number of threads. * @param threadName Thread names. * @return Future for the run. Future returns execution time in milliseconds. */ public static IgniteInternalFuture<Long> runMultiThreadedAsync(Callable<?> call, int threadNum, final String threadName) { final List<Callable<?>> calls = Collections.<Callable<?>>nCopies(threadNum, call); final GridTestSafeThreadFactory threadFactory = new GridTestSafeThreadFactory(threadName); IgniteInternalFuture<Long> runFut = runAsync(() -> runMultiThreaded(calls, threadFactory)); GridFutureAdapter<Long> resFut = new GridFutureAdapter<Long>() { @Override public boolean cancel() throws IgniteCheckedException { super.cancel(); if (isDone()) return false; runFut.cancel(); threadFactory.interruptAllThreads(); return onCancelled(); } }; runFut.listen(fut -> { try { resFut.onDone(fut.get()); } catch (IgniteFutureCancelledCheckedException e) { resFut.onCancelled(); } catch (Throwable e) { resFut.onDone(e); } }); return resFut; } /** * Runs callable tasks each in separate threads. * * @param calls Callable tasks. * @param threadName Thread name. * @return Execution time in milliseconds. * @throws Exception If failed. */ public static long runMultiThreaded(Iterable<Callable<?>> calls, String threadName) throws Exception { return runMultiThreaded(calls, new GridTestSafeThreadFactory(threadName)); } /** * Runs callable tasks each in separate threads. * * @param calls Callable tasks. * @param threadFactory Thread factory. * @return Execution time in milliseconds. * @throws Exception If failed. */ public static long runMultiThreaded(Iterable<Callable<?>> calls, GridTestSafeThreadFactory threadFactory) throws Exception { if (!busyLock.enterBusy()) throw new IllegalStateException("Failed to start new threads (test is being stopped)."); Collection<Thread> threads = new ArrayList<>(); long time; try { for (Callable<?> call : calls) threads.add(threadFactory.newThread(call)); time = System.currentTimeMillis(); for (Thread t : threads) t.start(); } finally { busyLock.leaveBusy(); } // Wait threads finish their job. try { for (Thread t : threads) t.join(); } catch (InterruptedException e) { for (Thread t : threads) t.interrupt(); throw e; } time = System.currentTimeMillis() - time; // Validate errors happens threadFactory.checkError(); return time; } /** * Runs runnable task asyncronously. * * @param task Runnable. * @return Future with task result. */ public static IgniteInternalFuture runAsync(final Runnable task) { return runAsync(task,"async-runnable-runner"); } /** * Runs runnable task asyncronously. * * @param task Runnable. * @return Future with task result. */ public static IgniteInternalFuture runAsync(final Runnable task, String threadName) { return runAsync(() -> { task.run(); return null; }, threadName); } /** * Runs callable task asyncronously. * * @param task Callable. * @return Future with task result. */ public static <T> IgniteInternalFuture<T> runAsync(final Callable<T> task) { return runAsync(task, "async-callable-runner"); } /** * Runs callable task asyncronously. * * @param task Callable. * @param threadName Thread name. * @return Future with task result. */ public static <T> IgniteInternalFuture<T> runAsync(final Callable<T> task, String threadName) { if (!busyLock.enterBusy()) throw new IllegalStateException("Failed to start new threads (test is being stopped)."); try { final GridTestSafeThreadFactory thrFactory = new GridTestSafeThreadFactory(threadName); final GridFutureAdapter<T> fut = new GridFutureAdapter<T>() { @Override public boolean cancel() throws IgniteCheckedException { super.cancel(); if (isDone()) return false; thrFactory.interruptAllThreads(); try { get(); return false; } catch (IgniteFutureCancelledCheckedException e) { return true; } catch (IgniteCheckedException e) { return false; } } }; thrFactory.newThread(() -> { try { // Execute task. T res = task.call(); fut.onDone(res); } catch (InterruptedException e) { fut.onCancelled(); } catch (Throwable e) { fut.onDone(e); } }).start(); return fut; } finally { busyLock.leaveBusy(); } } /** * Wait for all passed futures to complete even if they fail. * * @param futs Futures. * @throws AssertionError Suppresses underlying exceptions if some futures failed. */ public static void waitForAllFutures(IgniteInternalFuture<?>... futs) { AssertionError err = null; for (IgniteInternalFuture<?> fut : futs) { try { fut.get(); } catch (Throwable t) { if (err == null) err = new AssertionError("One or several futures threw the exception."); err.addSuppressed(t); } } if (err != null) throw err; } /** * Interrupts and waits for termination of all the threads started * so far by current test. * * @param log Logger. */ public static void stopThreads(IgniteLogger log) { busyLock.block(); try { GridTestSafeThreadFactory.stopAllThreads(log); } finally { busyLock.unblock(); } } /** * @return Ignite home. * @throws Exception If failed. */ @SuppressWarnings({"ProhibitedExceptionThrown"}) public static String getIgniteHome() throws Exception { String ggHome = System.getProperty("IGNITE_HOME"); if (ggHome == null) ggHome = System.getenv("IGNITE_HOME"); if (ggHome == null) throw new Exception("IGNITE_HOME parameter must be set either as system or environment variable."); File dir = new File(ggHome); if (!dir.exists()) throw new Exception("Ignite home does not exist [ignite-home=" + dir.getAbsolutePath() + ']'); if (!dir.isDirectory()) throw new Exception("Ignite home is not a directory [ignite-home=" + dir.getAbsolutePath() + ']'); return ggHome; } /** * @param <T> Type. * @param cls Class. * @param annCls Annotation class. * @return Annotation. */ @Nullable public static <T extends Annotation> T getAnnotation(Class<?> cls, Class<T> annCls) { for (Class<?> cls0 = cls; cls0 != null; cls0 = cls0.getSuperclass()) { T ann = cls0.getAnnotation(annCls); if (ann != null) return ann; } return null; } /** * Initializes address. */ static { InetAddress locHost = null; try { locHost = U.getLocalHost(); } catch (IOException e) { assert false : "Unable to get local address. This leads to the same multicast addresses " + "in the local network."; } if (locHost != null) { int thirdByte = locHost.getAddress()[3]; if (thirdByte < 0) thirdByte += 256; // To get different addresses for different machines. addr = new int[] {229, thirdByte, 1, 1}; } else addr = new int[] {229, 1, 1, 1}; } /** * @param path Path. * @param startFilter Start filter. * @param endFilter End filter. * @return List of JARs that corresponds to the filters. * @throws IOException If failed. */ private static Collection<String> getFiles(String path, @Nullable final String startFilter, @Nullable final String endFilter) throws IOException { Collection<String> res = new ArrayList<>(); File file = new File(path); assert file.isDirectory(); File[] jars = file.listFiles(new FilenameFilter() { /** * @see FilenameFilter#accept(File, String) */ @SuppressWarnings({"UnnecessaryJavaDocLink"}) @Override public boolean accept(File dir, String name) { // Exclude spring.jar because it tries to load META-INF/spring-handlers.xml from // all available JARs and create instances of classes from there for example. // Exclude logging as it is used by spring and casted to Log interface. // Exclude log4j because of the design - 1 per VM. if (name.startsWith("spring") || name.startsWith("log4j") || name.startsWith("commons-logging") || name.startsWith("junit") || name.startsWith("ignite-tests")) return false; boolean ret = true; if (startFilter != null) ret = name.startsWith(startFilter); if (ret && endFilter != null) ret = name.endsWith(endFilter); return ret; } }); for (File jar : jars) res.add(jar.getCanonicalPath()); return res; } /** * Silent stop grid. * Method doesn't throw any exception. * * @param ignite Grid to stop. * @param log Logger. */ public static void close(Ignite ignite, IgniteLogger log) { if (ignite != null) try { G.stop(ignite.name(), false); } catch (Throwable e) { U.error(log, "Failed to stop grid: " + ignite.name(), e); } } /** * Silent stop grid. * Method doesn't throw any exception. * * @param igniteInstanceName Ignite instance name. * @param log Logger. */ public static void stopGrid(String igniteInstanceName, IgniteLogger log) { try { G.stop(igniteInstanceName, false); } catch (Throwable e) { U.error(log, "Failed to stop grid: " + igniteInstanceName, e); } } /** * Gets file representing the path passed in. First the check is made if path is absolute. * If not, then the check is made if path is relative to ${IGNITE_HOME}. If both checks fail, * then {@code null} is returned, otherwise file representing path is returned. * <p> * See {@link #getIgniteHome()} for information on how {@code IGNITE_HOME} is retrieved. * * @param path Path to resolve. * @return Resolved path, or {@code null} if file cannot be resolved. * @see #getIgniteHome() */ @Nullable public static File resolveIgnitePath(String path) { return resolvePath(null, path); } /** * @param igniteHome Optional ignite home path. * @param path Path to resolve. * @return Resolved path, or {@code null} if file cannot be resolved. */ @Nullable private static File resolvePath(@Nullable String igniteHome, String path) { File file = new File(path).getAbsoluteFile(); if (!file.exists()) { String home = igniteHome != null ? igniteHome : U.getIgniteHome(); if (home == null) return null; file = new File(home, path); return file.exists() ? file : null; } return file; } /** * @param cache Cache. * @return Cache context. */ public static <K, V> GridCacheContext<K, V> cacheContext(IgniteCache<K, V> cache) { return ((IgniteKernal)cache.unwrap(Ignite.class)).<K, V>internalCache(cache.getName()).context(); } /** * @param cache Cache. * @return Near cache. */ public static <K, V> GridNearCacheAdapter<K, V> near(IgniteCache<K, V> cache) { return cacheContext(cache).near(); } /** * @param cache Cache. * @return DHT cache. */ public static <K, V> GridDhtCacheAdapter<K, V> dht(IgniteCache<K, V> cache) { return near(cache).dht(); } /** * @param cacheName Cache name. * @param backups Number of backups. * @param log Logger. * @throws Exception If failed. */ @SuppressWarnings("BusyWait") public static <K, V> void waitTopologyUpdate(@Nullable String cacheName, int backups, IgniteLogger log) throws Exception { for (Ignite g : Ignition.allGrids()) { IgniteCache<K, V> cache = ((IgniteEx)g).cache(cacheName); GridDhtPartitionTopology top = dht(cache).topology(); while (true) { boolean wait = false; for (int p = 0; p < g.affinity(cacheName).partitions(); p++) { Collection<ClusterNode> nodes = top.nodes(p, AffinityTopologyVersion.NONE); if (nodes.size() > backups + 1) { LT.warn(log, "Partition map was not updated yet (will wait) [igniteInstanceName=" + g.name() + ", p=" + p + ", nodes=" + F.nodeIds(nodes) + ']'); wait = true; break; } } if (wait) Thread.sleep(20); else break; // While. } } } /** * Convert runnable tasks with callable. * * @param run Runnable task to convert into callable one. * @param res Callable result. * @param <T> The result type of method <tt>call</tt>, always {@code null}. * @return Callable task around the specified runnable one. */ public static <T> Callable<T> makeCallable(final Runnable run, @Nullable final T res) { return new Callable<T>() { @Override public T call() throws Exception { run.run(); return res; } }; } /** * Get object field value via reflection. * * @param obj Object or class to get field value from. * @param cls Class. * @param fieldName Field names to get value for. * @param <T> Expected field class. * @return Field value. * @throws IgniteException In case of error. */ public static <T> T getFieldValue(Object obj, Class cls, String fieldName) throws IgniteException { assert obj != null; assert fieldName != null; try { return (T)findField(cls, obj, fieldName); } catch (NoSuchFieldException | IllegalAccessException e) { throw new IgniteException("Failed to get object field [obj=" + obj + ", fieldName=" + fieldName + ']', e); } } /** * Get object field value via reflection. * * @param obj Object or class to get field value from. * @param fieldNames Field names to get value for: obj->field1->field2->...->fieldN. * @param <T> Expected field class. * @return Field value. * @throws IgniteException In case of error. */ public static <T> T getFieldValue(Object obj, String... fieldNames) throws IgniteException { assert obj != null; assert fieldNames != null; assert fieldNames.length >= 1; try { for (String fieldName : fieldNames) { Class<?> cls = obj instanceof Class ? (Class)obj : obj.getClass(); try { obj = findField(cls, obj, fieldName); } catch (NoSuchFieldException e) { // Resolve inner class, if not an inner field. Class<?> innerCls = getInnerClass(cls, fieldName); if (innerCls == null) throw new IgniteException("Failed to get object field [obj=" + obj + ", fieldNames=" + Arrays.toString(fieldNames) + ']', e); obj = innerCls; } } return (T)obj; } catch (IllegalAccessException e) { throw new IgniteException("Failed to get object field [obj=" + obj + ", fieldNames=" + Arrays.toString(fieldNames) + ']', e); } } /** * Get object field value via reflection(including superclass). * * @param obj Object or class to get field value from. * @param fieldNames Field names to get value for: obj->field1->field2->...->fieldN. * @param <T> Expected field class. * @return Field value. * @throws IgniteException In case of error. */ public static <T> T getFieldValueHierarchy(Object obj, String... fieldNames) throws IgniteException { assert obj != null; assert fieldNames != null; assert fieldNames.length >= 1; try { for (String fieldName : fieldNames) { Class<?> cls = obj instanceof Class ? (Class)obj : obj.getClass(); while (cls != null) { try { obj = findField(cls, obj, fieldName); break; } catch (NoSuchFieldException e) { cls = cls.getSuperclass(); } } } return (T)obj; } catch (IllegalAccessException e) { throw new IgniteException("Failed to get object field [obj=" + obj + ", fieldNames=" + Arrays.toString(fieldNames) + ']', e); } } /** * @param cls Class for searching. * @param obj Target object. * @param fieldName Field name for search. * @return Field from object if it was found. */ private static Object findField(Class<?> cls, Object obj, String fieldName) throws NoSuchFieldException, IllegalAccessException { // Resolve inner field. Field field = cls.getDeclaredField(fieldName); boolean accessible = field.isAccessible(); if (!accessible) field.setAccessible(true); return field.get(obj); } /** * Change static final fields. * @param field Need to be changed. * @param newVal New value. * @throws Exception If failed. */ public static void setFieldValue(Field field, Object newVal) throws Exception { field.setAccessible(true); Field modifiersField = Field.class.getDeclaredField("modifiers"); AccessController.doPrivileged(new PrivilegedAction() { @Override public Object run() { modifiersField.setAccessible(true); return null; } }); modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); field.set(null, newVal); } /** * Get inner class by its name from the enclosing class. * * @param parentCls Parent class to resolve inner class for. * @param innerClsName Name of the inner class. * @return Inner class. */ @Nullable public static <T> Class<T> getInnerClass(Class<?> parentCls, String innerClsName) { for (Class<?> cls : parentCls.getDeclaredClasses()) if (innerClsName.equals(cls.getSimpleName())) return (Class<T>)cls; return null; } /** * Set object field value via reflection. * * @param obj Object to set field value to. * @param fieldName Field name to set value for. * @param val New field value. * @throws IgniteException In case of error. */ public static void setFieldValue(Object obj, String fieldName, Object val) throws IgniteException { assert obj != null; assert fieldName != null; try { Class<?> cls = obj instanceof Class ? (Class)obj : obj.getClass(); Field field = cls.getDeclaredField(fieldName); boolean accessible = field.isAccessible(); if (!accessible) field.setAccessible(true); field.set(obj, val); } catch (NoSuchFieldException | IllegalAccessException e) { throw new IgniteException("Failed to set object field [obj=" + obj + ", field=" + fieldName + ']', e); } } /** * Set object field value via reflection. * * @param obj Object to set field value to. * @param cls Class to get field from. * @param fieldName Field name to set value for. * @param val New field value. * @throws IgniteException In case of error. */ public static void setFieldValue(Object obj, Class cls, String fieldName, Object val) throws IgniteException { assert fieldName != null; try { Field field = cls.getDeclaredField(fieldName); boolean accessible = field.isAccessible(); if (!accessible) field.setAccessible(true); boolean isFinal = (field.getModifiers() & Modifier.FINAL) != 0; if (isFinal) { Field modifiersField = Field.class.getDeclaredField("modifiers"); modifiersField.setAccessible(true); modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); } field.set(obj, val); } catch (NoSuchFieldException | IllegalAccessException e) { throw new IgniteException("Failed to set object field [obj=" + obj + ", field=" + fieldName + ']', e); } } /** * Invoke method on an object. * * @param obj Object to call method on. * @param mtd Method to invoke. * @param params Parameters of the method. * @return Method invocation result. * @throws Exception If failed. */ @Nullable public static <T> T invoke(Object obj, String mtd, Object... params) throws Exception { Class<?> cls = obj.getClass(); do { // We cannot resolve method by parameter classes due to some of parameters can be null. // Search correct method among all methods collection. for (Method m : cls.getDeclaredMethods()) { // Filter methods by name. if (!m.getName().equals(mtd)) continue; if (!areCompatible(params, m.getParameterTypes())) continue; try { boolean accessible = m.isAccessible(); if (!accessible) m.setAccessible(true); return (T)m.invoke(obj, params); } catch (IllegalAccessException e) { throw new RuntimeException("Failed to access method" + " [obj=" + obj + ", mtd=" + mtd + ", params=" + Arrays.toString(params) + ']', e); } catch (InvocationTargetException e) { Throwable cause = e.getCause(); if (cause instanceof Error) throw (Error) cause; if (cause instanceof Exception) throw (Exception) cause; throw new RuntimeException("Failed to invoke method)" + " [obj=" + obj + ", mtd=" + mtd + ", params=" + Arrays.toString(params) + ']', e); } } cls = cls.getSuperclass(); } while (cls != Object.class); throw new RuntimeException("Failed to find method" + " [obj=" + obj + ", mtd=" + mtd + ", params=" + Arrays.toString(params) + ']'); } /** * Check objects and corresponding types are compatible. * * @param objs Objects array. * @param types Classes array. * @return Objects in array can be casted to corresponding types. */ private static boolean areCompatible(Object[] objs, Class[] types) { if (objs.length != types.length) return false; for (int i = 0, size = objs.length; i < size; i++) { Object o = objs[i]; if (o != null && !types[i].isInstance(o)) return false; } return true; } /** * Tries few times to perform some assertion. In the worst case * {@code assertion} closure will be executed {@code retries} + 1 times and * thread will spend approximately {@code retries} * {@code retryInterval} sleeping. * * @param log Log. * @param retries Number of retries. * @param retryInterval Interval between retries in milliseconds. * @param c Closure with assertion. All {@link AssertionError}s thrown * from this closure will be ignored {@code retries} times. * @throws org.apache.ignite.internal.IgniteInterruptedCheckedException If interrupted. */ @SuppressWarnings("ErrorNotRethrown") public static void retryAssert(@Nullable IgniteLogger log, int retries, long retryInterval, GridAbsClosure c) throws IgniteInterruptedCheckedException { for (int i = 0; i < retries; i++) { try { c.apply(); return; } catch (AssertionError e) { U.warn(log, "Check failed (will retry in " + retryInterval + "ms).", e); U.sleep(retryInterval); } } // Apply the last time without guarding try. c.apply(); } /** * Reads entire file into byte array. * * @param file File to read. * @return Content of file in byte array. * @throws IOException If failed. */ public static byte[] readFile(File file) throws IOException { assert file.exists(); assert file.length() < Integer.MAX_VALUE; byte[] bytes = new byte[(int) file.length()]; try (FileInputStream fis = new FileInputStream(file)) { int readBytesCnt = fis.read(bytes); assert readBytesCnt == bytes.length; } return bytes; } /** * Reads resource into byte array. * * @param classLoader Classloader. * @param resourceName Resource name. * @return Content of resorce in byte array. * @throws IOException If failed. */ public static byte[] readResource(ClassLoader classLoader, String resourceName) throws IOException { try (InputStream is = classLoader.getResourceAsStream(resourceName)) { assertNotNull("Resource is missing: " + resourceName , is); try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) { U.copy(is, baos); return baos.toByteArray(); } } } /** * Sleeps and increments an integer. * <p> * Allows for loops like the following: * <pre>{@code * for (int i = 0; i < 20 && !condition; i = sleepAndIncrement(200, i)) { * ... * } * }</pre> * for busy-waiting limited number of iterations. * * @param sleepDur Sleep duration in milliseconds. * @param i Integer to increment. * @return Incremented value. * @throws org.apache.ignite.internal.IgniteInterruptedCheckedException If sleep was interrupted. */ public static int sleepAndIncrement(int sleepDur, int i) throws IgniteInterruptedCheckedException { U.sleep(sleepDur); return i + 1; } /** * Waits for condition, polling in busy wait loop. * * @param cond Condition to wait for. * @param timeout Max time to wait in milliseconds. * @return {@code true} if condition was achieved, {@code false} otherwise. * @throws org.apache.ignite.internal.IgniteInterruptedCheckedException If interrupted. */ public static boolean waitForCondition(GridAbsPredicate cond, long timeout) throws IgniteInterruptedCheckedException { long curTime = U.currentTimeMillis(); long endTime = curTime + timeout; if (endTime < 0) endTime = Long.MAX_VALUE; while (curTime < endTime) { if (cond.apply()) return true; U.sleep(DFLT_BUSYWAIT_SLEEP_INTERVAL); curTime = U.currentTimeMillis(); } return false; } /** * Creates an SSL context from test key store with disabled trust manager. * * @return Initialized context. * @throws GeneralSecurityException In case if context could not be initialized. * @throws IOException If keystore cannot be accessed. */ public static SSLContext sslContext() throws GeneralSecurityException, IOException { SSLContext ctx = SSLContext.getInstance("TLS"); char[] storePass = keyStorePassword().toCharArray(); KeyManagerFactory keyMgrFactory = KeyManagerFactory.getInstance("SunX509"); KeyStore keyStore = KeyStore.getInstance("JKS"); keyStore.load(new FileInputStream(U.resolveIgnitePath(GridTestProperties.getProperty("ssl.keystore.path"))), storePass); keyMgrFactory.init(keyStore, storePass); ctx.init(keyMgrFactory.getKeyManagers(), new TrustManager[]{GridSslBasicContextFactory.getDisabledTrustManager()}, null); return ctx; } /** * Creates test-purposed SSL context factory from test key store with disabled trust manager. * * @return SSL context factory used in test. */ public static GridSslContextFactory sslContextFactory() { GridSslBasicContextFactory factory = new GridSslBasicContextFactory(); factory.setKeyStoreFilePath( U.resolveIgnitePath(GridTestProperties.getProperty("ssl.keystore.path")).getAbsolutePath()); factory.setKeyStorePassword(keyStorePassword().toCharArray()); factory.setTrustManagers(GridSslBasicContextFactory.getDisabledTrustManager()); return factory; } /** * Creates test-purposed SSL context factory from test key store with disabled trust manager. * * @return SSL context factory used in test. */ public static Factory<SSLContext> sslFactory() { SslContextFactory factory = new SslContextFactory(); factory.setKeyStoreFilePath( U.resolveIgnitePath(GridTestProperties.getProperty("ssl.keystore.path")).getAbsolutePath()); factory.setKeyStorePassword(keyStorePassword().toCharArray()); factory.setTrustManagers(SslContextFactory.getDisabledTrustManager()); return factory; } /** * Creates test-purposed SSL context factory from specified key store and trust store. * * @param keyStore Key store name. * @param trustStore Trust store name. * @return SSL context factory used in test. */ public static Factory<SSLContext> sslTrustedFactory(String keyStore, String trustStore) { SslContextFactory factory = new SslContextFactory(); factory.setKeyStoreFilePath(keyStorePath(keyStore)); factory.setKeyStorePassword(keyStorePassword().toCharArray()); factory.setTrustStoreFilePath(keyStorePath(trustStore)); factory.setTrustStorePassword(keyStorePassword().toCharArray()); return factory; } public static String keyStorePassword() { return GridTestProperties.getProperty("ssl.keystore.password"); } @NotNull public static String keyStorePath(String keyStore) { return U.resolveIgnitePath(GridTestProperties.getProperty( "ssl.keystore." + keyStore + ".path")).getAbsolutePath(); } /** * @param o1 Object 1. * @param o2 Object 2. * @return Equals or not. */ public static boolean deepEquals(@Nullable Object o1, @Nullable Object o2) { if (o1 == o2) return true; else if (o1 == null || o2 == null) return false; else if (o1.getClass() != o2.getClass()) return false; else { Class<?> cls = o1.getClass(); assert o2.getClass() == cls; for (Field f : cls.getDeclaredFields()) { f.setAccessible(true); Object v1; Object v2; try { v1 = f.get(o1); v2 = f.get(o2); } catch (IllegalAccessException e) { throw new AssertionError(e); } if (!Objects.deepEquals(v1, v2)) return false; } return true; } } /** * Converts integer permission mode into set of {@link PosixFilePermission}. * * @param mode File mode. * @return Set of {@link PosixFilePermission}. */ public static Set<PosixFilePermission> modeToPermissionSet(int mode) { Set<PosixFilePermission> res = EnumSet.noneOf(PosixFilePermission.class); if ((mode & 0400) > 0) res.add(PosixFilePermission.OWNER_READ); if ((mode & 0200) > 0) res.add(PosixFilePermission.OWNER_WRITE); if ((mode & 0100) > 0) res.add(PosixFilePermission.OWNER_EXECUTE); if ((mode & 040) > 0) res.add(PosixFilePermission.GROUP_READ); if ((mode & 020) > 0) res.add(PosixFilePermission.GROUP_WRITE); if ((mode & 010) > 0) res.add(PosixFilePermission.GROUP_EXECUTE); if ((mode & 04) > 0) res.add(PosixFilePermission.OTHERS_READ); if ((mode & 02) > 0) res.add(PosixFilePermission.OTHERS_WRITE); if ((mode & 01) > 0) res.add(PosixFilePermission.OTHERS_EXECUTE); return res; } /** * @param name Name. * @param run Run. */ public static void benchmark(@Nullable String name, @NotNull Runnable run) { benchmark(name, 8000, 10000, run); } /** * @param name Name. * @param warmup Warmup. * @param executionTime Time. * @param run Run. */ public static void benchmark(@Nullable String name, long warmup, long executionTime, @NotNull Runnable run) { final AtomicBoolean stop = new AtomicBoolean(); class Stopper extends TimerTask { @Override public void run() { stop.set(true); } } new Timer(true).schedule(new Stopper(), warmup); while (!stop.get()) run.run(); stop.set(false); new Timer(true).schedule(new Stopper(), executionTime); long startTime = System.currentTimeMillis(); int cnt = 0; do { run.run(); cnt++; } while (!stop.get()); double dur = (System.currentTimeMillis() - startTime) / 1000d; System.out.printf("%s:\n operations:%d, duration=%fs, op/s=%d, latency=%fms\n", name, cnt, dur, (long)(cnt / dur), dur / cnt); } /** * Prompt to execute garbage collector. * {@code System.gc();} is not guaranteed to garbage collection, this method try to fill memory to crowd out dead * objects. */ public static void runGC() { System.gc(); ReferenceQueue<byte[]> queue = new ReferenceQueue<>(); Collection<SoftReference<byte[]>> refs = new ArrayList<>(); while (true) { byte[] bytes = new byte[128 * 1024]; refs.add(new SoftReference<>(bytes, queue)); if (queue.poll() != null) break; } System.gc(); } /** * @return Path to apache ignite. */ public static String apacheIgniteTestPath() { return System.getProperty("IGNITE_TEST_PATH", U.getIgniteHome() + "/target/ignite"); } /** * {@link Class#getSimpleName()} does not return outer class name prefix for inner classes, for example, * getSimpleName() returns "RegularDiscovery" instead of "GridDiscoveryManagerSelfTest$RegularDiscovery" * This method return correct simple name for inner classes. * * @param cls Class * @return Simple name with outer class prefix. */ public static String fullSimpleName(@NotNull Class cls) { if (cls.getEnclosingClass() != null) return cls.getEnclosingClass().getSimpleName() + "." + cls.getSimpleName(); else return cls.getSimpleName(); } /** * Adds test class to the list only if it's not in {@code ignoredTests} set. * * @param suite List where to place the test class. * @param test Test. * @param ignoredTests Tests to ignore. If test contained in the collection it is not included in suite */ public static void addTestIfNeeded(@NotNull final List<Class<?>> suite, @NotNull final Class<?> test, @Nullable final Collection<Class> ignoredTests) { if (ignoredTests != null && ignoredTests.contains(test)) return; suite.add(test); } /** * Generate random alphabetical string. * * @param rnd Random object. * @param maxLen Maximal length of string * @return Random string object. */ public static String randomString(Random rnd, int maxLen) { int len = rnd.nextInt(maxLen); StringBuilder b = new StringBuilder(len); for (int i = 0; i < len; i++) b.append(ALPHABETH.charAt(rnd.nextInt(ALPHABETH.length()))); return b.toString(); } /** * @param node Node. * @param topVer Ready exchange version to wait for before trying to merge exchanges. */ public static void mergeExchangeWaitVersion(Ignite node, long topVer) { ((IgniteEx)node).context().cache().context().exchange().mergeExchangesTestWaitVersion( new AffinityTopologyVersion(topVer, 0), null); } /** * @param node Node. * @param topVer Ready exchange version to wait for before trying to merge exchanges. */ public static void mergeExchangeWaitVersion(Ignite node, long topVer, List mergedEvts) { ((IgniteEx)node).context().cache().context().exchange().mergeExchangesTestWaitVersion( new AffinityTopologyVersion(topVer, 0), mergedEvts); } /** Test parameters scale factor util. */ private static class ScaleFactorUtil { /** Test speed scale factor property name. */ private static final String TEST_SCALE_FACTOR_PROPERTY = "TEST_SCALE_FACTOR"; /** Min test scale factor value. */ private static final double MIN_TEST_SCALE_FACTOR_VALUE = 0.1; /** Max test scale factor value. */ private static final double MAX_TEST_SCALE_FACTOR_VALUE = 1.0; /** Test speed scale factor. */ private static final double TEST_SCALE_FACTOR_VALUE = readScaleFactor(); /** */ private static double readScaleFactor() { double scaleFactor = Double.parseDouble(System.getProperty(TEST_SCALE_FACTOR_PROPERTY, "1.0")); scaleFactor = Math.max(scaleFactor, MIN_TEST_SCALE_FACTOR_VALUE); scaleFactor = Math.min(scaleFactor, MAX_TEST_SCALE_FACTOR_VALUE); return scaleFactor; } /** */ public static int apply(int val) { return (int)Math.round(TEST_SCALE_FACTOR_VALUE * val); } /** */ public static int apply(int val, int lowerBound, int upperBound) { return applyUB(applyLB(val, lowerBound), upperBound); } /** Apply scale factor with lower bound */ public static int applyLB(int val, int lowerBound) { return Math.max(apply(val), lowerBound); } /** Apply scale factor with upper bound */ public static int applyUB(int val, int upperBound) { return Math.min(apply(val), upperBound); } } /** * @param node Node to connect to. * @param params Connection parameters. * @return Thin JDBC connection to specified node. */ public static Connection connect(IgniteEx node, String params) throws SQLException { Collection<GridPortRecord> recs = node.context().ports().records(); GridPortRecord cliLsnrRec = null; for (GridPortRecord rec : recs) { if (rec.clazz() == ClientListenerProcessor.class) { cliLsnrRec = rec; break; } } assertNotNull(cliLsnrRec); String connStr = "jdbc:ignite:thin://127.0.0.1:" + cliLsnrRec.port(); if (!F.isEmpty(params)) connStr += "/?" + params; return DriverManager.getConnection(connStr); } /** * Removes idle_verify log files created in tests. */ public static void cleanIdleVerifyLogFiles() { File dir = new File("."); for (File f : dir.listFiles(n -> n.getName().startsWith(IdleVerifyResultV2.IDLE_VERIFY_FILE_PREFIX))) f.delete(); } public static class SqlTestFunctions { /** Sleep milliseconds. */ public static volatile long sleepMs; /** Fail flag. */ public static volatile boolean fail; /** * Do sleep {@code sleepMs} milliseconds * * @return amount of milliseconds to sleep */ @QuerySqlFunction @SuppressWarnings("BusyWait") public static long sleep() { long end = System.currentTimeMillis() + sleepMs; long remainTime =sleepMs; do { try { Thread.sleep(remainTime); } catch (InterruptedException ignored) { // No-op } } while ((remainTime = end - System.currentTimeMillis()) > 0); return sleepMs; } /** * Function do fail in case of {@code fail} is true, return 0 otherwise. * * @return in case of {@code fail} is false return 0, fail otherwise. */ @QuerySqlFunction public static int can_fail() { if (fail) throw new IllegalArgumentException(); else return 0; } /** * Function do sleep {@code sleepMs} milliseconds and do fail in case of {@code fail} is true, return 0 otherwise. * * @return amount of milliseconds to sleep in case of {@code fail} is false, fail otherwise. */ @QuerySqlFunction public static long sleep_and_can_fail() { long sleep = sleep(); can_fail(); return sleep; } } /** * Runnable that can throw exceptions. */ @FunctionalInterface public interface RunnableX extends Runnable { /** * Runnable body. * * @throws Exception If failed. */ void runx() throws Exception; /** {@inheritdoc} */ @Override default void run() { try { runx(); } catch (Exception e) { throw new IgniteException(e); } } } /** * IgniteRunnable that can throw exceptions. */ @FunctionalInterface public interface IgniteRunnableX extends IgniteRunnable { /** * Runnable body. * * @throws Exception If failed. */ void runx() throws Exception; /** {@inheritdoc} */ @Override default void run() { try { runx(); } catch (Exception e) { throw new IgniteException(e); } } } }
[ "\"IGNITE_HOME\"" ]
[]
[ "IGNITE_HOME" ]
[]
["IGNITE_HOME"]
java
1
0
network/proxy/mucp/mucp.go
// Package mucp transparently forwards the incoming request using a go-micro client. package mucp import ( "context" "io" "os" "strings" "sync" "github.com/micro/go-micro/client" "github.com/micro/go-micro/client/selector" "github.com/micro/go-micro/codec" "github.com/micro/go-micro/codec/bytes" "github.com/micro/go-micro/config/options" "github.com/micro/go-micro/network/proxy" "github.com/micro/go-micro/network/router" "github.com/micro/go-micro/server" pb "github.com/micro/go-micro/network/router/proto" ) // Proxy will transparently proxy requests to an endpoint. // If no endpoint is specified it will call a service using the client. type Proxy struct { // embed options options.Options // Endpoint specified the fixed service endpoint to call. Endpoint string // The client to use for outbound requests Client client.Client // The router for routes Router router.Router // The router service client RouterService pb.RouterService // A fib of routes service:address sync.RWMutex Routes map[string][]router.Route } // read client request and write to server func readLoop(r server.Request, s client.Stream) error { // request to backend server req := s.Request() for { // get data from client // no need to decode it body, err := r.Read() if err == io.EOF { return nil } if err != nil { return err } // get the header from client hdr := r.Header() msg := &codec.Message{ Type: codec.Request, Header: hdr, Body: body, } // write the raw request err = req.Codec().Write(msg, nil) if err == io.EOF { return nil } else if err != nil { return err } } } func (p *Proxy) getRoute(service string) ([]string, error) { // converts routes to just addresses toNodes := func(routes []router.Route) []string { var nodes []string for _, node := range routes { nodes = append(nodes, node.Gateway) } return nodes } // lookup the route cache first p.RLock() routes, ok := p.Routes[service] // got it! if ok { p.RUnlock() return toNodes(routes), nil } p.RUnlock() // route cache miss, now lookup the router // if it does not exist, don't error out // the proxy will just hand off to the client // and try the registry // in future we might set a default gateway if p.Router != nil { // lookup the router routes, err := p.Router.Table().Lookup( router.NewQuery(router.QueryDestination(service)), ) if err != nil { return nil, err } p.Lock() if p.Routes == nil { p.Routes = make(map[string][]router.Route) } p.Routes[service] = routes p.Unlock() return toNodes(routes), nil } // we've tried getting cached routes // we've tried using the router addr := os.Getenv("MICRO_ROUTER_ADDRESS") name := os.Getenv("MICRO_ROUTER") // no router is specified we're going to set the default if len(name) == 0 && len(addr) == 0 { p.Router = router.DefaultRouter go p.Router.Advertise() // recursively execute getRoute return p.getRoute(service) } if len(name) == 0 { name = "go.micro.router" } // lookup the remote router var addrs []string // set the remote address if specified if len(addr) > 0 { addrs = append(addrs, addr) } else { // we have a name so we need to check the registry services, err := p.Client.Options().Registry.GetService(name) if err != nil { return nil, err } for _, service := range services { for _, node := range service.Nodes { addrs = append(addrs, node.Address) } } } // no router addresses available if len(addrs) == 0 { return nil, selector.ErrNoneAvailable } var pbRoutes *pb.LookupResponse var gerr error // set default client if p.RouterService == nil { p.RouterService = pb.NewRouterService(name, p.Client) } // TODO: implement backoff and retries for _, addr := range addrs { // call the router proutes, err := p.RouterService.Lookup(context.Background(), &pb.LookupRequest{ Query: &pb.Query{ Destination: service, }, }, client.WithAddress(addr)) if err != nil { gerr = err continue } // set routes pbRoutes = proutes break } // errored out if gerr != nil { return nil, gerr } // no routes if pbRoutes == nil { return nil, selector.ErrNoneAvailable } // convert from pb to []*router.Route for _, r := range pbRoutes.Routes { routes = append(routes, router.Route{ Destination: r.Destination, Gateway: r.Gateway, Router: r.Router, Network: r.Network, Metric: int(r.Metric), }) } return toNodes(routes), nil } // ServeRequest honours the server.Router interface func (p *Proxy) ServeRequest(ctx context.Context, req server.Request, rsp server.Response) error { // set default client if p.Client == nil { p.Client = client.DefaultClient } // service name service := req.Service() endpoint := req.Endpoint() var addresses []string // call a specific backend endpoint either by name or address if len(p.Endpoint) > 0 { // address:port if parts := strings.Split(p.Endpoint, ":"); len(parts) > 1 { addresses = []string{p.Endpoint} } else { // get route for endpoint from router addr, err := p.getRoute(p.Endpoint) if err != nil { return err } // set the address addresses = addr // set the name service = p.Endpoint } } else { // no endpoint was specified just lookup the route // get route for endpoint from router addr, err := p.getRoute(service) if err != nil { return err } addresses = addr } var opts []client.CallOption // set address if available if len(addresses) > 0 { opts = append(opts, client.WithAddress(addresses...)) } // read initial request body, err := req.Read() if err != nil { return err } // create new request with raw bytes body creq := p.Client.NewRequest(service, endpoint, &bytes.Frame{body}, client.WithContentType(req.ContentType())) // create new stream stream, err := p.Client.Stream(ctx, creq, opts...) if err != nil { return err } defer stream.Close() // create client request read loop go readLoop(req, stream) // get raw response resp := stream.Response() // create server response write loop for { // read backend response body body, err := resp.Read() if err == io.EOF { return nil } else if err != nil { return err } // read backend response header hdr := resp.Header() // write raw response header to client rsp.WriteHeader(hdr) // write raw response body to client err = rsp.Write(body) if err == io.EOF { return nil } else if err != nil { return err } } return nil } // NewSingleHostProxy returns a proxy which sends requests to a single backend func NewSingleHostProxy(endpoint string) *Proxy { return &Proxy{ Options: options.NewOptions(), Endpoint: endpoint, } } // NewProxy returns a new proxy which will route based on mucp headers func NewProxy(opts ...options.Option) proxy.Proxy { p := new(Proxy) p.Options = options.NewOptions(opts...) p.Options.Init(options.WithString("mucp")) // get endpoint ep, ok := p.Options.Values().Get("proxy.endpoint") if ok { p.Endpoint = ep.(string) } // get client c, ok := p.Options.Values().Get("proxy.client") if ok { p.Client = c.(client.Client) } // get router r, ok := p.Options.Values().Get("proxy.router") if ok { p.Router = r.(router.Router) // TODO: should we advertise? go p.Router.Advertise() } return p }
[ "\"MICRO_ROUTER_ADDRESS\"", "\"MICRO_ROUTER\"" ]
[]
[ "MICRO_ROUTER", "MICRO_ROUTER_ADDRESS" ]
[]
["MICRO_ROUTER", "MICRO_ROUTER_ADDRESS"]
go
2
0
pkg/server/web/config.go
// Copyright 2014 beego Author. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package web import ( context2 "context" "crypto/tls" "fmt" "os" "path/filepath" "reflect" "runtime" "strings" "github.com/flycash/beego-web/pkg" "github.com/flycash/beego-web/pkg/infrastructure/config" "github.com/flycash/beego-web/pkg/infrastructure/logs" "github.com/flycash/beego-web/pkg/infrastructure/session" "github.com/flycash/beego-web/pkg/infrastructure/utils" "github.com/flycash/beego-web/pkg/server/web/context" ) // Config is the main struct for BConfig // TODO after supporting multiple servers, remove common config to somewhere else type Config struct { AppName string // Application name RunMode string // Running Mode: dev | prod RouterCaseSensitive bool ServerName string RecoverPanic bool RecoverFunc func(*context.Context, *Config) CopyRequestBody bool EnableGzip bool MaxMemory int64 EnableErrorsShow bool EnableErrorsRender bool Listen Listen WebConfig WebConfig Log LogConfig } // Listen holds for http and https related config type Listen struct { Graceful bool // Graceful means use graceful module to start the server ServerTimeOut int64 ListenTCP4 bool EnableHTTP bool HTTPAddr string HTTPPort int AutoTLS bool Domains []string TLSCacheDir string EnableHTTPS bool EnableMutualHTTPS bool HTTPSAddr string HTTPSPort int HTTPSCertFile string HTTPSKeyFile string TrustCaFile string EnableAdmin bool AdminAddr string AdminPort int EnableFcgi bool EnableStdIo bool // EnableStdIo works with EnableFcgi Use FCGI via standard I/O ClientAuth int } // WebConfig holds web related config type WebConfig struct { AutoRender bool EnableDocs bool FlashName string FlashSeparator string DirectoryIndex bool StaticDir map[string]string StaticExtensionsToGzip []string StaticCacheFileSize int StaticCacheFileNum int TemplateLeft string TemplateRight string ViewsPath string CommentRouterPath string EnableXSRF bool XSRFKey string XSRFExpire int Session SessionConfig } // SessionConfig holds session related config type SessionConfig struct { SessionOn bool SessionProvider string SessionName string SessionGCMaxLifetime int64 SessionProviderConfig string SessionCookieLifeTime int SessionAutoSetCookie bool SessionDomain string SessionDisableHTTPOnly bool // used to allow for cross domain cookies/javascript cookies. SessionEnableSidInHTTPHeader bool // enable store/get the sessionId into/from http headers SessionNameInHTTPHeader string SessionEnableSidInURLQuery bool // enable get the sessionId from Url Query params } // LogConfig holds Log related config type LogConfig struct { AccessLogs bool EnableStaticLogs bool // log static files requests default: false AccessLogsFormat string // access log format: JSON_FORMAT, APACHE_FORMAT or empty string FileLineNum bool Outputs map[string]string // Store Adaptor : config } var ( // BConfig is the default config for Application BConfig *Config // AppConfig is the instance of Config, store the config information from file AppConfig *beegoAppConfig // AppPath is the absolute path to the app AppPath string // GlobalSessions is the instance for the session manager GlobalSessions *session.Manager // appConfigPath is the path to the config files appConfigPath string // appConfigProvider is the provider for the config, default is ini appConfigProvider = "ini" // WorkPath is the absolute path to project root directory WorkPath string ) func init() { BConfig = newBConfig() var err error if AppPath, err = filepath.Abs(filepath.Dir(os.Args[0])); err != nil { panic(err) } WorkPath, err = os.Getwd() if err != nil { panic(err) } var filename = "app.conf" if os.Getenv("BEEGO_RUNMODE") != "" { filename = os.Getenv("BEEGO_RUNMODE") + ".app.conf" } appConfigPath = filepath.Join(WorkPath, "conf", filename) if !utils.FileExists(appConfigPath) { appConfigPath = filepath.Join(AppPath, "conf", filename) if !utils.FileExists(appConfigPath) { AppConfig = &beegoAppConfig{innerConfig: config.NewFakeConfig()} return } } if err = parseConfig(appConfigPath); err != nil { panic(err) } } func defaultRecoverPanic(ctx *context.Context, cfg *Config) { if err := recover(); err != nil { if err == ErrAbort { return } if !cfg.RecoverPanic { panic(err) } if cfg.EnableErrorsShow { if _, ok := ErrorMaps[fmt.Sprint(err)]; ok { exception(fmt.Sprint(err), ctx) return } } var stack string logs.Critical("the request url is ", ctx.Input.URL()) logs.Critical("Handler crashed with error", err) for i := 1; ; i++ { _, file, line, ok := runtime.Caller(i) if !ok { break } logs.Critical(fmt.Sprintf("%s:%d", file, line)) stack = stack + fmt.Sprintln(fmt.Sprintf("%s:%d", file, line)) } if cfg.RunMode == DEV && cfg.EnableErrorsRender { showErr(err, ctx, stack) } if ctx.Output.Status != 0 { ctx.ResponseWriter.WriteHeader(ctx.Output.Status) } else { ctx.ResponseWriter.WriteHeader(500) } } } func newBConfig() *Config { res := &Config{ AppName: "beego", RunMode: PROD, RouterCaseSensitive: true, ServerName: "beegoServer:" + pkg.VERSION, RecoverPanic: true, CopyRequestBody: false, EnableGzip: false, MaxMemory: 1 << 26, // 64MB EnableErrorsShow: true, EnableErrorsRender: true, Listen: Listen{ Graceful: false, ServerTimeOut: 0, ListenTCP4: false, EnableHTTP: true, AutoTLS: false, Domains: []string{}, TLSCacheDir: ".", HTTPAddr: "", HTTPPort: 8080, EnableHTTPS: false, HTTPSAddr: "", HTTPSPort: 10443, HTTPSCertFile: "", HTTPSKeyFile: "", EnableAdmin: false, AdminAddr: "", AdminPort: 8088, EnableFcgi: false, EnableStdIo: false, ClientAuth: int(tls.RequireAndVerifyClientCert), }, WebConfig: WebConfig{ AutoRender: true, EnableDocs: false, FlashName: "BEEGO_FLASH", FlashSeparator: "BEEGOFLASH", DirectoryIndex: false, StaticDir: map[string]string{"/static": "static"}, StaticExtensionsToGzip: []string{".css", ".js"}, StaticCacheFileSize: 1024 * 100, StaticCacheFileNum: 1000, TemplateLeft: "{{", TemplateRight: "}}", ViewsPath: "views", CommentRouterPath: "controllers", EnableXSRF: false, XSRFKey: "beegoxsrf", XSRFExpire: 0, Session: SessionConfig{ SessionOn: false, SessionProvider: "memory", SessionName: "beegosessionID", SessionGCMaxLifetime: 3600, SessionProviderConfig: "", SessionDisableHTTPOnly: false, SessionCookieLifeTime: 0, // set cookie default is the browser life SessionAutoSetCookie: true, SessionDomain: "", SessionEnableSidInHTTPHeader: false, // enable store/get the sessionId into/from http headers SessionNameInHTTPHeader: "Beegosessionid", SessionEnableSidInURLQuery: false, // enable get the sessionId from Url Query params }, }, Log: LogConfig{ AccessLogs: false, EnableStaticLogs: false, AccessLogsFormat: "APACHE_FORMAT", FileLineNum: true, Outputs: map[string]string{"console": ""}, }, } res.RecoverFunc = defaultRecoverPanic return res } // now only support ini, next will support json. func parseConfig(appConfigPath string) (err error) { AppConfig, err = newAppConfig(appConfigProvider, appConfigPath) if err != nil { return err } return assignConfig(AppConfig) } func assignConfig(ac config.Configer) error { for _, i := range []interface{}{BConfig, &BConfig.Listen, &BConfig.WebConfig, &BConfig.Log, &BConfig.WebConfig.Session} { assignSingleConfig(i, ac) } // set the run mode first if envRunMode := os.Getenv("BEEGO_RUNMODE"); envRunMode != "" { BConfig.RunMode = envRunMode } else if runMode, err := ac.String(nil, "RunMode"); runMode != "" && err == nil { BConfig.RunMode = runMode } if sd, err := ac.String(nil, "StaticDir"); sd != "" && err == nil { BConfig.WebConfig.StaticDir = map[string]string{} sds := strings.Fields(sd) for _, v := range sds { if url2fsmap := strings.SplitN(v, ":", 2); len(url2fsmap) == 2 { BConfig.WebConfig.StaticDir["/"+strings.Trim(url2fsmap[0], "/")] = url2fsmap[1] } else { BConfig.WebConfig.StaticDir["/"+strings.Trim(url2fsmap[0], "/")] = url2fsmap[0] } } } if sgz, err := ac.String(nil, "StaticExtensionsToGzip"); sgz != "" && err == nil { extensions := strings.Split(sgz, ",") fileExts := []string{} for _, ext := range extensions { ext = strings.TrimSpace(ext) if ext == "" { continue } if !strings.HasPrefix(ext, ".") { ext = "." + ext } fileExts = append(fileExts, ext) } if len(fileExts) > 0 { BConfig.WebConfig.StaticExtensionsToGzip = fileExts } } if sfs, err := ac.Int(nil, "StaticCacheFileSize"); err == nil { BConfig.WebConfig.StaticCacheFileSize = sfs } if sfn, err := ac.Int(nil, "StaticCacheFileNum"); err == nil { BConfig.WebConfig.StaticCacheFileNum = sfn } if lo, err := ac.String(nil, "LogOutputs"); lo != "" && err == nil { // if lo is not nil or empty // means user has set his own LogOutputs // clear the default setting to BConfig.Log.Outputs BConfig.Log.Outputs = make(map[string]string) los := strings.Split(lo, ";") for _, v := range los { if logType2Config := strings.SplitN(v, ",", 2); len(logType2Config) == 2 { BConfig.Log.Outputs[logType2Config[0]] = logType2Config[1] } else { continue } } } // init log logs.Reset() for adaptor, config := range BConfig.Log.Outputs { err := logs.SetLogger(adaptor, config) if err != nil { fmt.Fprintln(os.Stderr, fmt.Sprintf("%s with the config %q got err:%s", adaptor, config, err.Error())) } } logs.SetLogFuncCall(BConfig.Log.FileLineNum) return nil } func assignSingleConfig(p interface{}, ac config.Configer) { pt := reflect.TypeOf(p) if pt.Kind() != reflect.Ptr { return } pt = pt.Elem() if pt.Kind() != reflect.Struct { return } pv := reflect.ValueOf(p).Elem() for i := 0; i < pt.NumField(); i++ { pf := pv.Field(i) if !pf.CanSet() { continue } name := pt.Field(i).Name switch pf.Kind() { case reflect.String: pf.SetString(ac.DefaultString(nil, name, pf.String())) case reflect.Int, reflect.Int64: pf.SetInt(ac.DefaultInt64(nil, name, pf.Int())) case reflect.Bool: pf.SetBool(ac.DefaultBool(nil, name, pf.Bool())) case reflect.Struct: default: // do nothing here } } } // LoadAppConfig allow developer to apply a config file func LoadAppConfig(adapterName, configPath string) error { absConfigPath, err := filepath.Abs(configPath) if err != nil { return err } if !utils.FileExists(absConfigPath) { return fmt.Errorf("the target config file: %s don't exist", configPath) } appConfigPath = absConfigPath appConfigProvider = adapterName return parseConfig(appConfigPath) } type beegoAppConfig struct { config.BaseConfiger innerConfig config.Configer } func newAppConfig(appConfigProvider, appConfigPath string) (*beegoAppConfig, error) { ac, err := config.NewConfig(appConfigProvider, appConfigPath) if err != nil { return nil, err } return &beegoAppConfig{innerConfig: ac}, nil } func (b *beegoAppConfig) Set(ctx context2.Context, key, val string) error { if err := b.innerConfig.Set(nil, BConfig.RunMode+"::"+key, val); err != nil { return b.innerConfig.Set(nil, key, val) } return nil } func (b *beegoAppConfig) String(ctx context2.Context, key string) (string, error) { if v, err := b.innerConfig.String(nil, BConfig.RunMode+"::"+key); v != "" && err == nil { return v, nil } return b.innerConfig.String(nil, key) } func (b *beegoAppConfig) Strings(ctx context2.Context, key string) ([]string, error) { if v, err := b.innerConfig.Strings(nil, BConfig.RunMode+"::"+key); len(v) > 0 && err == nil { return v, nil } return b.innerConfig.Strings(nil, key) } func (b *beegoAppConfig) Int(ctx context2.Context, key string) (int, error) { if v, err := b.innerConfig.Int(nil, BConfig.RunMode+"::"+key); err == nil { return v, nil } return b.innerConfig.Int(nil, key) } func (b *beegoAppConfig) Int64(ctx context2.Context, key string) (int64, error) { if v, err := b.innerConfig.Int64(nil, BConfig.RunMode+"::"+key); err == nil { return v, nil } return b.innerConfig.Int64(nil, key) } func (b *beegoAppConfig) Bool(ctx context2.Context, key string) (bool, error) { if v, err := b.innerConfig.Bool(nil, BConfig.RunMode+"::"+key); err == nil { return v, nil } return b.innerConfig.Bool(nil, key) } func (b *beegoAppConfig) Float(ctx context2.Context, key string) (float64, error) { if v, err := b.innerConfig.Float(nil, BConfig.RunMode+"::"+key); err == nil { return v, nil } return b.innerConfig.Float(nil, key) } func (b *beegoAppConfig) DefaultString(ctx context2.Context, key string, defaultVal string) string { if v, err := b.String(nil, key); v != "" && err == nil { return v } return defaultVal } func (b *beegoAppConfig) DefaultStrings(ctx context2.Context, key string, defaultVal []string) []string { if v, err := b.Strings(ctx, key); len(v) != 0 && err == nil { return v } return defaultVal } func (b *beegoAppConfig) DefaultInt(ctx context2.Context, key string, defaultVal int) int { if v, err := b.Int(ctx, key); err == nil { return v } return defaultVal } func (b *beegoAppConfig) DefaultInt64(ctx context2.Context, key string, defaultVal int64) int64 { if v, err := b.Int64(ctx, key); err == nil { return v } return defaultVal } func (b *beegoAppConfig) DefaultBool(ctx context2.Context, key string, defaultVal bool) bool { if v, err := b.Bool(ctx, key); err == nil { return v } return defaultVal } func (b *beegoAppConfig) DefaultFloat(ctx context2.Context, key string, defaultVal float64) float64 { if v, err := b.Float(ctx, key); err == nil { return v } return defaultVal } func (b *beegoAppConfig) DIY(ctx context2.Context, key string) (interface{}, error) { return b.innerConfig.DIY(nil, key) } func (b *beegoAppConfig) GetSection(ctx context2.Context, section string) (map[string]string, error) { return b.innerConfig.GetSection(nil, section) } func (b *beegoAppConfig) SaveConfigFile(ctx context2.Context, filename string) error { return b.innerConfig.SaveConfigFile(nil, filename) }
[ "\"BEEGO_RUNMODE\"", "\"BEEGO_RUNMODE\"", "\"BEEGO_RUNMODE\"" ]
[]
[ "BEEGO_RUNMODE" ]
[]
["BEEGO_RUNMODE"]
go
1
0
git-2.2.1/git-p4.py
#!/usr/bin/env python # # git-p4.py -- A tool for bidirectional operation between a Perforce depot and git. # # Author: Simon Hausmann <[email protected]> # Copyright: 2007 Simon Hausmann <[email protected]> # 2007 Trolltech ASA # License: MIT <http://www.opensource.org/licenses/mit-license.php> # import sys if sys.hexversion < 0x02040000: # The limiter is the subprocess module sys.stderr.write("git-p4: requires Python 2.4 or later.\n") sys.exit(1) import os import optparse import marshal import subprocess import tempfile import time import platform import re import shutil import stat try: from subprocess import CalledProcessError except ImportError: # from python2.7:subprocess.py # Exception classes used by this module. class CalledProcessError(Exception): """This exception is raised when a process run by check_call() returns a non-zero exit status. The exit status will be stored in the returncode attribute.""" def __init__(self, returncode, cmd): self.returncode = returncode self.cmd = cmd def __str__(self): return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode) verbose = False # Only labels/tags matching this will be imported/exported defaultLabelRegexp = r'[a-zA-Z0-9_\-.]+$' def p4_build_cmd(cmd): """Build a suitable p4 command line. This consolidates building and returning a p4 command line into one location. It means that hooking into the environment, or other configuration can be done more easily. """ real_cmd = ["p4"] user = gitConfig("git-p4.user") if len(user) > 0: real_cmd += ["-u",user] password = gitConfig("git-p4.password") if len(password) > 0: real_cmd += ["-P", password] port = gitConfig("git-p4.port") if len(port) > 0: real_cmd += ["-p", port] host = gitConfig("git-p4.host") if len(host) > 0: real_cmd += ["-H", host] client = gitConfig("git-p4.client") if len(client) > 0: real_cmd += ["-c", client] if isinstance(cmd,basestring): real_cmd = ' '.join(real_cmd) + ' ' + cmd else: real_cmd += cmd return real_cmd def chdir(path, is_client_path=False): """Do chdir to the given path, and set the PWD environment variable for use by P4. It does not look at getcwd() output. Since we're not using the shell, it is necessary to set the PWD environment variable explicitly. Normally, expand the path to force it to be absolute. This addresses the use of relative path names inside P4 settings, e.g. P4CONFIG=.p4config. P4 does not simply open the filename as given; it looks for .p4config using PWD. If is_client_path, the path was handed to us directly by p4, and may be a symbolic link. Do not call os.getcwd() in this case, because it will cause p4 to think that PWD is not inside the client path. """ os.chdir(path) if not is_client_path: path = os.getcwd() os.environ['PWD'] = path def die(msg): if verbose: raise Exception(msg) else: sys.stderr.write(msg + "\n") sys.exit(1) def write_pipe(c, stdin): if verbose: sys.stderr.write('Writing pipe: %s\n' % str(c)) expand = isinstance(c,basestring) p = subprocess.Popen(c, stdin=subprocess.PIPE, shell=expand) pipe = p.stdin val = pipe.write(stdin) pipe.close() if p.wait(): die('Command failed: %s' % str(c)) return val def p4_write_pipe(c, stdin): real_cmd = p4_build_cmd(c) return write_pipe(real_cmd, stdin) def read_pipe(c, ignore_error=False): if verbose: sys.stderr.write('Reading pipe: %s\n' % str(c)) expand = isinstance(c,basestring) p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand) pipe = p.stdout val = pipe.read() if p.wait() and not ignore_error: die('Command failed: %s' % str(c)) return val def p4_read_pipe(c, ignore_error=False): real_cmd = p4_build_cmd(c) return read_pipe(real_cmd, ignore_error) def read_pipe_lines(c): if verbose: sys.stderr.write('Reading pipe: %s\n' % str(c)) expand = isinstance(c, basestring) p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand) pipe = p.stdout val = pipe.readlines() if pipe.close() or p.wait(): die('Command failed: %s' % str(c)) return val def p4_read_pipe_lines(c): """Specifically invoke p4 on the command supplied. """ real_cmd = p4_build_cmd(c) return read_pipe_lines(real_cmd) def p4_has_command(cmd): """Ask p4 for help on this command. If it returns an error, the command does not exist in this version of p4.""" real_cmd = p4_build_cmd(["help", cmd]) p = subprocess.Popen(real_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) p.communicate() return p.returncode == 0 def p4_has_move_command(): """See if the move command exists, that it supports -k, and that it has not been administratively disabled. The arguments must be correct, but the filenames do not have to exist. Use ones with wildcards so even if they exist, it will fail.""" if not p4_has_command("move"): return False cmd = p4_build_cmd(["move", "-k", "@from", "@to"]) p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (out, err) = p.communicate() # return code will be 1 in either case if err.find("Invalid option") >= 0: return False if err.find("disabled") >= 0: return False # assume it failed because @... was invalid changelist return True def system(cmd): expand = isinstance(cmd,basestring) if verbose: sys.stderr.write("executing %s\n" % str(cmd)) retcode = subprocess.call(cmd, shell=expand) if retcode: raise CalledProcessError(retcode, cmd) def p4_system(cmd): """Specifically invoke p4 as the system command. """ real_cmd = p4_build_cmd(cmd) expand = isinstance(real_cmd, basestring) retcode = subprocess.call(real_cmd, shell=expand) if retcode: raise CalledProcessError(retcode, real_cmd) _p4_version_string = None def p4_version_string(): """Read the version string, showing just the last line, which hopefully is the interesting version bit. $ p4 -V Perforce - The Fast Software Configuration Management System. Copyright 1995-2011 Perforce Software. All rights reserved. Rev. P4/NTX86/2011.1/393975 (2011/12/16). """ global _p4_version_string if not _p4_version_string: a = p4_read_pipe_lines(["-V"]) _p4_version_string = a[-1].rstrip() return _p4_version_string def p4_integrate(src, dest): p4_system(["integrate", "-Dt", wildcard_encode(src), wildcard_encode(dest)]) def p4_sync(f, *options): p4_system(["sync"] + list(options) + [wildcard_encode(f)]) def p4_add(f): # forcibly add file names with wildcards if wildcard_present(f): p4_system(["add", "-f", f]) else: p4_system(["add", f]) def p4_delete(f): p4_system(["delete", wildcard_encode(f)]) def p4_edit(f): p4_system(["edit", wildcard_encode(f)]) def p4_revert(f): p4_system(["revert", wildcard_encode(f)]) def p4_reopen(type, f): p4_system(["reopen", "-t", type, wildcard_encode(f)]) def p4_move(src, dest): p4_system(["move", "-k", wildcard_encode(src), wildcard_encode(dest)]) def p4_describe(change): """Make sure it returns a valid result by checking for the presence of field "time". Return a dict of the results.""" ds = p4CmdList(["describe", "-s", str(change)]) if len(ds) != 1: die("p4 describe -s %d did not return 1 result: %s" % (change, str(ds))) d = ds[0] if "p4ExitCode" in d: die("p4 describe -s %d exited with %d: %s" % (change, d["p4ExitCode"], str(d))) if "code" in d: if d["code"] == "error": die("p4 describe -s %d returned error code: %s" % (change, str(d))) if "time" not in d: die("p4 describe -s %d returned no \"time\": %s" % (change, str(d))) return d # # Canonicalize the p4 type and return a tuple of the # base type, plus any modifiers. See "p4 help filetypes" # for a list and explanation. # def split_p4_type(p4type): p4_filetypes_historical = { "ctempobj": "binary+Sw", "ctext": "text+C", "cxtext": "text+Cx", "ktext": "text+k", "kxtext": "text+kx", "ltext": "text+F", "tempobj": "binary+FSw", "ubinary": "binary+F", "uresource": "resource+F", "uxbinary": "binary+Fx", "xbinary": "binary+x", "xltext": "text+Fx", "xtempobj": "binary+Swx", "xtext": "text+x", "xunicode": "unicode+x", "xutf16": "utf16+x", } if p4type in p4_filetypes_historical: p4type = p4_filetypes_historical[p4type] mods = "" s = p4type.split("+") base = s[0] mods = "" if len(s) > 1: mods = s[1] return (base, mods) # # return the raw p4 type of a file (text, text+ko, etc) # def p4_type(f): results = p4CmdList(["fstat", "-T", "headType", wildcard_encode(f)]) return results[0]['headType'] # # Given a type base and modifier, return a regexp matching # the keywords that can be expanded in the file # def p4_keywords_regexp_for_type(base, type_mods): if base in ("text", "unicode", "binary"): kwords = None if "ko" in type_mods: kwords = 'Id|Header' elif "k" in type_mods: kwords = 'Id|Header|Author|Date|DateTime|Change|File|Revision' else: return None pattern = r""" \$ # Starts with a dollar, followed by... (%s) # one of the keywords, followed by... (:[^$\n]+)? # possibly an old expansion, followed by... \$ # another dollar """ % kwords return pattern else: return None # # Given a file, return a regexp matching the possible # RCS keywords that will be expanded, or None for files # with kw expansion turned off. # def p4_keywords_regexp_for_file(file): if not os.path.exists(file): return None else: (type_base, type_mods) = split_p4_type(p4_type(file)) return p4_keywords_regexp_for_type(type_base, type_mods) def setP4ExecBit(file, mode): # Reopens an already open file and changes the execute bit to match # the execute bit setting in the passed in mode. p4Type = "+x" if not isModeExec(mode): p4Type = getP4OpenedType(file) p4Type = re.sub('^([cku]?)x(.*)', '\\1\\2', p4Type) p4Type = re.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type) if p4Type[-1] == "+": p4Type = p4Type[0:-1] p4_reopen(p4Type, file) def getP4OpenedType(file): # Returns the perforce file type for the given file. result = p4_read_pipe(["opened", wildcard_encode(file)]) match = re.match(".*\((.+)\)\r?$", result) if match: return match.group(1) else: die("Could not determine file type for %s (result: '%s')" % (file, result)) # Return the set of all p4 labels def getP4Labels(depotPaths): labels = set() if isinstance(depotPaths,basestring): depotPaths = [depotPaths] for l in p4CmdList(["labels"] + ["%s..." % p for p in depotPaths]): label = l['label'] labels.add(label) return labels # Return the set of all git tags def getGitTags(): gitTags = set() for line in read_pipe_lines(["git", "tag"]): tag = line.strip() gitTags.add(tag) return gitTags def diffTreePattern(): # This is a simple generator for the diff tree regex pattern. This could be # a class variable if this and parseDiffTreeEntry were a part of a class. pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)') while True: yield pattern def parseDiffTreeEntry(entry): """Parses a single diff tree entry into its component elements. See git-diff-tree(1) manpage for details about the format of the diff output. This method returns a dictionary with the following elements: src_mode - The mode of the source file dst_mode - The mode of the destination file src_sha1 - The sha1 for the source file dst_sha1 - The sha1 fr the destination file status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc) status_score - The score for the status (applicable for 'C' and 'R' statuses). This is None if there is no score. src - The path for the source file. dst - The path for the destination file. This is only present for copy or renames. If it is not present, this is None. If the pattern is not matched, None is returned.""" match = diffTreePattern().next().match(entry) if match: return { 'src_mode': match.group(1), 'dst_mode': match.group(2), 'src_sha1': match.group(3), 'dst_sha1': match.group(4), 'status': match.group(5), 'status_score': match.group(6), 'src': match.group(7), 'dst': match.group(10) } return None def isModeExec(mode): # Returns True if the given git mode represents an executable file, # otherwise False. return mode[-3:] == "755" def isModeExecChanged(src_mode, dst_mode): return isModeExec(src_mode) != isModeExec(dst_mode) def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None): if isinstance(cmd,basestring): cmd = "-G " + cmd expand = True else: cmd = ["-G"] + cmd expand = False cmd = p4_build_cmd(cmd) if verbose: sys.stderr.write("Opening pipe: %s\n" % str(cmd)) # Use a temporary file to avoid deadlocks without # subprocess.communicate(), which would put another copy # of stdout into memory. stdin_file = None if stdin is not None: stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode) if isinstance(stdin,basestring): stdin_file.write(stdin) else: for i in stdin: stdin_file.write(i + '\n') stdin_file.flush() stdin_file.seek(0) p4 = subprocess.Popen(cmd, shell=expand, stdin=stdin_file, stdout=subprocess.PIPE) result = [] try: while True: entry = marshal.load(p4.stdout) if cb is not None: cb(entry) else: result.append(entry) except EOFError: pass exitCode = p4.wait() if exitCode != 0: entry = {} entry["p4ExitCode"] = exitCode result.append(entry) return result def p4Cmd(cmd): list = p4CmdList(cmd) result = {} for entry in list: result.update(entry) return result; def p4Where(depotPath): if not depotPath.endswith("/"): depotPath += "/" depotPath = depotPath + "..." outputList = p4CmdList(["where", depotPath]) output = None for entry in outputList: if "depotFile" in entry: if entry["depotFile"] == depotPath: output = entry break elif "data" in entry: data = entry.get("data") space = data.find(" ") if data[:space] == depotPath: output = entry break if output == None: return "" if output["code"] == "error": return "" clientPath = "" if "path" in output: clientPath = output.get("path") elif "data" in output: data = output.get("data") lastSpace = data.rfind(" ") clientPath = data[lastSpace + 1:] if clientPath.endswith("..."): clientPath = clientPath[:-3] return clientPath def currentGitBranch(): return read_pipe("git name-rev HEAD").split(" ")[1].strip() def isValidGitDir(path): if (os.path.exists(path + "/HEAD") and os.path.exists(path + "/refs") and os.path.exists(path + "/objects")): return True; return False def parseRevision(ref): return read_pipe("git rev-parse %s" % ref).strip() def branchExists(ref): rev = read_pipe(["git", "rev-parse", "-q", "--verify", ref], ignore_error=True) return len(rev) > 0 def extractLogMessageFromGitCommit(commit): logMessage = "" ## fixme: title is first line of commit, not 1st paragraph. foundTitle = False for log in read_pipe_lines("git cat-file commit %s" % commit): if not foundTitle: if len(log) == 1: foundTitle = True continue logMessage += log return logMessage def extractSettingsGitLog(log): values = {} for line in log.split("\n"): line = line.strip() m = re.search (r"^ *\[git-p4: (.*)\]$", line) if not m: continue assignments = m.group(1).split (':') for a in assignments: vals = a.split ('=') key = vals[0].strip() val = ('='.join (vals[1:])).strip() if val.endswith ('\"') and val.startswith('"'): val = val[1:-1] values[key] = val paths = values.get("depot-paths") if not paths: paths = values.get("depot-path") if paths: values['depot-paths'] = paths.split(',') return values def gitBranchExists(branch): proc = subprocess.Popen(["git", "rev-parse", branch], stderr=subprocess.PIPE, stdout=subprocess.PIPE); return proc.wait() == 0; _gitConfig = {} def gitConfig(key): if not _gitConfig.has_key(key): cmd = [ "git", "config", key ] s = read_pipe(cmd, ignore_error=True) _gitConfig[key] = s.strip() return _gitConfig[key] def gitConfigBool(key): """Return a bool, using git config --bool. It is True only if the variable is set to true, and False if set to false or not present in the config.""" if not _gitConfig.has_key(key): cmd = [ "git", "config", "--bool", key ] s = read_pipe(cmd, ignore_error=True) v = s.strip() _gitConfig[key] = v == "true" return _gitConfig[key] def gitConfigList(key): if not _gitConfig.has_key(key): s = read_pipe(["git", "config", "--get-all", key], ignore_error=True) _gitConfig[key] = s.strip().split(os.linesep) return _gitConfig[key] def p4BranchesInGit(branchesAreInRemotes=True): """Find all the branches whose names start with "p4/", looking in remotes or heads as specified by the argument. Return a dictionary of { branch: revision } for each one found. The branch names are the short names, without any "p4/" prefix.""" branches = {} cmdline = "git rev-parse --symbolic " if branchesAreInRemotes: cmdline += "--remotes" else: cmdline += "--branches" for line in read_pipe_lines(cmdline): line = line.strip() # only import to p4/ if not line.startswith('p4/'): continue # special symbolic ref to p4/master if line == "p4/HEAD": continue # strip off p4/ prefix branch = line[len("p4/"):] branches[branch] = parseRevision(line) return branches def branch_exists(branch): """Make sure that the given ref name really exists.""" cmd = [ "git", "rev-parse", "--symbolic", "--verify", branch ] p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, _ = p.communicate() if p.returncode: return False # expect exactly one line of output: the branch name return out.rstrip() == branch def findUpstreamBranchPoint(head = "HEAD"): branches = p4BranchesInGit() # map from depot-path to branch name branchByDepotPath = {} for branch in branches.keys(): tip = branches[branch] log = extractLogMessageFromGitCommit(tip) settings = extractSettingsGitLog(log) if settings.has_key("depot-paths"): paths = ",".join(settings["depot-paths"]) branchByDepotPath[paths] = "remotes/p4/" + branch settings = None parent = 0 while parent < 65535: commit = head + "~%s" % parent log = extractLogMessageFromGitCommit(commit) settings = extractSettingsGitLog(log) if settings.has_key("depot-paths"): paths = ",".join(settings["depot-paths"]) if branchByDepotPath.has_key(paths): return [branchByDepotPath[paths], settings] parent = parent + 1 return ["", settings] def createOrUpdateBranchesFromOrigin(localRefPrefix = "refs/remotes/p4/", silent=True): if not silent: print ("Creating/updating branch(es) in %s based on origin branch(es)" % localRefPrefix) originPrefix = "origin/p4/" for line in read_pipe_lines("git rev-parse --symbolic --remotes"): line = line.strip() if (not line.startswith(originPrefix)) or line.endswith("HEAD"): continue headName = line[len(originPrefix):] remoteHead = localRefPrefix + headName originHead = line original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead)) if (not original.has_key('depot-paths') or not original.has_key('change')): continue update = False if not gitBranchExists(remoteHead): if verbose: print "creating %s" % remoteHead update = True else: settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead)) if settings.has_key('change') > 0: if settings['depot-paths'] == original['depot-paths']: originP4Change = int(original['change']) p4Change = int(settings['change']) if originP4Change > p4Change: print ("%s (%s) is newer than %s (%s). " "Updating p4 branch from origin." % (originHead, originP4Change, remoteHead, p4Change)) update = True else: print ("Ignoring: %s was imported from %s while " "%s was imported from %s" % (originHead, ','.join(original['depot-paths']), remoteHead, ','.join(settings['depot-paths']))) if update: system("git update-ref %s %s" % (remoteHead, originHead)) def originP4BranchesExist(): return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master") def p4ChangesForPaths(depotPaths, changeRange): assert depotPaths cmd = ['changes'] for p in depotPaths: cmd += ["%s...%s" % (p, changeRange)] output = p4_read_pipe_lines(cmd) changes = {} for line in output: changeNum = int(line.split(" ")[1]) changes[changeNum] = True changelist = changes.keys() changelist.sort() return changelist def p4PathStartsWith(path, prefix): # This method tries to remedy a potential mixed-case issue: # # If UserA adds //depot/DirA/file1 # and UserB adds //depot/dira/file2 # # we may or may not have a problem. If you have core.ignorecase=true, # we treat DirA and dira as the same directory if gitConfigBool("core.ignorecase"): return path.lower().startswith(prefix.lower()) return path.startswith(prefix) def getClientSpec(): """Look at the p4 client spec, create a View() object that contains all the mappings, and return it.""" specList = p4CmdList("client -o") if len(specList) != 1: die('Output from "client -o" is %d lines, expecting 1' % len(specList)) # dictionary of all client parameters entry = specList[0] # the //client/ name client_name = entry["Client"] # just the keys that start with "View" view_keys = [ k for k in entry.keys() if k.startswith("View") ] # hold this new View view = View(client_name) # append the lines, in order, to the view for view_num in range(len(view_keys)): k = "View%d" % view_num if k not in view_keys: die("Expected view key %s missing" % k) view.append(entry[k]) return view def getClientRoot(): """Grab the client directory.""" output = p4CmdList("client -o") if len(output) != 1: die('Output from "client -o" is %d lines, expecting 1' % len(output)) entry = output[0] if "Root" not in entry: die('Client has no "Root"') return entry["Root"] # # P4 wildcards are not allowed in filenames. P4 complains # if you simply add them, but you can force it with "-f", in # which case it translates them into %xx encoding internally. # def wildcard_decode(path): # Search for and fix just these four characters. Do % last so # that fixing it does not inadvertently create new %-escapes. # Cannot have * in a filename in windows; untested as to # what p4 would do in such a case. if not platform.system() == "Windows": path = path.replace("%2A", "*") path = path.replace("%23", "#") \ .replace("%40", "@") \ .replace("%25", "%") return path def wildcard_encode(path): # do % first to avoid double-encoding the %s introduced here path = path.replace("%", "%25") \ .replace("*", "%2A") \ .replace("#", "%23") \ .replace("@", "%40") return path def wildcard_present(path): m = re.search("[*#@%]", path) return m is not None class Command: def __init__(self): self.usage = "usage: %prog [options]" self.needsGit = True self.verbose = False class P4UserMap: def __init__(self): self.userMapFromPerforceServer = False self.myP4UserId = None def p4UserId(self): if self.myP4UserId: return self.myP4UserId results = p4CmdList("user -o") for r in results: if r.has_key('User'): self.myP4UserId = r['User'] return r['User'] die("Could not find your p4 user id") def p4UserIsMe(self, p4User): # return True if the given p4 user is actually me me = self.p4UserId() if not p4User or p4User != me: return False else: return True def getUserCacheFilename(self): home = os.environ.get("HOME", os.environ.get("USERPROFILE")) return home + "/.gitp4-usercache.txt" def getUserMapFromPerforceServer(self): if self.userMapFromPerforceServer: return self.users = {} self.emails = {} for output in p4CmdList("users"): if not output.has_key("User"): continue self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">" self.emails[output["Email"]] = output["User"] s = '' for (key, val) in self.users.items(): s += "%s\t%s\n" % (key.expandtabs(1), val.expandtabs(1)) open(self.getUserCacheFilename(), "wb").write(s) self.userMapFromPerforceServer = True def loadUserMapFromCache(self): self.users = {} self.userMapFromPerforceServer = False try: cache = open(self.getUserCacheFilename(), "rb") lines = cache.readlines() cache.close() for line in lines: entry = line.strip().split("\t") self.users[entry[0]] = entry[1] except IOError: self.getUserMapFromPerforceServer() class P4Debug(Command): def __init__(self): Command.__init__(self) self.options = [] self.description = "A tool to debug the output of p4 -G." self.needsGit = False def run(self, args): j = 0 for output in p4CmdList(args): print 'Element: %d' % j j += 1 print output return True class P4RollBack(Command): def __init__(self): Command.__init__(self) self.options = [ optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true") ] self.description = "A tool to debug the multi-branch import. Don't use :)" self.rollbackLocalBranches = False def run(self, args): if len(args) != 1: return False maxChange = int(args[0]) if "p4ExitCode" in p4Cmd("changes -m 1"): die("Problems executing p4"); if self.rollbackLocalBranches: refPrefix = "refs/heads/" lines = read_pipe_lines("git rev-parse --symbolic --branches") else: refPrefix = "refs/remotes/" lines = read_pipe_lines("git rev-parse --symbolic --remotes") for line in lines: if self.rollbackLocalBranches or (line.startswith("p4/") and line != "p4/HEAD\n"): line = line.strip() ref = refPrefix + line log = extractLogMessageFromGitCommit(ref) settings = extractSettingsGitLog(log) depotPaths = settings['depot-paths'] change = settings['change'] changed = False if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p, maxChange) for p in depotPaths]))) == 0: print "Branch %s did not exist at change %s, deleting." % (ref, maxChange) system("git update-ref -d %s `git rev-parse %s`" % (ref, ref)) continue while change and int(change) > maxChange: changed = True if self.verbose: print "%s is at %s ; rewinding towards %s" % (ref, change, maxChange) system("git update-ref %s \"%s^\"" % (ref, ref)) log = extractLogMessageFromGitCommit(ref) settings = extractSettingsGitLog(log) depotPaths = settings['depot-paths'] change = settings['change'] if changed: print "%s rewound to %s" % (ref, change) return True class P4Submit(Command, P4UserMap): conflict_behavior_choices = ("ask", "skip", "quit") def __init__(self): Command.__init__(self) P4UserMap.__init__(self) self.options = [ optparse.make_option("--origin", dest="origin"), optparse.make_option("-M", dest="detectRenames", action="store_true"), # preserve the user, requires relevant p4 permissions optparse.make_option("--preserve-user", dest="preserveUser", action="store_true"), optparse.make_option("--export-labels", dest="exportLabels", action="store_true"), optparse.make_option("--dry-run", "-n", dest="dry_run", action="store_true"), optparse.make_option("--prepare-p4-only", dest="prepare_p4_only", action="store_true"), optparse.make_option("--conflict", dest="conflict_behavior", choices=self.conflict_behavior_choices), optparse.make_option("--branch", dest="branch"), ] self.description = "Submit changes from git to the perforce depot." self.usage += " [name of git branch to submit into perforce depot]" self.origin = "" self.detectRenames = False self.preserveUser = gitConfigBool("git-p4.preserveUser") self.dry_run = False self.prepare_p4_only = False self.conflict_behavior = None self.isWindows = (platform.system() == "Windows") self.exportLabels = False self.p4HasMoveCommand = p4_has_move_command() self.branch = None def check(self): if len(p4CmdList("opened ...")) > 0: die("You have files opened with perforce! Close them before starting the sync.") def separate_jobs_from_description(self, message): """Extract and return a possible Jobs field in the commit message. It goes into a separate section in the p4 change specification. A jobs line starts with "Jobs:" and looks like a new field in a form. Values are white-space separated on the same line or on following lines that start with a tab. This does not parse and extract the full git commit message like a p4 form. It just sees the Jobs: line as a marker to pass everything from then on directly into the p4 form, but outside the description section. Return a tuple (stripped log message, jobs string).""" m = re.search(r'^Jobs:', message, re.MULTILINE) if m is None: return (message, None) jobtext = message[m.start():] stripped_message = message[:m.start()].rstrip() return (stripped_message, jobtext) def prepareLogMessage(self, template, message, jobs): """Edits the template returned from "p4 change -o" to insert the message in the Description field, and the jobs text in the Jobs field.""" result = "" inDescriptionSection = False for line in template.split("\n"): if line.startswith("#"): result += line + "\n" continue if inDescriptionSection: if line.startswith("Files:") or line.startswith("Jobs:"): inDescriptionSection = False # insert Jobs section if jobs: result += jobs + "\n" else: continue else: if line.startswith("Description:"): inDescriptionSection = True line += "\n" for messageLine in message.split("\n"): line += "\t" + messageLine + "\n" result += line + "\n" return result def patchRCSKeywords(self, file, pattern): # Attempt to zap the RCS keywords in a p4 controlled file matching the given pattern (handle, outFileName) = tempfile.mkstemp(dir='.') try: outFile = os.fdopen(handle, "w+") inFile = open(file, "r") regexp = re.compile(pattern, re.VERBOSE) for line in inFile.readlines(): line = regexp.sub(r'$\1$', line) outFile.write(line) inFile.close() outFile.close() # Forcibly overwrite the original file os.unlink(file) shutil.move(outFileName, file) except: # cleanup our temporary file os.unlink(outFileName) print "Failed to strip RCS keywords in %s" % file raise print "Patched up RCS keywords in %s" % file def p4UserForCommit(self,id): # Return the tuple (perforce user,git email) for a given git commit id self.getUserMapFromPerforceServer() gitEmail = read_pipe(["git", "log", "--max-count=1", "--format=%ae", id]) gitEmail = gitEmail.strip() if not self.emails.has_key(gitEmail): return (None,gitEmail) else: return (self.emails[gitEmail],gitEmail) def checkValidP4Users(self,commits): # check if any git authors cannot be mapped to p4 users for id in commits: (user,email) = self.p4UserForCommit(id) if not user: msg = "Cannot find p4 user for email %s in commit %s." % (email, id) if gitConfigBool("git-p4.allowMissingP4Users"): print "%s" % msg else: die("Error: %s\nSet git-p4.allowMissingP4Users to true to allow this." % msg) def lastP4Changelist(self): # Get back the last changelist number submitted in this client spec. This # then gets used to patch up the username in the change. If the same # client spec is being used by multiple processes then this might go # wrong. results = p4CmdList("client -o") # find the current client client = None for r in results: if r.has_key('Client'): client = r['Client'] break if not client: die("could not get client spec") results = p4CmdList(["changes", "-c", client, "-m", "1"]) for r in results: if r.has_key('change'): return r['change'] die("Could not get changelist number for last submit - cannot patch up user details") def modifyChangelistUser(self, changelist, newUser): # fixup the user field of a changelist after it has been submitted. changes = p4CmdList("change -o %s" % changelist) if len(changes) != 1: die("Bad output from p4 change modifying %s to user %s" % (changelist, newUser)) c = changes[0] if c['User'] == newUser: return # nothing to do c['User'] = newUser input = marshal.dumps(c) result = p4CmdList("change -f -i", stdin=input) for r in result: if r.has_key('code'): if r['code'] == 'error': die("Could not modify user field of changelist %s to %s:%s" % (changelist, newUser, r['data'])) if r.has_key('data'): print("Updated user field for changelist %s to %s" % (changelist, newUser)) return die("Could not modify user field of changelist %s to %s" % (changelist, newUser)) def canChangeChangelists(self): # check to see if we have p4 admin or super-user permissions, either of # which are required to modify changelists. results = p4CmdList(["protects", self.depotPath]) for r in results: if r.has_key('perm'): if r['perm'] == 'admin': return 1 if r['perm'] == 'super': return 1 return 0 def prepareSubmitTemplate(self): """Run "p4 change -o" to grab a change specification template. This does not use "p4 -G", as it is nice to keep the submission template in original order, since a human might edit it. Remove lines in the Files section that show changes to files outside the depot path we're committing into.""" template = "" inFilesSection = False for line in p4_read_pipe_lines(['change', '-o']): if line.endswith("\r\n"): line = line[:-2] + "\n" if inFilesSection: if line.startswith("\t"): # path starts and ends with a tab path = line[1:] lastTab = path.rfind("\t") if lastTab != -1: path = path[:lastTab] if not p4PathStartsWith(path, self.depotPath): continue else: inFilesSection = False else: if line.startswith("Files:"): inFilesSection = True template += line return template def edit_template(self, template_file): """Invoke the editor to let the user change the submission message. Return true if okay to continue with the submit.""" # if configured to skip the editing part, just submit if gitConfigBool("git-p4.skipSubmitEdit"): return True # look at the modification time, to check later if the user saved # the file mtime = os.stat(template_file).st_mtime # invoke the editor if os.environ.has_key("P4EDITOR") and (os.environ.get("P4EDITOR") != ""): editor = os.environ.get("P4EDITOR") else: editor = read_pipe("git var GIT_EDITOR").strip() system([editor, template_file]) # If the file was not saved, prompt to see if this patch should # be skipped. But skip this verification step if configured so. if gitConfigBool("git-p4.skipSubmitEditCheck"): return True # modification time updated means user saved the file if os.stat(template_file).st_mtime > mtime: return True while True: response = raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ") if response == 'y': return True if response == 'n': return False def get_diff_description(self, editedFiles, filesToAdd): # diff if os.environ.has_key("P4DIFF"): del(os.environ["P4DIFF"]) diff = "" for editedFile in editedFiles: diff += p4_read_pipe(['diff', '-du', wildcard_encode(editedFile)]) # new file diff newdiff = "" for newFile in filesToAdd: newdiff += "==== new file ====\n" newdiff += "--- /dev/null\n" newdiff += "+++ %s\n" % newFile f = open(newFile, "r") for line in f.readlines(): newdiff += "+" + line f.close() return (diff + newdiff).replace('\r\n', '\n') def applyCommit(self, id): """Apply one commit, return True if it succeeded.""" print "Applying", read_pipe(["git", "show", "-s", "--format=format:%h %s", id]) (p4User, gitEmail) = self.p4UserForCommit(id) diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (self.diffOpts, id, id)) filesToAdd = set() filesToDelete = set() editedFiles = set() pureRenameCopy = set() filesToChangeExecBit = {} for line in diff: diff = parseDiffTreeEntry(line) modifier = diff['status'] path = diff['src'] if modifier == "M": p4_edit(path) if isModeExecChanged(diff['src_mode'], diff['dst_mode']): filesToChangeExecBit[path] = diff['dst_mode'] editedFiles.add(path) elif modifier == "A": filesToAdd.add(path) filesToChangeExecBit[path] = diff['dst_mode'] if path in filesToDelete: filesToDelete.remove(path) elif modifier == "D": filesToDelete.add(path) if path in filesToAdd: filesToAdd.remove(path) elif modifier == "C": src, dest = diff['src'], diff['dst'] p4_integrate(src, dest) pureRenameCopy.add(dest) if diff['src_sha1'] != diff['dst_sha1']: p4_edit(dest) pureRenameCopy.discard(dest) if isModeExecChanged(diff['src_mode'], diff['dst_mode']): p4_edit(dest) pureRenameCopy.discard(dest) filesToChangeExecBit[dest] = diff['dst_mode'] if self.isWindows: # turn off read-only attribute os.chmod(dest, stat.S_IWRITE) os.unlink(dest) editedFiles.add(dest) elif modifier == "R": src, dest = diff['src'], diff['dst'] if self.p4HasMoveCommand: p4_edit(src) # src must be open before move p4_move(src, dest) # opens for (move/delete, move/add) else: p4_integrate(src, dest) if diff['src_sha1'] != diff['dst_sha1']: p4_edit(dest) else: pureRenameCopy.add(dest) if isModeExecChanged(diff['src_mode'], diff['dst_mode']): if not self.p4HasMoveCommand: p4_edit(dest) # with move: already open, writable filesToChangeExecBit[dest] = diff['dst_mode'] if not self.p4HasMoveCommand: if self.isWindows: os.chmod(dest, stat.S_IWRITE) os.unlink(dest) filesToDelete.add(src) editedFiles.add(dest) else: die("unknown modifier %s for %s" % (modifier, path)) diffcmd = "git diff-tree --full-index -p \"%s\"" % (id) patchcmd = diffcmd + " | git apply " tryPatchCmd = patchcmd + "--check -" applyPatchCmd = patchcmd + "--check --apply -" patch_succeeded = True if os.system(tryPatchCmd) != 0: fixed_rcs_keywords = False patch_succeeded = False print "Unfortunately applying the change failed!" # Patch failed, maybe it's just RCS keyword woes. Look through # the patch to see if that's possible. if gitConfigBool("git-p4.attemptRCSCleanup"): file = None pattern = None kwfiles = {} for file in editedFiles | filesToDelete: # did this file's delta contain RCS keywords? pattern = p4_keywords_regexp_for_file(file) if pattern: # this file is a possibility...look for RCS keywords. regexp = re.compile(pattern, re.VERBOSE) for line in read_pipe_lines(["git", "diff", "%s^..%s" % (id, id), file]): if regexp.search(line): if verbose: print "got keyword match on %s in %s in %s" % (pattern, line, file) kwfiles[file] = pattern break for file in kwfiles: if verbose: print "zapping %s with %s" % (line,pattern) # File is being deleted, so not open in p4. Must # disable the read-only bit on windows. if self.isWindows and file not in editedFiles: os.chmod(file, stat.S_IWRITE) self.patchRCSKeywords(file, kwfiles[file]) fixed_rcs_keywords = True if fixed_rcs_keywords: print "Retrying the patch with RCS keywords cleaned up" if os.system(tryPatchCmd) == 0: patch_succeeded = True if not patch_succeeded: for f in editedFiles: p4_revert(f) return False # # Apply the patch for real, and do add/delete/+x handling. # system(applyPatchCmd) for f in filesToAdd: p4_add(f) for f in filesToDelete: p4_revert(f) p4_delete(f) # Set/clear executable bits for f in filesToChangeExecBit.keys(): mode = filesToChangeExecBit[f] setP4ExecBit(f, mode) # # Build p4 change description, starting with the contents # of the git commit message. # logMessage = extractLogMessageFromGitCommit(id) logMessage = logMessage.strip() (logMessage, jobs) = self.separate_jobs_from_description(logMessage) template = self.prepareSubmitTemplate() submitTemplate = self.prepareLogMessage(template, logMessage, jobs) if self.preserveUser: submitTemplate += "\n######## Actual user %s, modified after commit\n" % p4User if self.checkAuthorship and not self.p4UserIsMe(p4User): submitTemplate += "######## git author %s does not match your p4 account.\n" % gitEmail submitTemplate += "######## Use option --preserve-user to modify authorship.\n" submitTemplate += "######## Variable git-p4.skipUserNameCheck hides this message.\n" separatorLine = "######## everything below this line is just the diff #######\n" if not self.prepare_p4_only: submitTemplate += separatorLine submitTemplate += self.get_diff_description(editedFiles, filesToAdd) (handle, fileName) = tempfile.mkstemp() tmpFile = os.fdopen(handle, "w+b") if self.isWindows: submitTemplate = submitTemplate.replace("\n", "\r\n") tmpFile.write(submitTemplate) tmpFile.close() if self.prepare_p4_only: # # Leave the p4 tree prepared, and the submit template around # and let the user decide what to do next # print print "P4 workspace prepared for submission." print "To submit or revert, go to client workspace" print " " + self.clientPath print print "To submit, use \"p4 submit\" to write a new description," print "or \"p4 submit -i %s\" to use the one prepared by" \ " \"git p4\"." % fileName print "You can delete the file \"%s\" when finished." % fileName if self.preserveUser and p4User and not self.p4UserIsMe(p4User): print "To preserve change ownership by user %s, you must\n" \ "do \"p4 change -f <change>\" after submitting and\n" \ "edit the User field." if pureRenameCopy: print "After submitting, renamed files must be re-synced." print "Invoke \"p4 sync -f\" on each of these files:" for f in pureRenameCopy: print " " + f print print "To revert the changes, use \"p4 revert ...\", and delete" print "the submit template file \"%s\"" % fileName if filesToAdd: print "Since the commit adds new files, they must be deleted:" for f in filesToAdd: print " " + f print return True # # Let the user edit the change description, then submit it. # if self.edit_template(fileName): # read the edited message and submit ret = True tmpFile = open(fileName, "rb") message = tmpFile.read() tmpFile.close() if self.isWindows: message = message.replace("\r\n", "\n") submitTemplate = message[:message.index(separatorLine)] p4_write_pipe(['submit', '-i'], submitTemplate) if self.preserveUser: if p4User: # Get last changelist number. Cannot easily get it from # the submit command output as the output is # unmarshalled. changelist = self.lastP4Changelist() self.modifyChangelistUser(changelist, p4User) # The rename/copy happened by applying a patch that created a # new file. This leaves it writable, which confuses p4. for f in pureRenameCopy: p4_sync(f, "-f") else: # skip this patch ret = False print "Submission cancelled, undoing p4 changes." for f in editedFiles: p4_revert(f) for f in filesToAdd: p4_revert(f) os.remove(f) for f in filesToDelete: p4_revert(f) os.remove(fileName) return ret # Export git tags as p4 labels. Create a p4 label and then tag # with that. def exportGitTags(self, gitTags): validLabelRegexp = gitConfig("git-p4.labelExportRegexp") if len(validLabelRegexp) == 0: validLabelRegexp = defaultLabelRegexp m = re.compile(validLabelRegexp) for name in gitTags: if not m.match(name): if verbose: print "tag %s does not match regexp %s" % (name, validLabelRegexp) continue # Get the p4 commit this corresponds to logMessage = extractLogMessageFromGitCommit(name) values = extractSettingsGitLog(logMessage) if not values.has_key('change'): # a tag pointing to something not sent to p4; ignore if verbose: print "git tag %s does not give a p4 commit" % name continue else: changelist = values['change'] # Get the tag details. inHeader = True isAnnotated = False body = [] for l in read_pipe_lines(["git", "cat-file", "-p", name]): l = l.strip() if inHeader: if re.match(r'tag\s+', l): isAnnotated = True elif re.match(r'\s*$', l): inHeader = False continue else: body.append(l) if not isAnnotated: body = ["lightweight tag imported by git p4\n"] # Create the label - use the same view as the client spec we are using clientSpec = getClientSpec() labelTemplate = "Label: %s\n" % name labelTemplate += "Description:\n" for b in body: labelTemplate += "\t" + b + "\n" labelTemplate += "View:\n" for depot_side in clientSpec.mappings: labelTemplate += "\t%s\n" % depot_side if self.dry_run: print "Would create p4 label %s for tag" % name elif self.prepare_p4_only: print "Not creating p4 label %s for tag due to option" \ " --prepare-p4-only" % name else: p4_write_pipe(["label", "-i"], labelTemplate) # Use the label p4_system(["tag", "-l", name] + ["%s@%s" % (depot_side, changelist) for depot_side in clientSpec.mappings]) if verbose: print "created p4 label for tag %s" % name def run(self, args): if len(args) == 0: self.master = currentGitBranch() if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master): die("Detecting current git branch failed!") elif len(args) == 1: self.master = args[0] if not branchExists(self.master): die("Branch %s does not exist" % self.master) else: return False allowSubmit = gitConfig("git-p4.allowSubmit") if len(allowSubmit) > 0 and not self.master in allowSubmit.split(","): die("%s is not in git-p4.allowSubmit" % self.master) [upstream, settings] = findUpstreamBranchPoint() self.depotPath = settings['depot-paths'][0] if len(self.origin) == 0: self.origin = upstream if self.preserveUser: if not self.canChangeChangelists(): die("Cannot preserve user names without p4 super-user or admin permissions") # if not set from the command line, try the config file if self.conflict_behavior is None: val = gitConfig("git-p4.conflict") if val: if val not in self.conflict_behavior_choices: die("Invalid value '%s' for config git-p4.conflict" % val) else: val = "ask" self.conflict_behavior = val if self.verbose: print "Origin branch is " + self.origin if len(self.depotPath) == 0: print "Internal error: cannot locate perforce depot path from existing branches" sys.exit(128) self.useClientSpec = False if gitConfigBool("git-p4.useclientspec"): self.useClientSpec = True if self.useClientSpec: self.clientSpecDirs = getClientSpec() if self.useClientSpec: # all files are relative to the client spec self.clientPath = getClientRoot() else: self.clientPath = p4Where(self.depotPath) if self.clientPath == "": die("Error: Cannot locate perforce checkout of %s in client view" % self.depotPath) print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath) self.oldWorkingDirectory = os.getcwd() # ensure the clientPath exists new_client_dir = False if not os.path.exists(self.clientPath): new_client_dir = True os.makedirs(self.clientPath) chdir(self.clientPath, is_client_path=True) if self.dry_run: print "Would synchronize p4 checkout in %s" % self.clientPath else: print "Synchronizing p4 checkout..." if new_client_dir: # old one was destroyed, and maybe nobody told p4 p4_sync("...", "-f") else: p4_sync("...") self.check() commits = [] for line in read_pipe_lines(["git", "rev-list", "--no-merges", "%s..%s" % (self.origin, self.master)]): commits.append(line.strip()) commits.reverse() if self.preserveUser or gitConfigBool("git-p4.skipUserNameCheck"): self.checkAuthorship = False else: self.checkAuthorship = True if self.preserveUser: self.checkValidP4Users(commits) # # Build up a set of options to be passed to diff when # submitting each commit to p4. # if self.detectRenames: # command-line -M arg self.diffOpts = "-M" else: # If not explicitly set check the config variable detectRenames = gitConfig("git-p4.detectRenames") if detectRenames.lower() == "false" or detectRenames == "": self.diffOpts = "" elif detectRenames.lower() == "true": self.diffOpts = "-M" else: self.diffOpts = "-M%s" % detectRenames # no command-line arg for -C or --find-copies-harder, just # config variables detectCopies = gitConfig("git-p4.detectCopies") if detectCopies.lower() == "false" or detectCopies == "": pass elif detectCopies.lower() == "true": self.diffOpts += " -C" else: self.diffOpts += " -C%s" % detectCopies if gitConfigBool("git-p4.detectCopiesHarder"): self.diffOpts += " --find-copies-harder" # # Apply the commits, one at a time. On failure, ask if should # continue to try the rest of the patches, or quit. # if self.dry_run: print "Would apply" applied = [] last = len(commits) - 1 for i, commit in enumerate(commits): if self.dry_run: print " ", read_pipe(["git", "show", "-s", "--format=format:%h %s", commit]) ok = True else: ok = self.applyCommit(commit) if ok: applied.append(commit) else: if self.prepare_p4_only and i < last: print "Processing only the first commit due to option" \ " --prepare-p4-only" break if i < last: quit = False while True: # prompt for what to do, or use the option/variable if self.conflict_behavior == "ask": print "What do you want to do?" response = raw_input("[s]kip this commit but apply" " the rest, or [q]uit? ") if not response: continue elif self.conflict_behavior == "skip": response = "s" elif self.conflict_behavior == "quit": response = "q" else: die("Unknown conflict_behavior '%s'" % self.conflict_behavior) if response[0] == "s": print "Skipping this commit, but applying the rest" break if response[0] == "q": print "Quitting" quit = True break if quit: break chdir(self.oldWorkingDirectory) if self.dry_run: pass elif self.prepare_p4_only: pass elif len(commits) == len(applied): print "All commits applied!" sync = P4Sync() if self.branch: sync.branch = self.branch sync.run([]) rebase = P4Rebase() rebase.rebase() else: if len(applied) == 0: print "No commits applied." else: print "Applied only the commits marked with '*':" for c in commits: if c in applied: star = "*" else: star = " " print star, read_pipe(["git", "show", "-s", "--format=format:%h %s", c]) print "You will have to do 'git p4 sync' and rebase." if gitConfigBool("git-p4.exportLabels"): self.exportLabels = True if self.exportLabels: p4Labels = getP4Labels(self.depotPath) gitTags = getGitTags() missingGitTags = gitTags - p4Labels self.exportGitTags(missingGitTags) # exit with error unless everything applied perfectly if len(commits) != len(applied): sys.exit(1) return True class View(object): """Represent a p4 view ("p4 help views"), and map files in a repo according to the view.""" def __init__(self, client_name): self.mappings = [] self.client_prefix = "//%s/" % client_name # cache results of "p4 where" to lookup client file locations self.client_spec_path_cache = {} def append(self, view_line): """Parse a view line, splitting it into depot and client sides. Append to self.mappings, preserving order. This is only needed for tag creation.""" # Split the view line into exactly two words. P4 enforces # structure on these lines that simplifies this quite a bit. # # Either or both words may be double-quoted. # Single quotes do not matter. # Double-quote marks cannot occur inside the words. # A + or - prefix is also inside the quotes. # There are no quotes unless they contain a space. # The line is already white-space stripped. # The two words are separated by a single space. # if view_line[0] == '"': # First word is double quoted. Find its end. close_quote_index = view_line.find('"', 1) if close_quote_index <= 0: die("No first-word closing quote found: %s" % view_line) depot_side = view_line[1:close_quote_index] # skip closing quote and space rhs_index = close_quote_index + 1 + 1 else: space_index = view_line.find(" ") if space_index <= 0: die("No word-splitting space found: %s" % view_line) depot_side = view_line[0:space_index] rhs_index = space_index + 1 # prefix + means overlay on previous mapping if depot_side.startswith("+"): depot_side = depot_side[1:] # prefix - means exclude this path, leave out of mappings exclude = False if depot_side.startswith("-"): exclude = True depot_side = depot_side[1:] if not exclude: self.mappings.append(depot_side) def convert_client_path(self, clientFile): # chop off //client/ part to make it relative if not clientFile.startswith(self.client_prefix): die("No prefix '%s' on clientFile '%s'" % (self.client_prefix, clientFile)) return clientFile[len(self.client_prefix):] def update_client_spec_path_cache(self, files): """ Caching file paths by "p4 where" batch query """ # List depot file paths exclude that already cached fileArgs = [f['path'] for f in files if f['path'] not in self.client_spec_path_cache] if len(fileArgs) == 0: return # All files in cache where_result = p4CmdList(["-x", "-", "where"], stdin=fileArgs) for res in where_result: if "code" in res and res["code"] == "error": # assume error is "... file(s) not in client view" continue if "clientFile" not in res: die("No clientFile in 'p4 where' output") if "unmap" in res: # it will list all of them, but only one not unmap-ped continue self.client_spec_path_cache[res['depotFile']] = self.convert_client_path(res["clientFile"]) # not found files or unmap files set to "" for depotFile in fileArgs: if depotFile not in self.client_spec_path_cache: self.client_spec_path_cache[depotFile] = "" def map_in_client(self, depot_path): """Return the relative location in the client where this depot file should live. Returns "" if the file should not be mapped in the client.""" if depot_path in self.client_spec_path_cache: return self.client_spec_path_cache[depot_path] die( "Error: %s is not found in client spec path" % depot_path ) return "" class P4Sync(Command, P4UserMap): delete_actions = ( "delete", "move/delete", "purge" ) def __init__(self): Command.__init__(self) P4UserMap.__init__(self) self.options = [ optparse.make_option("--branch", dest="branch"), optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"), optparse.make_option("--changesfile", dest="changesFile"), optparse.make_option("--silent", dest="silent", action="store_true"), optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"), optparse.make_option("--import-labels", dest="importLabels", action="store_true"), optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false", help="Import into refs/heads/ , not refs/remotes"), optparse.make_option("--max-changes", dest="maxChanges"), optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true', help="Keep entire BRANCH/DIR/SUBDIR prefix during import"), optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true', help="Only sync files that are included in the Perforce Client Spec") ] self.description = """Imports from Perforce into a git repository.\n example: //depot/my/project/ -- to import the current head //depot/my/project/@all -- to import everything //depot/my/project/@1,6 -- to import only from revision 1 to 6 (a ... is not needed in the path p4 specification, it's added implicitly)""" self.usage += " //depot/path[@revRange]" self.silent = False self.createdBranches = set() self.committedChanges = set() self.branch = "" self.detectBranches = False self.detectLabels = False self.importLabels = False self.changesFile = "" self.syncWithOrigin = True self.importIntoRemotes = True self.maxChanges = "" self.keepRepoPath = False self.depotPaths = None self.p4BranchesInGit = [] self.cloneExclude = [] self.useClientSpec = False self.useClientSpec_from_options = False self.clientSpecDirs = None self.tempBranches = [] self.tempBranchLocation = "git-p4-tmp" if gitConfig("git-p4.syncFromOrigin") == "false": self.syncWithOrigin = False # Force a checkpoint in fast-import and wait for it to finish def checkpoint(self): self.gitStream.write("checkpoint\n\n") self.gitStream.write("progress checkpoint\n\n") out = self.gitOutput.readline() if self.verbose: print "checkpoint finished: " + out def extractFilesFromCommit(self, commit): self.cloneExclude = [re.sub(r"\.\.\.$", "", path) for path in self.cloneExclude] files = [] fnum = 0 while commit.has_key("depotFile%s" % fnum): path = commit["depotFile%s" % fnum] if [p for p in self.cloneExclude if p4PathStartsWith(path, p)]: found = False else: found = [p for p in self.depotPaths if p4PathStartsWith(path, p)] if not found: fnum = fnum + 1 continue file = {} file["path"] = path file["rev"] = commit["rev%s" % fnum] file["action"] = commit["action%s" % fnum] file["type"] = commit["type%s" % fnum] files.append(file) fnum = fnum + 1 return files def stripRepoPath(self, path, prefixes): """When streaming files, this is called to map a p4 depot path to where it should go in git. The prefixes are either self.depotPaths, or self.branchPrefixes in the case of branch detection.""" if self.useClientSpec: # branch detection moves files up a level (the branch name) # from what client spec interpretation gives path = self.clientSpecDirs.map_in_client(path) if self.detectBranches: for b in self.knownBranches: if path.startswith(b + "/"): path = path[len(b)+1:] elif self.keepRepoPath: # Preserve everything in relative path name except leading # //depot/; just look at first prefix as they all should # be in the same depot. depot = re.sub("^(//[^/]+/).*", r'\1', prefixes[0]) if p4PathStartsWith(path, depot): path = path[len(depot):] else: for p in prefixes: if p4PathStartsWith(path, p): path = path[len(p):] break path = wildcard_decode(path) return path def splitFilesIntoBranches(self, commit): """Look at each depotFile in the commit to figure out to what branch it belongs.""" if self.clientSpecDirs: files = self.extractFilesFromCommit(commit) self.clientSpecDirs.update_client_spec_path_cache(files) branches = {} fnum = 0 while commit.has_key("depotFile%s" % fnum): path = commit["depotFile%s" % fnum] found = [p for p in self.depotPaths if p4PathStartsWith(path, p)] if not found: fnum = fnum + 1 continue file = {} file["path"] = path file["rev"] = commit["rev%s" % fnum] file["action"] = commit["action%s" % fnum] file["type"] = commit["type%s" % fnum] fnum = fnum + 1 # start with the full relative path where this file would # go in a p4 client if self.useClientSpec: relPath = self.clientSpecDirs.map_in_client(path) else: relPath = self.stripRepoPath(path, self.depotPaths) for branch in self.knownBranches.keys(): # add a trailing slash so that a commit into qt/4.2foo # doesn't end up in qt/4.2, e.g. if relPath.startswith(branch + "/"): if branch not in branches: branches[branch] = [] branches[branch].append(file) break return branches # output one file from the P4 stream # - helper for streamP4Files def streamOneP4File(self, file, contents): relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes) if verbose: sys.stderr.write("%s\n" % relPath) (type_base, type_mods) = split_p4_type(file["type"]) git_mode = "100644" if "x" in type_mods: git_mode = "100755" if type_base == "symlink": git_mode = "120000" # p4 print on a symlink sometimes contains "target\n"; # if it does, remove the newline data = ''.join(contents) if not data: # Some version of p4 allowed creating a symlink that pointed # to nothing. This causes p4 errors when checking out such # a change, and errors here too. Work around it by ignoring # the bad symlink; hopefully a future change fixes it. print "\nIgnoring empty symlink in %s" % file['depotFile'] return elif data[-1] == '\n': contents = [data[:-1]] else: contents = [data] if type_base == "utf16": # p4 delivers different text in the python output to -G # than it does when using "print -o", or normal p4 client # operations. utf16 is converted to ascii or utf8, perhaps. # But ascii text saved as -t utf16 is completely mangled. # Invoke print -o to get the real contents. # # On windows, the newlines will always be mangled by print, so put # them back too. This is not needed to the cygwin windows version, # just the native "NT" type. # text = p4_read_pipe(['print', '-q', '-o', '-', file['depotFile']]) if p4_version_string().find("/NT") >= 0: text = text.replace("\r\n", "\n") contents = [ text ] if type_base == "apple": # Apple filetype files will be streamed as a concatenation of # its appledouble header and the contents. This is useless # on both macs and non-macs. If using "print -q -o xx", it # will create "xx" with the data, and "%xx" with the header. # This is also not very useful. # # Ideally, someday, this script can learn how to generate # appledouble files directly and import those to git, but # non-mac machines can never find a use for apple filetype. print "\nIgnoring apple filetype file %s" % file['depotFile'] return # Note that we do not try to de-mangle keywords on utf16 files, # even though in theory somebody may want that. pattern = p4_keywords_regexp_for_type(type_base, type_mods) if pattern: regexp = re.compile(pattern, re.VERBOSE) text = ''.join(contents) text = regexp.sub(r'$\1$', text) contents = [ text ] self.gitStream.write("M %s inline %s\n" % (git_mode, relPath)) # total length... length = 0 for d in contents: length = length + len(d) self.gitStream.write("data %d\n" % length) for d in contents: self.gitStream.write(d) self.gitStream.write("\n") def streamOneP4Deletion(self, file): relPath = self.stripRepoPath(file['path'], self.branchPrefixes) if verbose: sys.stderr.write("delete %s\n" % relPath) self.gitStream.write("D %s\n" % relPath) # handle another chunk of streaming data def streamP4FilesCb(self, marshalled): # catch p4 errors and complain err = None if "code" in marshalled: if marshalled["code"] == "error": if "data" in marshalled: err = marshalled["data"].rstrip() if err: f = None if self.stream_have_file_info: if "depotFile" in self.stream_file: f = self.stream_file["depotFile"] # force a failure in fast-import, else an empty # commit will be made self.gitStream.write("\n") self.gitStream.write("die-now\n") self.gitStream.close() # ignore errors, but make sure it exits first self.importProcess.wait() if f: die("Error from p4 print for %s: %s" % (f, err)) else: die("Error from p4 print: %s" % err) if marshalled.has_key('depotFile') and self.stream_have_file_info: # start of a new file - output the old one first self.streamOneP4File(self.stream_file, self.stream_contents) self.stream_file = {} self.stream_contents = [] self.stream_have_file_info = False # pick up the new file information... for the # 'data' field we need to append to our array for k in marshalled.keys(): if k == 'data': self.stream_contents.append(marshalled['data']) else: self.stream_file[k] = marshalled[k] self.stream_have_file_info = True # Stream directly from "p4 files" into "git fast-import" def streamP4Files(self, files): filesForCommit = [] filesToRead = [] filesToDelete = [] for f in files: # if using a client spec, only add the files that have # a path in the client if self.clientSpecDirs: if self.clientSpecDirs.map_in_client(f['path']) == "": continue filesForCommit.append(f) if f['action'] in self.delete_actions: filesToDelete.append(f) else: filesToRead.append(f) # deleted files... for f in filesToDelete: self.streamOneP4Deletion(f) if len(filesToRead) > 0: self.stream_file = {} self.stream_contents = [] self.stream_have_file_info = False # curry self argument def streamP4FilesCbSelf(entry): self.streamP4FilesCb(entry) fileArgs = ['%s#%s' % (f['path'], f['rev']) for f in filesToRead] p4CmdList(["-x", "-", "print"], stdin=fileArgs, cb=streamP4FilesCbSelf) # do the last chunk if self.stream_file.has_key('depotFile'): self.streamOneP4File(self.stream_file, self.stream_contents) def make_email(self, userid): if userid in self.users: return self.users[userid] else: return "%s <a@b>" % userid # Stream a p4 tag def streamTag(self, gitStream, labelName, labelDetails, commit, epoch): if verbose: print "writing tag %s for commit %s" % (labelName, commit) gitStream.write("tag %s\n" % labelName) gitStream.write("from %s\n" % commit) if labelDetails.has_key('Owner'): owner = labelDetails["Owner"] else: owner = None # Try to use the owner of the p4 label, or failing that, # the current p4 user id. if owner: email = self.make_email(owner) else: email = self.make_email(self.p4UserId()) tagger = "%s %s %s" % (email, epoch, self.tz) gitStream.write("tagger %s\n" % tagger) print "labelDetails=",labelDetails if labelDetails.has_key('Description'): description = labelDetails['Description'] else: description = 'Label from git p4' gitStream.write("data %d\n" % len(description)) gitStream.write(description) gitStream.write("\n") def commit(self, details, files, branch, parent = ""): epoch = details["time"] author = details["user"] if self.verbose: print "commit into %s" % branch # start with reading files; if that fails, we should not # create a commit. new_files = [] for f in files: if [p for p in self.branchPrefixes if p4PathStartsWith(f['path'], p)]: new_files.append (f) else: sys.stderr.write("Ignoring file outside of prefix: %s\n" % f['path']) if self.clientSpecDirs: self.clientSpecDirs.update_client_spec_path_cache(files) self.gitStream.write("commit %s\n" % branch) # gitStream.write("mark :%s\n" % details["change"]) self.committedChanges.add(int(details["change"])) committer = "" if author not in self.users: self.getUserMapFromPerforceServer() committer = "%s %s %s" % (self.make_email(author), epoch, self.tz) self.gitStream.write("committer %s\n" % committer) self.gitStream.write("data <<EOT\n") self.gitStream.write(details["desc"]) self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s" % (','.join(self.branchPrefixes), details["change"])) if len(details['options']) > 0: self.gitStream.write(": options = %s" % details['options']) self.gitStream.write("]\nEOT\n\n") if len(parent) > 0: if self.verbose: print "parent %s" % parent self.gitStream.write("from %s\n" % parent) self.streamP4Files(new_files) self.gitStream.write("\n") change = int(details["change"]) if self.labels.has_key(change): label = self.labels[change] labelDetails = label[0] labelRevisions = label[1] if self.verbose: print "Change %s is labelled %s" % (change, labelDetails) files = p4CmdList(["files"] + ["%s...@%s" % (p, change) for p in self.branchPrefixes]) if len(files) == len(labelRevisions): cleanedFiles = {} for info in files: if info["action"] in self.delete_actions: continue cleanedFiles[info["depotFile"]] = info["rev"] if cleanedFiles == labelRevisions: self.streamTag(self.gitStream, 'tag_%s' % labelDetails['label'], labelDetails, branch, epoch) else: if not self.silent: print ("Tag %s does not match with change %s: files do not match." % (labelDetails["label"], change)) else: if not self.silent: print ("Tag %s does not match with change %s: file count is different." % (labelDetails["label"], change)) # Build a dictionary of changelists and labels, for "detect-labels" option. def getLabels(self): self.labels = {} l = p4CmdList(["labels"] + ["%s..." % p for p in self.depotPaths]) if len(l) > 0 and not self.silent: print "Finding files belonging to labels in %s" % `self.depotPaths` for output in l: label = output["label"] revisions = {} newestChange = 0 if self.verbose: print "Querying files for label %s" % label for file in p4CmdList(["files"] + ["%s...@%s" % (p, label) for p in self.depotPaths]): revisions[file["depotFile"]] = file["rev"] change = int(file["change"]) if change > newestChange: newestChange = change self.labels[newestChange] = [output, revisions] if self.verbose: print "Label changes: %s" % self.labels.keys() # Import p4 labels as git tags. A direct mapping does not # exist, so assume that if all the files are at the same revision # then we can use that, or it's something more complicated we should # just ignore. def importP4Labels(self, stream, p4Labels): if verbose: print "import p4 labels: " + ' '.join(p4Labels) ignoredP4Labels = gitConfigList("git-p4.ignoredP4Labels") validLabelRegexp = gitConfig("git-p4.labelImportRegexp") if len(validLabelRegexp) == 0: validLabelRegexp = defaultLabelRegexp m = re.compile(validLabelRegexp) for name in p4Labels: commitFound = False if not m.match(name): if verbose: print "label %s does not match regexp %s" % (name,validLabelRegexp) continue if name in ignoredP4Labels: continue labelDetails = p4CmdList(['label', "-o", name])[0] # get the most recent changelist for each file in this label change = p4Cmd(["changes", "-m", "1"] + ["%s...@%s" % (p, name) for p in self.depotPaths]) if change.has_key('change'): # find the corresponding git commit; take the oldest commit changelist = int(change['change']) gitCommit = read_pipe(["git", "rev-list", "--max-count=1", "--reverse", ":/\[git-p4:.*change = %d\]" % changelist]) if len(gitCommit) == 0: print "could not find git commit for changelist %d" % changelist else: gitCommit = gitCommit.strip() commitFound = True # Convert from p4 time format try: tmwhen = time.strptime(labelDetails['Update'], "%Y/%m/%d %H:%M:%S") except ValueError: print "Could not convert label time %s" % labelDetails['Update'] tmwhen = 1 when = int(time.mktime(tmwhen)) self.streamTag(stream, name, labelDetails, gitCommit, when) if verbose: print "p4 label %s mapped to git commit %s" % (name, gitCommit) else: if verbose: print "Label %s has no changelists - possibly deleted?" % name if not commitFound: # We can't import this label; don't try again as it will get very # expensive repeatedly fetching all the files for labels that will # never be imported. If the label is moved in the future, the # ignore will need to be removed manually. system(["git", "config", "--add", "git-p4.ignoredP4Labels", name]) def guessProjectName(self): for p in self.depotPaths: if p.endswith("/"): p = p[:-1] p = p[p.strip().rfind("/") + 1:] if not p.endswith("/"): p += "/" return p def getBranchMapping(self): lostAndFoundBranches = set() user = gitConfig("git-p4.branchUser") if len(user) > 0: command = "branches -u %s" % user else: command = "branches" for info in p4CmdList(command): details = p4Cmd(["branch", "-o", info["branch"]]) viewIdx = 0 while details.has_key("View%s" % viewIdx): paths = details["View%s" % viewIdx].split(" ") viewIdx = viewIdx + 1 # require standard //depot/foo/... //depot/bar/... mapping if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."): continue source = paths[0] destination = paths[1] ## HACK if p4PathStartsWith(source, self.depotPaths[0]) and p4PathStartsWith(destination, self.depotPaths[0]): source = source[len(self.depotPaths[0]):-4] destination = destination[len(self.depotPaths[0]):-4] if destination in self.knownBranches: if not self.silent: print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination) print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination) continue self.knownBranches[destination] = source lostAndFoundBranches.discard(destination) if source not in self.knownBranches: lostAndFoundBranches.add(source) # Perforce does not strictly require branches to be defined, so we also # check git config for a branch list. # # Example of branch definition in git config file: # [git-p4] # branchList=main:branchA # branchList=main:branchB # branchList=branchA:branchC configBranches = gitConfigList("git-p4.branchList") for branch in configBranches: if branch: (source, destination) = branch.split(":") self.knownBranches[destination] = source lostAndFoundBranches.discard(destination) if source not in self.knownBranches: lostAndFoundBranches.add(source) for branch in lostAndFoundBranches: self.knownBranches[branch] = branch def getBranchMappingFromGitBranches(self): branches = p4BranchesInGit(self.importIntoRemotes) for branch in branches.keys(): if branch == "master": branch = "main" else: branch = branch[len(self.projectName):] self.knownBranches[branch] = branch def updateOptionDict(self, d): option_keys = {} if self.keepRepoPath: option_keys['keepRepoPath'] = 1 d["options"] = ' '.join(sorted(option_keys.keys())) def readOptions(self, d): self.keepRepoPath = (d.has_key('options') and ('keepRepoPath' in d['options'])) def gitRefForBranch(self, branch): if branch == "main": return self.refPrefix + "master" if len(branch) <= 0: return branch return self.refPrefix + self.projectName + branch def gitCommitByP4Change(self, ref, change): if self.verbose: print "looking in ref " + ref + " for change %s using bisect..." % change earliestCommit = "" latestCommit = parseRevision(ref) while True: if self.verbose: print "trying: earliest %s latest %s" % (earliestCommit, latestCommit) next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip() if len(next) == 0: if self.verbose: print "argh" return "" log = extractLogMessageFromGitCommit(next) settings = extractSettingsGitLog(log) currentChange = int(settings['change']) if self.verbose: print "current change %s" % currentChange if currentChange == change: if self.verbose: print "found %s" % next return next if currentChange < change: earliestCommit = "^%s" % next else: latestCommit = "%s" % next return "" def importNewBranch(self, branch, maxChange): # make fast-import flush all changes to disk and update the refs using the checkpoint # command so that we can try to find the branch parent in the git history self.gitStream.write("checkpoint\n\n"); self.gitStream.flush(); branchPrefix = self.depotPaths[0] + branch + "/" range = "@1,%s" % maxChange #print "prefix" + branchPrefix changes = p4ChangesForPaths([branchPrefix], range) if len(changes) <= 0: return False firstChange = changes[0] #print "first change in branch: %s" % firstChange sourceBranch = self.knownBranches[branch] sourceDepotPath = self.depotPaths[0] + sourceBranch sourceRef = self.gitRefForBranch(sourceBranch) #print "source " + sourceBranch branchParentChange = int(p4Cmd(["changes", "-m", "1", "%s...@1,%s" % (sourceDepotPath, firstChange)])["change"]) #print "branch parent: %s" % branchParentChange gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange) if len(gitParent) > 0: self.initialParents[self.gitRefForBranch(branch)] = gitParent #print "parent git commit: %s" % gitParent self.importChanges(changes) return True def searchParent(self, parent, branch, target): parentFound = False for blob in read_pipe_lines(["git", "rev-list", "--reverse", "--no-merges", parent]): blob = blob.strip() if len(read_pipe(["git", "diff-tree", blob, target])) == 0: parentFound = True if self.verbose: print "Found parent of %s in commit %s" % (branch, blob) break if parentFound: return blob else: return None def importChanges(self, changes): cnt = 1 for change in changes: description = p4_describe(change) self.updateOptionDict(description) if not self.silent: sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes))) sys.stdout.flush() cnt = cnt + 1 try: if self.detectBranches: branches = self.splitFilesIntoBranches(description) for branch in branches.keys(): ## HACK --hwn branchPrefix = self.depotPaths[0] + branch + "/" self.branchPrefixes = [ branchPrefix ] parent = "" filesForCommit = branches[branch] if self.verbose: print "branch is %s" % branch self.updatedBranches.add(branch) if branch not in self.createdBranches: self.createdBranches.add(branch) parent = self.knownBranches[branch] if parent == branch: parent = "" else: fullBranch = self.projectName + branch if fullBranch not in self.p4BranchesInGit: if not self.silent: print("\n Importing new branch %s" % fullBranch); if self.importNewBranch(branch, change - 1): parent = "" self.p4BranchesInGit.append(fullBranch) if not self.silent: print("\n Resuming with change %s" % change); if self.verbose: print "parent determined through known branches: %s" % parent branch = self.gitRefForBranch(branch) parent = self.gitRefForBranch(parent) if self.verbose: print "looking for initial parent for %s; current parent is %s" % (branch, parent) if len(parent) == 0 and branch in self.initialParents: parent = self.initialParents[branch] del self.initialParents[branch] blob = None if len(parent) > 0: tempBranch = "%s/%d" % (self.tempBranchLocation, change) if self.verbose: print "Creating temporary branch: " + tempBranch self.commit(description, filesForCommit, tempBranch) self.tempBranches.append(tempBranch) self.checkpoint() blob = self.searchParent(parent, branch, tempBranch) if blob: self.commit(description, filesForCommit, branch, blob) else: if self.verbose: print "Parent of %s not found. Committing into head of %s" % (branch, parent) self.commit(description, filesForCommit, branch, parent) else: files = self.extractFilesFromCommit(description) self.commit(description, files, self.branch, self.initialParent) # only needed once, to connect to the previous commit self.initialParent = "" except IOError: print self.gitError.read() sys.exit(1) def importHeadRevision(self, revision): print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch) details = {} details["user"] = "git perforce import user" details["desc"] = ("Initial import of %s from the state at revision %s\n" % (' '.join(self.depotPaths), revision)) details["change"] = revision newestRevision = 0 fileCnt = 0 fileArgs = ["%s...%s" % (p,revision) for p in self.depotPaths] for info in p4CmdList(["files"] + fileArgs): if 'code' in info and info['code'] == 'error': sys.stderr.write("p4 returned an error: %s\n" % info['data']) if info['data'].find("must refer to client") >= 0: sys.stderr.write("This particular p4 error is misleading.\n") sys.stderr.write("Perhaps the depot path was misspelled.\n"); sys.stderr.write("Depot path: %s\n" % " ".join(self.depotPaths)) sys.exit(1) if 'p4ExitCode' in info: sys.stderr.write("p4 exitcode: %s\n" % info['p4ExitCode']) sys.exit(1) change = int(info["change"]) if change > newestRevision: newestRevision = change if info["action"] in self.delete_actions: # don't increase the file cnt, otherwise details["depotFile123"] will have gaps! #fileCnt = fileCnt + 1 continue for prop in ["depotFile", "rev", "action", "type" ]: details["%s%s" % (prop, fileCnt)] = info[prop] fileCnt = fileCnt + 1 details["change"] = newestRevision # Use time from top-most change so that all git p4 clones of # the same p4 repo have the same commit SHA1s. res = p4_describe(newestRevision) details["time"] = res["time"] self.updateOptionDict(details) try: self.commit(details, self.extractFilesFromCommit(details), self.branch) except IOError: print "IO error with git fast-import. Is your git version recent enough?" print self.gitError.read() def run(self, args): self.depotPaths = [] self.changeRange = "" self.previousDepotPaths = [] self.hasOrigin = False # map from branch depot path to parent branch self.knownBranches = {} self.initialParents = {} if self.importIntoRemotes: self.refPrefix = "refs/remotes/p4/" else: self.refPrefix = "refs/heads/p4/" if self.syncWithOrigin: self.hasOrigin = originP4BranchesExist() if self.hasOrigin: if not self.silent: print 'Syncing with origin first, using "git fetch origin"' system("git fetch origin") branch_arg_given = bool(self.branch) if len(self.branch) == 0: self.branch = self.refPrefix + "master" if gitBranchExists("refs/heads/p4") and self.importIntoRemotes: system("git update-ref %s refs/heads/p4" % self.branch) system("git branch -D p4") # accept either the command-line option, or the configuration variable if self.useClientSpec: # will use this after clone to set the variable self.useClientSpec_from_options = True else: if gitConfigBool("git-p4.useclientspec"): self.useClientSpec = True if self.useClientSpec: self.clientSpecDirs = getClientSpec() # TODO: should always look at previous commits, # merge with previous imports, if possible. if args == []: if self.hasOrigin: createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent) # branches holds mapping from branch name to sha1 branches = p4BranchesInGit(self.importIntoRemotes) # restrict to just this one, disabling detect-branches if branch_arg_given: short = self.branch.split("/")[-1] if short in branches: self.p4BranchesInGit = [ short ] else: self.p4BranchesInGit = branches.keys() if len(self.p4BranchesInGit) > 1: if not self.silent: print "Importing from/into multiple branches" self.detectBranches = True for branch in branches.keys(): self.initialParents[self.refPrefix + branch] = \ branches[branch] if self.verbose: print "branches: %s" % self.p4BranchesInGit p4Change = 0 for branch in self.p4BranchesInGit: logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch) settings = extractSettingsGitLog(logMsg) self.readOptions(settings) if (settings.has_key('depot-paths') and settings.has_key ('change')): change = int(settings['change']) + 1 p4Change = max(p4Change, change) depotPaths = sorted(settings['depot-paths']) if self.previousDepotPaths == []: self.previousDepotPaths = depotPaths else: paths = [] for (prev, cur) in zip(self.previousDepotPaths, depotPaths): prev_list = prev.split("/") cur_list = cur.split("/") for i in range(0, min(len(cur_list), len(prev_list))): if cur_list[i] <> prev_list[i]: i = i - 1 break paths.append ("/".join(cur_list[:i + 1])) self.previousDepotPaths = paths if p4Change > 0: self.depotPaths = sorted(self.previousDepotPaths) self.changeRange = "@%s,#head" % p4Change if not self.silent and not self.detectBranches: print "Performing incremental import into %s git branch" % self.branch # accept multiple ref name abbreviations: # refs/foo/bar/branch -> use it exactly # p4/branch -> prepend refs/remotes/ or refs/heads/ # branch -> prepend refs/remotes/p4/ or refs/heads/p4/ if not self.branch.startswith("refs/"): if self.importIntoRemotes: prepend = "refs/remotes/" else: prepend = "refs/heads/" if not self.branch.startswith("p4/"): prepend += "p4/" self.branch = prepend + self.branch if len(args) == 0 and self.depotPaths: if not self.silent: print "Depot paths: %s" % ' '.join(self.depotPaths) else: if self.depotPaths and self.depotPaths != args: print ("previous import used depot path %s and now %s was specified. " "This doesn't work!" % (' '.join (self.depotPaths), ' '.join (args))) sys.exit(1) self.depotPaths = sorted(args) revision = "" self.users = {} # Make sure no revision specifiers are used when --changesfile # is specified. bad_changesfile = False if len(self.changesFile) > 0: for p in self.depotPaths: if p.find("@") >= 0 or p.find("#") >= 0: bad_changesfile = True break if bad_changesfile: die("Option --changesfile is incompatible with revision specifiers") newPaths = [] for p in self.depotPaths: if p.find("@") != -1: atIdx = p.index("@") self.changeRange = p[atIdx:] if self.changeRange == "@all": self.changeRange = "" elif ',' not in self.changeRange: revision = self.changeRange self.changeRange = "" p = p[:atIdx] elif p.find("#") != -1: hashIdx = p.index("#") revision = p[hashIdx:] p = p[:hashIdx] elif self.previousDepotPaths == []: # pay attention to changesfile, if given, else import # the entire p4 tree at the head revision if len(self.changesFile) == 0: revision = "#head" p = re.sub ("\.\.\.$", "", p) if not p.endswith("/"): p += "/" newPaths.append(p) self.depotPaths = newPaths # --detect-branches may change this for each branch self.branchPrefixes = self.depotPaths self.loadUserMapFromCache() self.labels = {} if self.detectLabels: self.getLabels(); if self.detectBranches: ## FIXME - what's a P4 projectName ? self.projectName = self.guessProjectName() if self.hasOrigin: self.getBranchMappingFromGitBranches() else: self.getBranchMapping() if self.verbose: print "p4-git branches: %s" % self.p4BranchesInGit print "initial parents: %s" % self.initialParents for b in self.p4BranchesInGit: if b != "master": ## FIXME b = b[len(self.projectName):] self.createdBranches.add(b) self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60)) self.importProcess = subprocess.Popen(["git", "fast-import"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE); self.gitOutput = self.importProcess.stdout self.gitStream = self.importProcess.stdin self.gitError = self.importProcess.stderr if revision: self.importHeadRevision(revision) else: changes = [] if len(self.changesFile) > 0: output = open(self.changesFile).readlines() changeSet = set() for line in output: changeSet.add(int(line)) for change in changeSet: changes.append(change) changes.sort() else: # catch "git p4 sync" with no new branches, in a repo that # does not have any existing p4 branches if len(args) == 0: if not self.p4BranchesInGit: die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.") # The default branch is master, unless --branch is used to # specify something else. Make sure it exists, or complain # nicely about how to use --branch. if not self.detectBranches: if not branch_exists(self.branch): if branch_arg_given: die("Error: branch %s does not exist." % self.branch) else: die("Error: no branch %s; perhaps specify one with --branch." % self.branch) if self.verbose: print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths), self.changeRange) changes = p4ChangesForPaths(self.depotPaths, self.changeRange) if len(self.maxChanges) > 0: changes = changes[:min(int(self.maxChanges), len(changes))] if len(changes) == 0: if not self.silent: print "No changes to import!" else: if not self.silent and not self.detectBranches: print "Import destination: %s" % self.branch self.updatedBranches = set() if not self.detectBranches: if args: # start a new branch self.initialParent = "" else: # build on a previous revision self.initialParent = parseRevision(self.branch) self.importChanges(changes) if not self.silent: print "" if len(self.updatedBranches) > 0: sys.stdout.write("Updated branches: ") for b in self.updatedBranches: sys.stdout.write("%s " % b) sys.stdout.write("\n") if gitConfigBool("git-p4.importLabels"): self.importLabels = True if self.importLabels: p4Labels = getP4Labels(self.depotPaths) gitTags = getGitTags() missingP4Labels = p4Labels - gitTags self.importP4Labels(self.gitStream, missingP4Labels) self.gitStream.close() if self.importProcess.wait() != 0: die("fast-import failed: %s" % self.gitError.read()) self.gitOutput.close() self.gitError.close() # Cleanup temporary branches created during import if self.tempBranches != []: for branch in self.tempBranches: read_pipe("git update-ref -d %s" % branch) os.rmdir(os.path.join(os.environ.get("GIT_DIR", ".git"), self.tempBranchLocation)) # Create a symbolic ref p4/HEAD pointing to p4/<branch> to allow # a convenient shortcut refname "p4". if self.importIntoRemotes: head_ref = self.refPrefix + "HEAD" if not gitBranchExists(head_ref) and gitBranchExists(self.branch): system(["git", "symbolic-ref", head_ref, self.branch]) return True class P4Rebase(Command): def __init__(self): Command.__init__(self) self.options = [ optparse.make_option("--import-labels", dest="importLabels", action="store_true"), ] self.importLabels = False self.description = ("Fetches the latest revision from perforce and " + "rebases the current work (branch) against it") def run(self, args): sync = P4Sync() sync.importLabels = self.importLabels sync.run([]) return self.rebase() def rebase(self): if os.system("git update-index --refresh") != 0: die("Some files in your working directory are modified and different than what is in your index. You can use git update-index <filename> to bring the index up-to-date or stash away all your changes with git stash."); if len(read_pipe("git diff-index HEAD --")) > 0: die("You have uncommitted changes. Please commit them before rebasing or stash them away with git stash."); [upstream, settings] = findUpstreamBranchPoint() if len(upstream) == 0: die("Cannot find upstream branchpoint for rebase") # the branchpoint may be p4/foo~3, so strip off the parent upstream = re.sub("~[0-9]+$", "", upstream) print "Rebasing the current branch onto %s" % upstream oldHead = read_pipe("git rev-parse HEAD").strip() system("git rebase %s" % upstream) system("git diff-tree --stat --summary -M %s HEAD --" % oldHead) return True class P4Clone(P4Sync): def __init__(self): P4Sync.__init__(self) self.description = "Creates a new git repository and imports from Perforce into it" self.usage = "usage: %prog [options] //depot/path[@revRange]" self.options += [ optparse.make_option("--destination", dest="cloneDestination", action='store', default=None, help="where to leave result of the clone"), optparse.make_option("-/", dest="cloneExclude", action="append", type="string", help="exclude depot path"), optparse.make_option("--bare", dest="cloneBare", action="store_true", default=False), ] self.cloneDestination = None self.needsGit = False self.cloneBare = False # This is required for the "append" cloneExclude action def ensure_value(self, attr, value): if not hasattr(self, attr) or getattr(self, attr) is None: setattr(self, attr, value) return getattr(self, attr) def defaultDestination(self, args): ## TODO: use common prefix of args? depotPath = args[0] depotDir = re.sub("(@[^@]*)$", "", depotPath) depotDir = re.sub("(#[^#]*)$", "", depotDir) depotDir = re.sub(r"\.\.\.$", "", depotDir) depotDir = re.sub(r"/$", "", depotDir) return os.path.split(depotDir)[1] def run(self, args): if len(args) < 1: return False if self.keepRepoPath and not self.cloneDestination: sys.stderr.write("Must specify destination for --keep-path\n") sys.exit(1) depotPaths = args if not self.cloneDestination and len(depotPaths) > 1: self.cloneDestination = depotPaths[-1] depotPaths = depotPaths[:-1] self.cloneExclude = ["/"+p for p in self.cloneExclude] for p in depotPaths: if not p.startswith("//"): sys.stderr.write('Depot paths must start with "//": %s\n' % p) return False if not self.cloneDestination: self.cloneDestination = self.defaultDestination(args) print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination) if not os.path.exists(self.cloneDestination): os.makedirs(self.cloneDestination) chdir(self.cloneDestination) init_cmd = [ "git", "init" ] if self.cloneBare: init_cmd.append("--bare") retcode = subprocess.call(init_cmd) if retcode: raise CalledProcessError(retcode, init_cmd) if not P4Sync.run(self, depotPaths): return False # create a master branch and check out a work tree if gitBranchExists(self.branch): system([ "git", "branch", "master", self.branch ]) if not self.cloneBare: system([ "git", "checkout", "-f" ]) else: print 'Not checking out any branch, use ' \ '"git checkout -q -b master <branch>"' # auto-set this variable if invoked with --use-client-spec if self.useClientSpec_from_options: system("git config --bool git-p4.useclientspec true") return True class P4Branches(Command): def __init__(self): Command.__init__(self) self.options = [ ] self.description = ("Shows the git branches that hold imports and their " + "corresponding perforce depot paths") self.verbose = False def run(self, args): if originP4BranchesExist(): createOrUpdateBranchesFromOrigin() cmdline = "git rev-parse --symbolic " cmdline += " --remotes" for line in read_pipe_lines(cmdline): line = line.strip() if not line.startswith('p4/') or line == "p4/HEAD": continue branch = line log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch) settings = extractSettingsGitLog(log) print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"]) return True class HelpFormatter(optparse.IndentedHelpFormatter): def __init__(self): optparse.IndentedHelpFormatter.__init__(self) def format_description(self, description): if description: return description + "\n" else: return "" def printUsage(commands): print "usage: %s <command> [options]" % sys.argv[0] print "" print "valid commands: %s" % ", ".join(commands) print "" print "Try %s <command> --help for command specific help." % sys.argv[0] print "" commands = { "debug" : P4Debug, "submit" : P4Submit, "commit" : P4Submit, "sync" : P4Sync, "rebase" : P4Rebase, "clone" : P4Clone, "rollback" : P4RollBack, "branches" : P4Branches } def main(): if len(sys.argv[1:]) == 0: printUsage(commands.keys()) sys.exit(2) cmdName = sys.argv[1] try: klass = commands[cmdName] cmd = klass() except KeyError: print "unknown command %s" % cmdName print "" printUsage(commands.keys()) sys.exit(2) options = cmd.options cmd.gitdir = os.environ.get("GIT_DIR", None) args = sys.argv[2:] options.append(optparse.make_option("--verbose", "-v", dest="verbose", action="store_true")) if cmd.needsGit: options.append(optparse.make_option("--git-dir", dest="gitdir")) parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName), options, description = cmd.description, formatter = HelpFormatter()) (cmd, args) = parser.parse_args(sys.argv[2:], cmd); global verbose verbose = cmd.verbose if cmd.needsGit: if cmd.gitdir == None: cmd.gitdir = os.path.abspath(".git") if not isValidGitDir(cmd.gitdir): cmd.gitdir = read_pipe("git rev-parse --git-dir").strip() if os.path.exists(cmd.gitdir): cdup = read_pipe("git rev-parse --show-cdup").strip() if len(cdup) > 0: chdir(cdup); if not isValidGitDir(cmd.gitdir): if isValidGitDir(cmd.gitdir + "/.git"): cmd.gitdir += "/.git" else: die("fatal: cannot locate git repository at %s" % cmd.gitdir) os.environ["GIT_DIR"] = cmd.gitdir if not cmd.run(args): parser.print_help() sys.exit(2) if __name__ == '__main__': main()
[]
[]
[ "HOME", "P4DIFF", "P4EDITOR", "USERPROFILE", "PWD", "GIT_DIR" ]
[]
["HOME", "P4DIFF", "P4EDITOR", "USERPROFILE", "PWD", "GIT_DIR"]
python
6
0
main.go
package main import ( "context" "encoding/json" "fmt" "io/ioutil" "net/http" "net/url" "os" "os/signal" "sync" "syscall" "time" "github.com/pkg/errors" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" "github.com/sirupsen/logrus" "github.com/spf13/pflag" yaml "gopkg.in/yaml.v2" ) type metricConfiguration struct { Name string `yaml:"name"` Help string `yaml:"help"` JQL string `yaml:"jql"` Interval string `yaml:"interval"` Labels map[string]string `yaml:"labels"` ParsedInterval time.Duration Gauge prometheus.Gauge } type configuration struct { BaseURL string `yaml:"baseURL"` Login string `yaml:"login"` Password string `yaml:"-"` Metrics []metricConfiguration `yaml:"metrics"` HTTPHeaders map[string]string `yaml:"httpHeaders"` } func loadConfiguration(path string) (*configuration, error) { var data []byte var err error if path == "-" { data, err = ioutil.ReadAll(os.Stdin) } else { data, err = ioutil.ReadFile(path) } if err != nil { return nil, errors.Wrapf(err, "failed to read %s", path) } cfg := &configuration{} if err := yaml.Unmarshal(data, cfg); err != nil { return nil, errors.Wrap(err, "failed to parse config data") } for i := 0; i < len(cfg.Metrics); i++ { // Set a default value of 5 minutes if none has been specified. if cfg.Metrics[i].Interval == "" { cfg.Metrics[i].Interval = "5m" } dur, err := time.ParseDuration(cfg.Metrics[i].Interval) if err != nil { return nil, errors.Wrapf(err, "invalid interval for metric %d", i) } cfg.Metrics[i].ParsedInterval = dur } return cfg, nil } type pagedResponse struct { Total uint64 `json:"total"` } func addHeaders(r *http.Request, headers map[string]string) { for k, v := range headers { r.Header.Set(k, v) } } func check(ctx context.Context, log *logrus.Logger, cfg *configuration, wg *sync.WaitGroup) { for idx, m := range cfg.Metrics { go func(idx int, m metricConfiguration) { timer := time.NewTicker(m.ParsedInterval) params := url.Values{} params.Set("jql", m.JQL) params.Set("maxResults", "0") u := fmt.Sprintf("%s/rest/api/2/search?%s", cfg.BaseURL, params.Encode()) client := http.Client{} defer timer.Stop() loop: for { var resp *http.Response pr := pagedResponse{} log.Debugf("Checking %s", m.Name) r, err := http.NewRequest(http.MethodGet, u, nil) addHeaders(r, cfg.HTTPHeaders) if err != nil { log.WithError(err).Errorf("Failed to create HTTP request with URL = %s", u) goto next } r.SetBasicAuth(cfg.Login, cfg.Password) resp, err = client.Do(r) if err != nil { log.WithError(err).WithField("url", u).Errorf("Failed to execute HTTP request") goto next } if resp.StatusCode != http.StatusOK { resp.Body.Close() log.WithField("url", u).Errorf("HTTP response had status %d instead of 200", resp.StatusCode) goto next } if err := json.NewDecoder(resp.Body).Decode(&pr); err != nil { resp.Body.Close() log.WithError(err).WithField("url", u).Errorf("Failed to parse HTTP response") goto next } resp.Body.Close() cfg.Metrics[idx].Gauge.Set(float64(pr.Total)) log.Debugf("Completed %s: %v", m.Name, pr.Total) next: select { case <-timer.C: case <-ctx.Done(): break loop } } log.Infof("Stopping worker for %s", m.Name) defer wg.Done() }(idx, m) } } func setupGauges(metrics []metricConfiguration) error { for i := 0; i < len(metrics); i++ { metrics[i].Gauge = prometheus.NewGauge(prometheus.GaugeOpts{ Name: fmt.Sprintf("jira_%s", metrics[i].Name), ConstLabels: metrics[i].Labels, Help: metrics[i].Help, }) if err := prometheus.Register(metrics[i].Gauge); err != nil { return err } } return nil } func main() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() log := logrus.New() var configFile string var addr string var verbose bool pflag.StringVar(&configFile, "config", "", "Path to a configuration file") pflag.StringVar(&addr, "http-addr", "127.0.0.1:9300", "Address the HTTP server should be listening on") pflag.BoolVar(&verbose, "verbose", false, "Verbose logging") pflag.Parse() if verbose { log.SetLevel(logrus.DebugLevel) } else { log.SetLevel(logrus.InfoLevel) } if configFile == "" { log.Fatal("Please specify a config file using --config CONFIG_FILE") } cfg, err := loadConfiguration(configFile) if err != nil { log.WithError(err).Fatalf("Failed to load config from %s", configFile) } cfg.Password = os.Getenv("JIRA_PASSWORD") if cfg.Password == "" { log.Fatal("Please specify a JIRA_PASSWORD via environment variable") } if err := setupGauges(cfg.Metrics); err != nil { log.WithError(err).Fatal("Failed to setup gauges") } sigChan := make(chan os.Signal) signal.Notify(sigChan, syscall.SIGINT) httpServer := http.Server{} wg := sync.WaitGroup{} wg.Add(len(cfg.Metrics) + 2) go func() { <-sigChan log.Info("Shutting down...") httpServer.Close() cancel() defer wg.Done() }() go check(ctx, log, cfg, &wg) mux := http.NewServeMux() mux.Handle("/metrics", promhttp.Handler()) httpServer.Handler = mux httpServer.Addr = addr go func() { defer wg.Done() log.Infof("Starting server on %s", addr) if err := httpServer.ListenAndServe(); err != nil { cancel() log.WithError(err).Error("Server stopped") } }() wg.Wait() }
[ "\"JIRA_PASSWORD\"" ]
[]
[ "JIRA_PASSWORD" ]
[]
["JIRA_PASSWORD"]
go
1
0
SIFID/sifid_score.py
#!/usr/bin/env python3 """Calculates ***Single Image*** Frechet Inception Distance (SIFID) to evalulate Single-Image-GANs Code was adapted from: https://github.com/mseitzer/pytorch-fid.git Which was adapted from the TensorFlow implementation of: https://github.com/bioinf-jku/TTUR The FID metric calculates the distance between two distributions of images. The SIFID calculates the distance between the distribution of deep features of a single real image and a single fake image. Copyright 2018 Institute of Bioinformatics, JKU Linz Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import os import pathlib from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter import numpy as np import torch from scipy import linalg #from scipy.misc import imread from matplotlib.pyplot import imread from torch.nn.functional import adaptive_avg_pool2d try: from tqdm import tqdm except ImportError: # If not tqdm is not available, provide a mock version of it def tqdm(x): return x from inception import InceptionV3 import torchvision import numpy import scipy import pickle parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter) parser.add_argument('--path2real', type=str, help=('Path to the real images')) parser.add_argument('--path2fake', type=str, help=('Path to generated images')) parser.add_argument('-c', '--gpu', default='', type=str, help='GPU to use (leave blank for CPU only)') parser.add_argument('--images_suffix', default='jpg', type=str, help='image file suffix') def get_activations(files, model, batch_size=1, dims=64, cuda=False, verbose=False): """Calculates the activations of the pool_3 layer for all images. Params: -- files : List of image files paths -- model : Instance of inception model -- batch_size : Batch size of images for the model to process at once. Make sure that the number of samples is a multiple of the batch size, otherwise some samples are ignored. This behavior is retained to match the original FID score implementation. -- dims : Dimensionality of features returned by Inception -- cuda : If set to True, use GPU -- verbose : If set to True and parameter out_step is given, the number of calculated batches is reported. Returns: -- A numpy array of dimension (num images, dims) that contains the activations of the given tensor when feeding inception with the query tensor. """ model.eval() if len(files) % batch_size != 0: print(('Warning: number of images is not a multiple of the ' 'batch size. Some samples are going to be ignored.')) if batch_size > len(files): print(('Warning: batch size is bigger than the data size. ' 'Setting batch size to data size')) batch_size = len(files) n_batches = len(files) // batch_size n_used_imgs = n_batches * batch_size pred_arr = np.empty((n_used_imgs, dims)) for i in tqdm(range(n_batches)): if verbose: print('\rPropagating batch %d/%d' % (i + 1, n_batches), end='', flush=True) start = i * batch_size end = start + batch_size images = np.array([imread(str(f)).astype(np.float32) for f in files[start:end]]) images = images[:,:,:,0:3] # Reshape to (n_images, 3, height, width) images = images.transpose((0, 3, 1, 2)) #images = images[0,:,:,:] images /= 255 batch = torch.from_numpy(images).type(torch.FloatTensor) if cuda: batch = batch.cuda() pred = model(batch)[0] # If model output is not scalar, apply global spatial average pooling. # This happens if you choose a dimensionality not equal 2048. #if pred.shape[2] != 1 or pred.shape[3] != 1: # pred = adaptive_avg_pool2d(pred, output_size=(1, 1)) pred_arr = pred.cpu().data.numpy().transpose(0, 2, 3, 1).reshape(batch_size*pred.shape[2]*pred.shape[3],-1) if verbose: print(' done') return pred_arr def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6): """Numpy implementation of the Frechet Distance. The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1) and X_2 ~ N(mu_2, C_2) is d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)). Stable version by Dougal J. Sutherland. Params: -- mu1 : Numpy array containing the activations of a layer of the inception net (like returned by the function 'get_predictions') for generated samples. -- mu2 : The sample mean over activations, precalculated on an representative data set. -- sigma1: The covariance matrix over activations for generated samples. -- sigma2: The covariance matrix over activations, precalculated on an representative data set. Returns: -- : The Frechet Distance. """ mu1 = np.atleast_1d(mu1) mu2 = np.atleast_1d(mu2) sigma1 = np.atleast_2d(sigma1) sigma2 = np.atleast_2d(sigma2) assert mu1.shape == mu2.shape, \ 'Training and test mean vectors have different lengths' assert sigma1.shape == sigma2.shape, \ 'Training and test covariances have different dimensions' diff = mu1 - mu2 # Product might be almost singular covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False) if not np.isfinite(covmean).all(): msg = ('fid calculation produces singular product; ' 'adding %s to diagonal of cov estimates') % eps print(msg) offset = np.eye(sigma1.shape[0]) * eps covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset)) # Numerical error might give slight imaginary component if np.iscomplexobj(covmean): if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3): m = np.max(np.abs(covmean.imag)) raise ValueError('Imaginary component {}'.format(m)) covmean = covmean.real tr_covmean = np.trace(covmean) return (diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean) def calculate_activation_statistics(files, model, batch_size=1, dims=64, cuda=False, verbose=False): """Calculation of the statistics used by the FID. Params: -- files : List of image files paths -- model : Instance of inception model -- batch_size : The images numpy array is split into batches with batch size batch_size. A reasonable batch size depends on the hardware. -- dims : Dimensionality of features returned by Inception -- cuda : If set to True, use GPU -- verbose : If set to True and parameter out_step is given, the number of calculated batches is reported. Returns: -- mu : The mean over samples of the activations of the inception model. -- sigma : The covariance matrix of the activations of the inception model. """ act = get_activations(files, model, batch_size, dims, cuda, verbose) mu = np.mean(act, axis=0) sigma = np.cov(act, rowvar=False) return mu, sigma def _compute_statistics_of_path(files, model, batch_size, dims, cuda): if path.endswith('.npz'): f = np.load(path) m, s = f['mu'][:], f['sigma'][:] f.close() else: path = pathlib.Path(path) files = list(path.glob('*.jpg'))+ list(path.glob('*.png')) m, s = calculate_activation_statistics(files, model, batch_size, dims, cuda) return m, s def calculate_sifid_given_paths(path1, path2, batch_size, cuda, dims, suffix): """Calculates the SIFID of two paths""" block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[dims] model = InceptionV3([block_idx]) if cuda: model.cuda() path1 = pathlib.Path(path1) files1 = list(path1.glob('*.%s' %suffix)) path2 = pathlib.Path(path2) files2 = list(path2.glob('*.%s' %suffix)) print(path1) print(files1) fid_values = [] Im_ind = [] for i in range(len(files2)): m1, s1 = calculate_activation_statistics([files1[i]], model, batch_size, dims, cuda) m2, s2 = calculate_activation_statistics([files2[i]], model, batch_size, dims, cuda) fid_values.append(calculate_frechet_distance(m1, s1, m2, s2)) file_num1 = files1[i].name file_num2 = files2[i].name Im_ind.append(int(file_num1[:-4])) Im_ind.append(int(file_num2[:-4])) return fid_values if __name__ == '__main__': args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu path1 = args.path2real path2 = args.path2fake suffix = args.images_suffix sifid_values = calculate_sifid_given_paths(path1,path2,1,args.gpu!='',64,suffix) sifid_values = np.asarray(sifid_values,dtype=np.float32) numpy.save('SIFID', sifid_values) print('SIFID: ', sifid_values.mean())
[]
[]
[ "CUDA_VISIBLE_DEVICES" ]
[]
["CUDA_VISIBLE_DEVICES"]
python
1
0
client/foundries.go
package client import ( "bytes" "crypto/tls" "crypto/x509" "encoding/base64" "encoding/json" "fmt" "io/ioutil" "net/http" "os" "strconv" "strings" "time" "github.com/sirupsen/logrus" tuf "github.com/theupdateframework/notary/tuf/data" ) type Config struct { Factory string Token string ClientCredentials OAuthConfig } type Api struct { serverUrl string config Config client http.Client } type NetInfo struct { Hostname string `json:"hostname"` Ipv4 string `json:"local_ipv4"` MAC string `json:"mac"` } type Update struct { CorrelationId string `json:"correlation-id"` Target string `json:"target"` Version string `json:"version"` Time string `json:"time"` } type UpdateList struct { Updates []Update `json:"updates"` Total int `json:"total"` Next *string `json:"next"` } type EventType struct { Id string `json:"id"` } type EventDetail struct { Version string `json:"version"` TargetName string `json:"targetName"` Success *bool `json:"success,omitempty"` } type UpdateEvent struct { Time string `json:"deviceTime"` Type EventType `json:"eventType"` Detail EventDetail `json:"event"` } type Device struct { Uuid string `json:"uuid"` Name string `json:"name"` Owner string `json:"owner"` Factory string `json:"factory"` CreatedAt string `json:"created-at"` LastSeen string `json:"last-seen"` OstreeHash string `json:"ostree-hash"` DockerApps []string `json:"docker-apps,omitempty"` Tags []string `json:"device-tags,omitempty"` Network *NetInfo `json:"network-info,omitempty"` Hardware *json.RawMessage `json:"hardware-info,omitempty"` TargetName string `json:"target-name"` Status string `json:"status"` CurrentUpdate string `json:"current-update"` UpToDate bool `json:"up-to-date"` PublicKey string `json:"public-key"` } type DeviceList struct { Devices []Device `json:"devices"` Total int `json:"total"` Next *string `json:"next"` } type DockerApp struct { FileName string `json:"filename"` Uri string `json:"uri"` } type FactoryUser struct { PolisId string `json:"polis-id"` Name string `json:"name"` Role string `json:"role"` } type ProjectSecret struct { Name string `json:"name"` Value *string `json:"value"` } type ProjectTrigger struct { Type string `json:"type"` Id int `json:"id,omitempty"` Secrets []ProjectSecret `json:"secrets"` } type TufCustom struct { HardwareIds []string `json:"hardwareIds,omitempty"` Tags []string `json:"tags,omitempty"` TargetFormat string `json:"targetFormat,omitempty"` Version string `json:"version,omitempty"` DockerApps map[string]DockerApp `json:"docker_apps,omitempty"` Name string `json:"name,omitempty"` } func NewApiClient(serverUrl string, config Config, caCertPath string) *Api { var tlsConfig *tls.Config if len(caCertPath) > 0 { rootCAs, _ := x509.SystemCertPool() if rootCAs == nil { rootCAs = x509.NewCertPool() } certs, err := ioutil.ReadFile(caCertPath) if err != nil { logrus.Fatalf("Failed to append %q to RootCAs: %v", caCertPath, err) } if ok := rootCAs.AppendCertsFromPEM(certs); !ok { logrus.Warning("No certs appended, using system certs only") } tlsConfig = &tls.Config{ RootCAs: rootCAs, } } api := Api{ serverUrl: strings.TrimRight(serverUrl, "/"), config: config, client: http.Client{ Timeout: time.Second * 10, Transport: &http.Transport{ TLSClientConfig: tlsConfig, }, }, } return &api } func (a *Api) setReqHeaders(req *http.Request, jsonContent bool) { req.Header.Set("User-Agent", "fioctl") if len(a.config.Token) > 0 { logrus.Debug("Using API token for http request") headerName := os.Getenv("TOKEN_HEADER") if len(headerName) == 0 { headerName = "OSF-TOKEN" } req.Header.Set(headerName, a.config.Token) } if len(a.config.ClientCredentials.AccessToken) > 0 { logrus.Debug("Using oauth token for http request") tok := base64.StdEncoding.EncodeToString([]byte(a.config.ClientCredentials.AccessToken)) req.Header.Set("Authorization", "Bearer "+tok) } if jsonContent { req.Header.Set("Content-Type", "application/json") } } func (a *Api) RawGet(url string, headers *map[string]string) (*http.Response, error) { req, err := http.NewRequest(http.MethodGet, url, nil) if err != nil { return nil, err } a.setReqHeaders(req, false) if headers != nil { for key, val := range *headers { req.Header.Set(key, val) } } return a.client.Do(req) } func (a *Api) Get(url string) (*[]byte, error) { res, err := a.RawGet(url, nil) if err != nil { return nil, err } body, err := ioutil.ReadAll(res.Body) if err != nil { return nil, err } if res.StatusCode != 200 { return nil, fmt.Errorf("Unable to get '%s': HTTP_%d\n=%s", url, res.StatusCode, body) } return &body, nil } func (a *Api) Patch(url string, data []byte) (*[]byte, error) { req, err := http.NewRequest(http.MethodPatch, url, bytes.NewBuffer(data)) if err != nil { return nil, err } a.setReqHeaders(req, true) res, err := a.client.Do(req) if err != nil { return nil, err } body, err := ioutil.ReadAll(res.Body) if err != nil { return nil, err } if res.StatusCode != 202 && res.StatusCode != 200 { return nil, fmt.Errorf("Unable to PATCH '%s': HTTP_%d\n=%s", url, res.StatusCode, body) } return &body, nil } func (a *Api) Post(url string, data []byte) (*[]byte, error) { req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(data)) if err != nil { return nil, err } a.setReqHeaders(req, true) res, err := a.client.Do(req) if err != nil { return nil, err } body, err := ioutil.ReadAll(res.Body) if err != nil { return nil, err } if res.StatusCode != 201 { return nil, fmt.Errorf("Unable to POST '%s': HTTP_%d\n=%s", url, res.StatusCode, body) } return &body, nil } func (a *Api) Put(url string, data []byte) (*[]byte, error) { req, err := http.NewRequest(http.MethodPut, url, bytes.NewBuffer(data)) if err != nil { return nil, err } a.setReqHeaders(req, true) res, err := a.client.Do(req) if err != nil { return nil, err } body, err := ioutil.ReadAll(res.Body) if err != nil { return nil, err } if res.StatusCode != 202 { return nil, fmt.Errorf("Unable to PUT '%s': HTTP_%d\n=%s", url, res.StatusCode, body) } return &body, nil } func (a *Api) Delete(url string, data []byte) (*[]byte, error) { req, err := http.NewRequest(http.MethodDelete, url, bytes.NewBuffer(data)) if err != nil { return nil, err } a.setReqHeaders(req, true) res, err := a.client.Do(req) if err != nil { return nil, err } body, err := ioutil.ReadAll(res.Body) if err != nil { return nil, err } if res.StatusCode != 202 && res.StatusCode != 200 { return nil, fmt.Errorf("Unable to DELETE '%s': HTTP_%d\n=%s", url, res.StatusCode, body) } return &body, nil } func (a *Api) DeviceGet(device string) (*Device, error) { body, err := a.Get(a.serverUrl + "/ota/devices/" + device + "/") if err != nil { return nil, err } d := Device{} err = json.Unmarshal(*body, &d) if err != nil { return nil, err } return &d, nil } func (a *Api) DeviceList(shared bool, matchTag, byFactory, nameIlike string) (*DeviceList, error) { sharedInt := 0 if shared { sharedInt = 1 } url := a.serverUrl + "/ota/devices/?" url += fmt.Sprintf("shared=%d&match_tag=%s&name_ilike=%s&factory=%s", sharedInt, matchTag, nameIlike, byFactory) logrus.Debugf("DeviceList with url: %s", url) return a.DeviceListCont(url) } func (a *Api) DeviceListCont(url string) (*DeviceList, error) { body, err := a.Get(url) if err != nil { return nil, err } devices := DeviceList{} err = json.Unmarshal(*body, &devices) if err != nil { return nil, err } return &devices, nil } func (a *Api) DeviceDelete(device string) error { bytes := []byte{} _, err := a.Delete(a.serverUrl+"/ota/devices/"+device+"/", bytes) return err } func (a *Api) DeviceListUpdates(device string) (*UpdateList, error) { return a.DeviceListUpdatesCont(a.serverUrl + "/ota/devices/" + device + "/updates/") } func (a *Api) DeviceListUpdatesCont(url string) (*UpdateList, error) { body, err := a.Get(url) if err != nil { return nil, err } updates := UpdateList{} err = json.Unmarshal(*body, &updates) if err != nil { return nil, err } return &updates, nil } func (a *Api) DeviceUpdateEvents(device, correlationId string) ([]UpdateEvent, error) { var events []UpdateEvent body, err := a.Get(a.serverUrl + "/ota/devices/" + device + "/updates/" + correlationId + "/") if err != nil { return nil, err } err = json.Unmarshal(*body, &events) if err != nil { return events, err } return events, nil } func (a *Api) TargetsListRaw(factory string) (*[]byte, error) { url := a.serverUrl + "/ota/repo/" + factory + "/api/v1/user_repo/targets.json" return a.Get(url) } func (a *Api) TargetsList(factory string) (*tuf.SignedTargets, error) { body, err := a.TargetsListRaw(factory) if err != nil { return nil, err } targets := tuf.SignedTargets{} err = json.Unmarshal(*body, &targets) if err != nil { return nil, err } return &targets, nil } func (a *Api) TargetCustom(target tuf.FileMeta) (*TufCustom, error) { custom := TufCustom{} err := json.Unmarshal(*target.Custom, &custom) if err != nil { return nil, err } return &custom, nil } func (a *Api) TargetsPut(factory string, data []byte) (string, error) { url := a.serverUrl + "/ota/factories/" + factory + "/targets/" resp, err := a.Put(url, data) if err != nil { return "", err } type PutResp struct { JobServUrl string `json:"jobserv-url"` } pr := PutResp{} if err := json.Unmarshal(*resp, &pr); err != nil { return "", err } return pr.JobServUrl + "runs/UpdateTargets/console.log", nil } func (a *Api) TargetUpdateTags(factory string, target_names []string, tag_names []string) (string, error) { type EmptyTarget struct { Custom TufCustom `json:"custom"` } tags := EmptyTarget{TufCustom{Tags: tag_names}} type Update struct { Targets map[string]EmptyTarget `json:"targets"` } update := Update{map[string]EmptyTarget{}} for idx := range target_names { update.Targets[target_names[idx]] = tags } data, err := json.Marshal(update) if err != nil { return "", err } url := a.serverUrl + "/ota/factories/" + factory + "/targets/" resp, err := a.Patch(url, data) if err != nil { return "", err } type PatchResp struct { JobServUrl string `json:"jobserv-url"` } pr := PatchResp{} if err := json.Unmarshal(*resp, &pr); err != nil { return "", err } return pr.JobServUrl + "runs/UpdateTargets/console.log", nil } func (a *Api) TargetDeleteTargets(factory string, target_names []string) (string, error) { type Update struct { Targets []string `json:"targets"` } update := Update{} update.Targets = target_names data, err := json.Marshal(update) if err != nil { return "", err } url := a.serverUrl + "/ota/factories/" + factory + "/targets/" resp, err := a.Delete(url, data) if err != nil { return "", err } type PatchResp struct { JobServUrl string `json:"jobserv-url"` } pr := PatchResp{} if err := json.Unmarshal(*resp, &pr); err != nil { return "", err } return pr.JobServUrl + "runs/UpdateTargets/console.log", nil } func (a *Api) JobservTail(url string) { offset := 0 status := "" for { headers := map[string]string{"X-OFFSET": strconv.Itoa(offset)} resp, err := a.RawGet(url, &headers) if err != nil { fmt.Printf("TODO LOG ERROR OR SOMETHING: %s\n", err) } body, err := ioutil.ReadAll(resp.Body) if err != nil { fmt.Printf("Unable to read body resp: %s", err) } if resp.StatusCode != 200 { fmt.Printf("Unable to get '%s': HTTP_%d\n=%s", url, resp.StatusCode, body) } newstatus := resp.Header.Get("X-RUN-STATUS") if newstatus == "QUEUED" { if status == "" { os.Stdout.Write(body) } else { os.Stdout.WriteString(".") } } else if len(newstatus) == 0 { body = body[offset:] os.Stdout.Write(body) return } else { if newstatus != status { fmt.Printf("\n--- Status change: %s -> %s\n", status, newstatus) } os.Stdout.Write(body) offset += len(body) } status = newstatus time.Sleep(5 * time.Second) } } func (a *Api) FactoryTriggers(factory string) ([]ProjectTrigger, error) { type Resp struct { Data []ProjectTrigger `json:"data"` } body, err := a.Get(a.serverUrl + "/projects/" + factory + "/lmp/triggers/") if err != nil { return nil, err } r := Resp{} err = json.Unmarshal(*body, &r) return r.Data, err } func (a *Api) FactoryUpdateTrigger(factory string, t ProjectTrigger) error { data, err := json.Marshal(t) if err != nil { return err } url := a.serverUrl + "/projects/" + factory + "/lmp/triggers/" if t.Id == 0 { logrus.Debugf("Creating new trigger") _, err := a.Post(url, data) return err } else { logrus.Debugf("Patching trigger %d", t.Id) url += strconv.Itoa(t.Id) + "/" _, err := a.Patch(url, data) return err } } func (a *Api) UsersList(factory string) ([]FactoryUser, error) { url := a.serverUrl + "/ota/factories/" + factory + "/users/" body, err := a.Get(url) if err != nil { return nil, err } var users []FactoryUser err = json.Unmarshal(*body, &users) if err != nil { return nil, err } return users, nil }
[ "\"TOKEN_HEADER\"" ]
[]
[ "TOKEN_HEADER" ]
[]
["TOKEN_HEADER"]
go
1
0
app/app/settings.py
""" Django settings for app project. Generated by 'django-admin startproject' using Django 3.1.5. For more information on this file, see https://docs.djangoproject.com/en/3.1/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/3.1/ref/settings/ """ import os from pathlib import Path from datetime import datetime, timedelta # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 'd&q0zfz5j!sm!a4_krfuvp!7nu$r$f(1p$6^1vrwq5p9lx(*lw' API_URL = os.environ.get('API_URL','http://localhost:8080') MARVEL_PUBLIC_KEY = os.environ.get('MARVEL_PUBLIC_KEY','57422c4803fb8c8b6625b7f8b6151a6f') MARVEL_PRIVATE_KEY = os.environ.get('MARVEL_PRIVATE_KEY','90c5754f8927c87bb7e1190fba1092978ed095dc') # SECURITY WARNING: don't run with debug turned on in production! ENV_DEBUG = os.environ.get('DEBUG', 'true') DEBUG = ENV_DEBUG == 'true' ALLOWED_HOSTS = ['*'] CORS_ORIGIN_ALLOW_ALL = True # Application definition INSTALLED_APPS = [ 'corsheaders', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'rest_framework', 'drf_yasg', 'api', ] MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'whitenoise.middleware.WhiteNoiseMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'corsheaders.middleware.CorsMiddleware', 'django.middleware.common.CommonMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ] ROOT_URLCONF = 'app.urls' TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'app.wsgi.application' # Database # https://docs.djangoproject.com/en/3.1/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': BASE_DIR / 'db.sqlite3', } } HEROKU = bool(os.environ.get('DJANGO_HEROKU', False)) if HEROKU: # Configure Django App for Heroku. import django_heroku django_heroku.settings(locals()) # Password validation # https://docs.djangoproject.com/en/3.1/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', }, { 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', }, { 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', }, { 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', }, ] # Internationalization # https://docs.djangoproject.com/en/3.1/topics/i18n/ LANGUAGE_CODE = 'es-ES' TIME_ZONE = 'America/Bogota' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/3.1/howto/static-files/ STATIC_URL = '/static/' STATIC_ROOT = os.path.join(BASE_DIR, 'static/') # JWT BASIC CONFIGURATION JWT_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9" # Change in production JWT_ALGORITHM = 'HS512' JWT_OPTIONS = {'verify_signature': True, 'verify_exp': True, 'verify_nbf': False, 'verify_iat': True, 'verify_aud': False} SIMPLE_JWT = { 'ACCESS_TOKEN_LIFETIME': timedelta(minutes=int(os.environ.get("ACCESS_TOKEN_LIFETIME_IN_MINUTES", 60))), 'REFRESH_TOKEN_LIFETIME': timedelta(days=int(os.environ.get("REFRESH_TOKEN_LIFETIME_IN_DAYS", 1))), 'ROTATE_REFRESH_TOKENS': False, 'BLACKLIST_AFTER_ROTATION': True, 'ALGORITHM': 'HS256', 'SIGNING_KEY': SECRET_KEY, 'VERIFYING_KEY': None, 'AUDIENCE': None, 'ISSUER': None, 'AUTH_HEADER_TYPES': ('Bearer',), 'USER_ID_FIELD': 'id', 'USER_ID_CLAIM': 'user_id', 'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',), 'TOKEN_TYPE_CLAIM': 'token_type', 'JTI_CLAIM': 'jti', 'SLIDING_TOKEN_REFRESH_EXP_CLAIM': 'refresh_exp', 'SLIDING_TOKEN_LIFETIME': timedelta(minutes=5), 'SLIDING_TOKEN_REFRESH_LIFETIME': timedelta(days=1), } REST_FRAMEWORK = { 'DEFAULT_RENDERER_CLASSES': ( 'rest_framework.renderers.JSONRenderer', ), 'DEFAULT_AUTHENTICATION_CLASSES': [ 'rest_framework_simplejwt.authentication.JWTAuthentication', ], 'DEFAULT_PERMISSION_CLASSES': [ 'rest_framework.permissions.AllowAny', ], 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination', 'PAGE_SIZE': 100 }
[]
[]
[ "MARVEL_PRIVATE_KEY", "MARVEL_PUBLIC_KEY", "ACCESS_TOKEN_LIFETIME_IN_MINUTES", "DJANGO_HEROKU", "DEBUG", "REFRESH_TOKEN_LIFETIME_IN_DAYS", "API_URL" ]
[]
["MARVEL_PRIVATE_KEY", "MARVEL_PUBLIC_KEY", "ACCESS_TOKEN_LIFETIME_IN_MINUTES", "DJANGO_HEROKU", "DEBUG", "REFRESH_TOKEN_LIFETIME_IN_DAYS", "API_URL"]
python
7
0
pgxpool/tx_test.go
package pgxpool_test import ( "context" "os" "testing" "github.com/khaibin/pgx/v4/pgxpool" "github.com/stretchr/testify/require" ) func TestTxExec(t *testing.T) { t.Parallel() pool, err := pgxpool.Connect(context.Background(), os.Getenv("PGX_TEST_DATABASE")) require.NoError(t, err) defer pool.Close() tx, err := pool.Begin(context.Background()) require.NoError(t, err) defer tx.Rollback(context.Background()) testExec(t, tx) } func TestTxQuery(t *testing.T) { t.Parallel() pool, err := pgxpool.Connect(context.Background(), os.Getenv("PGX_TEST_DATABASE")) require.NoError(t, err) defer pool.Close() tx, err := pool.Begin(context.Background()) require.NoError(t, err) defer tx.Rollback(context.Background()) testQuery(t, tx) } func TestTxQueryRow(t *testing.T) { t.Parallel() pool, err := pgxpool.Connect(context.Background(), os.Getenv("PGX_TEST_DATABASE")) require.NoError(t, err) defer pool.Close() tx, err := pool.Begin(context.Background()) require.NoError(t, err) defer tx.Rollback(context.Background()) testQueryRow(t, tx) } func TestTxSendBatch(t *testing.T) { t.Parallel() pool, err := pgxpool.Connect(context.Background(), os.Getenv("PGX_TEST_DATABASE")) require.NoError(t, err) defer pool.Close() tx, err := pool.Begin(context.Background()) require.NoError(t, err) defer tx.Rollback(context.Background()) testSendBatch(t, tx) } func TestTxCopyFrom(t *testing.T) { t.Parallel() pool, err := pgxpool.Connect(context.Background(), os.Getenv("PGX_TEST_DATABASE")) require.NoError(t, err) defer pool.Close() tx, err := pool.Begin(context.Background()) require.NoError(t, err) defer tx.Rollback(context.Background()) testCopyFrom(t, tx) }
[ "\"PGX_TEST_DATABASE\"", "\"PGX_TEST_DATABASE\"", "\"PGX_TEST_DATABASE\"", "\"PGX_TEST_DATABASE\"", "\"PGX_TEST_DATABASE\"" ]
[]
[ "PGX_TEST_DATABASE" ]
[]
["PGX_TEST_DATABASE"]
go
1
0
integration/src/main/java/integration/client/RestClient.java
package integration.client; import integration.server.soap.Endpoint; import org.glassfish.jersey.client.ClientConfig; import javax.ws.rs.client.Client; import javax.ws.rs.client.ClientBuilder; import javax.ws.rs.client.WebTarget; import javax.ws.rs.core.Response; import java.io.IOException; import java.net.URL; import java.util.HashMap; import java.util.Map; import java.util.Properties; public class RestClient { private static String dataApi = ""; private static WebTarget service; static { ClientConfig clientConfig = new ClientConfig(); Client client = ClientBuilder.newClient(clientConfig); service = client.target(getDataApi()); } public static String getDataApi() { String env = System.getenv("ENV"); // This has to be configured in Heroku vars if (dataApi == "") { Properties props = new Properties(); URL propFileUrl = Endpoint.class.getClassLoader().getResource("project.properties"); try { props.load(propFileUrl.openStream()); String environmentName = (env == "" | env == null) ? "local" : env; dataApi = props.getProperty("project.data.api" + "." + environmentName); } catch (IOException e) { e.printStackTrace(); dataApi = ""; } } dataApi = (dataApi.charAt(dataApi.length() - 1) == '/') ? dataApi + "/" : dataApi; System.out.println("Data layer REST API URL set to " + dataApi); return dataApi; } public static WebTarget getService() { return service; } public static Response get(String path, String mediaType, Map<String, Object> params) { WebTarget target = service.path(path); for (Map.Entry<String, Object> entry : params.entrySet()) { target = target.queryParam(entry.getKey(), entry.getValue()); } Response res = target.request(mediaType).accept(mediaType).get(); res.bufferEntity(); // To use readEntity multiple times return res; } public static Response get(String path, String mediaType) { return get(path, mediaType, new HashMap<String, Object>()); } }
[ "\"ENV\"" ]
[]
[ "ENV" ]
[]
["ENV"]
java
1
0
aws-inventory/lambda/inventory-cloudfront.py
import boto3 from botocore.exceptions import ClientError import json import os import time import datetime from dateutil import tz from antiope.aws_account import * from common import * import logging logger = logging.getLogger() logger.setLevel(getattr(logging, os.getenv('LOG_LEVEL', default='INFO'))) logging.getLogger('botocore').setLevel(logging.WARNING) logging.getLogger('boto3').setLevel(logging.WARNING) logging.getLogger('urllib3').setLevel(logging.WARNING) RESOURCE_PATH = "cloudfront/distribution" RESOURCE_TYPE = "AWS::CloudFront::Distribution" def lambda_handler(event, context): set_debug(event, logger) logger.debug("Received event: " + json.dumps(event, sort_keys=True)) message = json.loads(event['Records'][0]['Sns']['Message']) logger.info("Received message: " + json.dumps(message, sort_keys=True)) try: target_account = AWSAccount(message['account_id']) # Cloudfront is a global service cf_client = target_account.get_client('cloudfront') resource_item = {} resource_item['awsAccountId'] = target_account.account_id resource_item['awsAccountName'] = target_account.account_name resource_item['resourceType'] = RESOURCE_TYPE resource_item['source'] = "Antiope" distributions = list_distributions(cf_client, target_account) logger.debug(f"Found {len(distributions)} distributions for account {target_account.account_name}({target_account.account_id}") for distribution in distributions: resource_item['configurationItemCaptureTime'] = str(datetime.datetime.now()) resource_item['configuration'] = distribution resource_item['supplementaryConfiguration'] = {} resource_item['resourceId'] = distribution['Id'] resource_item['resourceName'] = distribution['DomainName'] resource_item['ARN'] = distribution['ARN'] resource_item['errors'] = {} save_resource_to_s3(RESOURCE_PATH, distribution['Id'], resource_item) except AntiopeAssumeRoleError as e: logger.error("Unable to assume role into account {}({})".format(target_account.account_name, target_account.account_id)) return() except ClientError as e: logger.critical("AWS Error getting info for {}: {}".format(message['account_id'], e)) capture_error(message, context, e, "ClientError for {}: {}".format(message['account_id'], e)) raise except Exception as e: logger.critical("{}\nMessage: {}\nContext: {}".format(e, message, vars(context))) capture_error(message, context, e, "General Exception for {}: {}".format(message['account_id'], e)) raise def list_distributions(cf_client, target_account): distributions = [] response = cf_client.list_distributions() while 'NextMarker' in response['DistributionList']: for i in response['DistributionList']['Items']: distributions.append(i) response = cf_client.list_distributions(Marker=response['DistributionList']['NextMarker']) if 'Items' not in response['DistributionList']: return(distributions) for i in response['DistributionList']['Items']: distributions.append(i) return(distributions)
[]
[]
[ "LOG_LEVEL" ]
[]
["LOG_LEVEL"]
python
1
0
java/device/iothub-java-client/src/test/java/tests/integration/com/microsoft/azure/iothub/transport/SendMessagesIT.java
// Copyright (c) Microsoft. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. package tests.integration.com.microsoft.azure.iothub.transport; import com.microsoft.azure.iot.service.exceptions.IotHubException; import com.microsoft.azure.iot.service.sdk.Device; import com.microsoft.azure.iot.service.sdk.RegistryManager; import com.microsoft.azure.iothub.*; import org.junit.*; import tests.integration.com.microsoft.azure.iothub.DeviceConnectionString; import tests.integration.com.microsoft.azure.iothub.EventCallback; import tests.integration.com.microsoft.azure.iothub.Success; import java.io.IOException; import java.net.URISyntaxException; import java.util.Map; import java.util.UUID; public class SendMessagesIT { private static String iotHubonnectionStringEnvVarName = "IOTHUB_CONNECTION_STRING"; private static String iotHubConnectionString = ""; private static RegistryManager registryManager; private static Device deviceHttps; private static Device deviceAmqps; private static Device deviceMqtt; // How much to wait until a message makes it to the server, in milliseconds private Integer sendTimeout = 5000; @BeforeClass public static void setUp() throws Exception { Map<String, String> env = System.getenv(); for (String envName : env.keySet()) { if (envName.equals(iotHubonnectionStringEnvVarName)) { iotHubConnectionString = env.get(envName); } } registryManager = RegistryManager.createFromConnectionString(iotHubConnectionString); String uuid = UUID.randomUUID().toString(); String deviceIdHttps = "java-device-client-e2e-test-https".concat("-" + uuid); String deviceIdAmqps = "java-device-client-e2e-test-amqps".concat("-" + uuid); String deviceIdMqtt = "java-device-client-e2e-test-mqtt".concat("-" + uuid); deviceHttps = Device.createFromId(deviceIdHttps, null, null); deviceAmqps = Device.createFromId(deviceIdAmqps, null, null); deviceMqtt = Device.createFromId(deviceIdMqtt, null, null); registryManager.addDevice(deviceHttps); registryManager.addDevice(deviceAmqps); registryManager.addDevice(deviceMqtt); } @AfterClass public static void TearDown() throws IOException, IotHubException { registryManager.removeDevice(deviceHttps.getDeviceId()); registryManager.removeDevice(deviceAmqps.getDeviceId()); registryManager.removeDevice(deviceMqtt.getDeviceId()); } @Test public void SendMessagesOverHttps() throws URISyntaxException, IOException { String messageString = "Java client e2e test message over Https protocol"; Message msg = new Message(messageString); DeviceClient client = new DeviceClient(DeviceConnectionString.get(iotHubConnectionString, deviceHttps), IotHubClientProtocol.HTTPS); client.open(); for (int i = 0; i < 3; ++i) { try { Success messageSent = new Success(); EventCallback callback = new EventCallback(); client.sendEventAsync(msg, callback, messageSent); Integer waitDuration = 0; while(true) { Thread.sleep(100); waitDuration += 100; if (messageSent.getResult() || waitDuration > sendTimeout) { break; } } if (!messageSent.getResult()) { Assert.fail("Sending message over HTTPS protocol failed"); } } catch (Exception e) { Assert.fail("Sending message over HTTPS protocol failed"); } } client.close(); } @Test public void SendMessagesOverAmqps() throws URISyntaxException, IOException, InterruptedException { String messageString = "Java client e2e test message over Amqps protocol"; Message msg = new Message(messageString); DeviceClient client = new DeviceClient(DeviceConnectionString.get(iotHubConnectionString, deviceAmqps), IotHubClientProtocol.AMQPS); client.open(); for (int i = 0; i < 3; ++i) { try { Success messageSent = new Success(); EventCallback callback = new EventCallback(); client.sendEventAsync(msg, callback, messageSent); Integer waitDuration = 0; while(true) { Thread.sleep(100); if (messageSent.getResult() || waitDuration > sendTimeout) { break; } } if (!messageSent.getResult()) { Assert.fail("Sending message over AMQPS protocol failed"); } } catch (Exception e) { Assert.fail("Sending message over AMQPS protocol failed"); } } client.close(); } @Test public void SendMessagesOverMqtt() throws URISyntaxException, IOException { String messageString = "Java client e2e test message over Mqtt protocol"; Message msg = new Message(messageString); DeviceClient client = new DeviceClient(DeviceConnectionString.get(iotHubConnectionString, deviceMqtt), IotHubClientProtocol.MQTT); client.open(); for (int i = 0; i < 3; ++i) { try { Success messageSent = new Success(); EventCallback callback = new EventCallback(); client.sendEventAsync(msg, callback, messageSent); Integer waitDuration = 0; while(true) { Thread.sleep(100); if (messageSent.getResult() || waitDuration > sendTimeout) { break; } } if (!messageSent.getResult()) { Assert.fail("Sending message over MQTT protocol failed"); } } catch (Exception e) { Assert.fail("Sending message over MQTT protocol failed"); } } client.close(); } }
[]
[]
[]
[]
[]
java
0
0
database/database.go
package database import ( "golang-products-api/database/migrations" "log" "os" "time" "github.com/joho/godotenv" "gorm.io/driver/postgres" "gorm.io/gorm" ) var database *gorm.DB func StartDatabase() { database = createDatabaseInstance() configureDatabase() } func createDatabaseInstance() *gorm.DB { godotenv.Load(".env") databaseHost := os.Getenv("DB_HOST") databasePort := os.Getenv("DB_PORT") databaseUser := os.Getenv("DB_USER") databasePassword := os.Getenv("DB_PASSWORD") databaseName := os.Getenv("DB_DATABASE") databaseConnectionUrl := "host=" + databaseHost + " port=" + databasePort + " user=" + databaseUser + " dbname=" + databaseName + " password=" + databasePassword + " sslmode=disable" createdDatabase, errorFromDatabaseOpen := gorm.Open(postgres.Open(databaseConnectionUrl), &gorm.Config{}) if errorFromDatabaseOpen != nil { log.Fatal("Failed to create the database: ", errorFromDatabaseOpen) } return createdDatabase } func configureDatabase() { config, errorFromConfig := database.DB() if errorFromConfig != nil { log.Fatal("Failed to configure the database: ", errorFromConfig) } config.SetMaxIdleConns(10) config.SetMaxOpenConns(100) config.SetConnMaxLifetime(time.Hour) migrations.RunMigrations(database) } func GetDatabase() *gorm.DB { return database }
[ "\"DB_HOST\"", "\"DB_PORT\"", "\"DB_USER\"", "\"DB_PASSWORD\"", "\"DB_DATABASE\"" ]
[]
[ "DB_PASSWORD", "DB_HOST", "DB_PORT", "DB_DATABASE", "DB_USER" ]
[]
["DB_PASSWORD", "DB_HOST", "DB_PORT", "DB_DATABASE", "DB_USER"]
go
5
0
truenas/provider_test.go
package truenas import ( "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "log" "os" "testing" ) var testAccProviders map[string]*schema.Provider var testAccProvider *schema.Provider const testResourcePrefix = "tf-acc-test" var testPoolName string func init() { testAccProvider = Provider() testAccProviders = map[string]*schema.Provider{ "truenas": testAccProvider, } if v := os.Getenv("TRUENAS_POOL_NAME"); v != "" { testPoolName = v } if testPoolName == "" { log.Printf("[WARN] Env TRUENAS_POOL_NAME was not specified, using default 'Tank'") testPoolName = "Tank" } } func testAccPreCheck(t *testing.T) { if v := os.Getenv("TRUENAS_API_KEY"); v == "" { t.Fatal("TRUENAS_API_KEY must be set for acceptance tests") } if v := os.Getenv("TRUENAS_BASE_URL"); v == "" { t.Fatal("TRUENAS_BASE_URL must be set for acceptance tests") } }
[ "\"TRUENAS_POOL_NAME\"", "\"TRUENAS_API_KEY\"", "\"TRUENAS_BASE_URL\"" ]
[]
[ "TRUENAS_BASE_URL", "TRUENAS_POOL_NAME", "TRUENAS_API_KEY" ]
[]
["TRUENAS_BASE_URL", "TRUENAS_POOL_NAME", "TRUENAS_API_KEY"]
go
3
0
dbinflux/dbinflux.py
#!/usr/bin/env python # -*- coding: utf-8 -*- """Provide some extra functions to work with InfluxDB.""" import argparse import copy import csv import os import logging import time from influxdb import InfluxDBClient from influxdb.exceptions import InfluxDBClientError, InfluxDBServerError def connect(config: dict) -> InfluxDBClient: """Connect to the InfluxDB with given config :param config: Dictionary (or object with dictionary interface) in format: {'host': 'localhost', 'port': 8086, 'timeout': 5, 'username': 'username', 'password': 'password', 'database': 'database'} or in format: {'INFLUXDB_HOST': 'localhost', 'INFLUXDB_PORT': 8086, 'INFLUXDB_TIMEOUT': 5, 'INFLUXDB_USERNAME': 'username', 'INFLUXDB_PASSWORD': 'password', 'INFLUXDB_DATABASE': 'database'} """ host = config['host'] if 'host' in config else \ config['INFLUXDB_HOST'] if 'INFLUXDB_HOST' in config else 'localhost' port = int(config['port']) if 'port' in config else \ int(config['INFLUXDB_PORT']) if 'INFLUXDB_PORT' in config else 8086 timeout = int(config['timeout']) if 'timeout' in config else \ int(config['INFLUXDB_TIMEOUT']) if 'INFLUXDB_TIMEOUT' in config else 5 username = config['username'] if 'username' in config else config['INFLUXDB_USERNAME'] password = config['password'] if 'password' in config else config['INFLUXDB_PASSWORD'] database = config['database'] if 'database' in config else config['INFLUXDB_DATABASE'] return InfluxDBClient(host=host, port=port, username=username, password=password, database=database, timeout=timeout) def dump_measurement_csv(client, measurement, chunk_size=500, logger=None, show_cli_cmd=False): """Dump given measurement to csv file""" if not logger: logging.basicConfig(level=logging.INFO) logger = logging.getLogger() query = "SELECT * FROM {}".format(measurement) if show_cli_cmd: logger.info("0. Stop inserting in measurement '%s'", measurement) logger.info("1. Execute following command in InfluxDB CLI to get same output faster:") logger.info(" influx -database '%s' -username '%s' -password '%s' -execute '%s LIMIT 2' -format csv > " "/tmp/%s.csv", client._database, client._username, client._password, query, measurement) logger.info("2. Execute 1 once again and check files hashes, to be sure no new data was saved during export") logger.info(" Also, you may want count points number with 'wc -l /tmp/%s.csv'", measurement) logger.info("3. Then transform csv file '%s.csv' -> '%s.txt' (line protocol file) with csv2lp() function", measurement, measurement) logger.info(" Also, do any data transformation you want, for example, type conversion, etc") logger.info("4. Drop measurement: DROP MEASUREMENT %s", measurement) logger.info("5. And last, import data back into InfluxDB:") logger.info(" influx -username '%s' -password '%s' -import -pps 10000 -path=%s.txt", client._username, client._password, measurement) logger.info("6. Check new measurement schema with:") logger.info(" influx -database '%s' -username '%s' -password '%s' -execute 'SHOW FIELD KEYS FROM %s'", client._database, client._username, client._password, measurement) logger.info(" influx -database '%s' -username '%s' -password '%s' -execute 'SHOW TAG KEYS FROM %s'", client._database, client._username, client._password, measurement) logger.info(" influx -database '%s' -username '%s' -password '%s' " "-execute 'SHOW TAG VALUES FROM %s WITH KEY IN (...)'", client._database, client._username, client._password, measurement) else: logger.info("Dumping measurement '%s' started...", measurement) logger.info("Start query '%s' with chunk size %d...", query, chunk_size) t0 = time.time() res = client.query(query, chunked=True, chunk_size=chunk_size) t1 = time.time() tdiff = t1-t0 logger.info('End query. Time: %ds (%.2fm)', tdiff, tdiff/60) # @todo finish function (actually dump data) def csv2lp(csv_filepath, tags_keys=None, database=None, retention_policy=None): """Transform given csv file into file protocol file. Run example: csv2lp('/root/bitfinex_ticker.csv', ['symbol'], 'alfadirect', 'alfadirect')""" tags_keys = tags_keys if tags_keys else [] path, filename = os.path.split(csv_filepath) filename_wo_extension = os.path.splitext(os.path.basename(filename))[0] lp_filepath = path + '/' + filename_wo_extension + '.txt' with open(csv_filepath) as csvfile: reader = csv.DictReader(csvfile) with open(lp_filepath, 'w') as lp: if database and retention_policy: lp.write('# DML\n') lp.write('# CONTEXT-DATABASE: {}\n'.format(database)) lp.write('# CONTEXT-RETENTION-POLICY: {}\n\n'.format(retention_policy)) for row in reader: tag_set = [] for tag_key in tags_keys: tag_set.append('{}={}'.format(tag_key, row[tag_key])) tag_set = ','.join(tag_set) field_set = [] excludes = ['name', 'time'] + tags_keys for field_key, field_value in row.items(): if field_key not in excludes: field_set.append('{}={}'.format(field_key, field_value)) field_set = ','.join(field_set) name = row['name'] time = row['time'] lp.write('{},{} {} {}\n'.format(name, tag_set, field_set, time)) def batch_write_points(client, points, time_precision=None): batch_size = 10000 l = len(points) for i in range(0, l, batch_size): end = i + batch_size - 1 end = l if end > l else end client.write_points(points[i:end], time_precision=time_precision) def move_points(source, dest): """This function helps transfer points from one database (and/or measurement) to another one. Here is the demo script using that function: import pylibs source = { 'client': pylibs.connect({ 'host': 'influxdb_source', 'username': 'user1', 'password': 'super_secret_password', 'database': 'some_database' }), 'measurement': 'dockerhub', 'fields': ['field_1', 'field_2', 'another_field'], 'tags': ['tag_1', 'tag_2'] } dest = pylibs.connect({ 'host': 'influxdb_dest', 'username': 'user2', 'password': 'another_super_secret_password', 'database': 'another_database' }) pylibs.move_points(source, dest) :param source: Dictionary with source measurement description. :param dest: Destination client or dictionary with destination measurement description. :return: """ if not isinstance(dest, dict): dest = {'client': dest} if 'client' not in source or 'client' not in dest: print("Source and destinations clients must be passed in!") exit(1) if 'measurement' not in source: print("Source measurement must be passed in!") exit(2) elif 'measurement' not in dest: dest['measurement'] = source['measurement'] res = source['client'].query("SELECT * FROM {}".format(source['measurement'])) points = [] point_template = { "time": None, "measurement": dest['measurement'], "tags": {}, "fields": {}, } for point in res.get_points(): point_raw = copy.deepcopy(point_template) point_raw['time'] = point['time'] for meta_key in ['fields', 'tags']: for key in source[meta_key]: point_raw[meta_key][key] = point[key] points.append(point_raw) batch_write_points(dest['client'], points) def argparse_add_influxdb_options(parser: argparse.ArgumentParser): """Add InfluxDB connection parameters to given parser. Also read environment variables for defaults""" parser.add_argument('--influxdb-host', metavar='HOST', default=os.environ.get('INFLUXDB_HOST', 'localhost'), help='InfluxDB host name') parser.add_argument('--influxdb-port', metavar='PORT', default=os.environ.get('INFLUXDB_PORT', 8086), help='InfluxDB host port') parser.add_argument('--influxdb-user', metavar='USER', default=os.environ.get('INFLUXDB_USER', None), help='InfluxDB user') parser.add_argument('--influxdb-password', metavar='PASSWORD', default=os.environ.get('INFLUXDB_PASSWORD', None), help='InfluxDB user password') parser.add_argument('--influxdb-password-file', metavar='FILE', default=os.environ.get( 'INFLUXDB_PASSWORD_FILE', None), help='Filename contains InfluxDB user password') parser.add_argument('--influxdb-database', metavar='DATABASE', default=os.environ.get('INFLUXDB_DATABASE', None), help='InfluxDB database to connect to') def timestamp_to_influxdb_format(timestamp=time.time()) -> int: """Convert given timestamp (number of seconds) to integer of InfluxDB format (number of nanoseconds). @todo: see __main__ section test: fix them :param timestamp: Datetime in timestamp format (number of seconds that elapsed since 00:00:00 Coordinated Universal Time (UTC), Thursday, 1 January 1970. Can be string, int or float :return: Integer that ready to use in influxdb.client.write_points() function without precision parameter """ return round(float(timestamp) * 1_000_000_000) def write_points_with_exception_handling(client, points, time_precision=None, logger=None): if not logger: logger = logging.getLogger() try: return client.write_points(points, time_precision=time_precision) except InfluxDBClientError as e: logger.warning('Nothing saved as InfluxDB client error happens: %s', getattr(e, 'message', repr(e))) except InfluxDBServerError as e: logger.warning('Nothing saved as InfluxDB server error happens: %s', getattr(e, 'message', repr(e))) def get_measurements(client: InfluxDBClient, database='') -> list: """Return the list of measurements in given database""" query = 'SHOW MEASUREMENTS' query += ' ON "{}"'.format(database) if database else '' return [_['name'] for _ in client.query(query).get_points()] def get_series(client: InfluxDBClient, database='', measurement='') -> list: """Return the list of series in given database and measurement""" query = 'SHOW SERIES' query += ' ON "{}"'.format(database) if database else '' query += ' FROM "{}"'.format(measurement) if measurement else '' return [_['key'] for _ in client.query(query).get_points()] def get_fields_keys(client: InfluxDBClient, database='', measurement='') -> dict: """Return the dictionary of field keys, where key is field name and value is field type, for given database and measurement""" query = 'SHOW FIELD KEYS' query += ' ON "{}"'.format(database) if database else '' query += ' FROM "{}"'.format(measurement) if measurement else '' return {_['fieldKey']: _['fieldType'] for _ in client.query(query).get_points()} def get_tag_keys(client: InfluxDBClient, database='', measurement='') -> list: """Return the list of tag keys in given database and measurement""" query = 'SHOW TAG KEYS' query += ' ON "{}"'.format(database) if database else '' query += ' FROM "{}"'.format(measurement) if measurement else '' return [_['tagKey'] for _ in client.query(query).get_points()] def get_tags(client: InfluxDBClient, database='', measurement='') -> dict: """Return the dictionary of tag keys, where key is tag name and value is a list of tag values, for given database and measurement""" tags = {} for tag in get_tag_keys(client, database, measurement): query = 'SHOW TAG VALUES' query += ' ON "{}"'.format(database) if database else '' query += ' FROM "{}"'.format(measurement) if measurement else '' query += ' WITH KEY = "{}"'.format(tag) tags[tag] = [_['value'] for _ in client.query(query).get_points()] return tags def compare_point_with_db(client: InfluxDBClient, measurement: str, tag_set: dict, ts: int, point: dict) -> dict: """Get the point from InfluxDB for given measurement, tag set and timestamp, and compare results from InfluxDB with given point. Return comparison stats. @see https://docs.influxdata.com/influxdb/v1.8/troubleshooting/frequently-asked-questions/#how-does-influxdb-handle-duplicate-points """ query = 'SELECT * FROM "{}" WHERE time = {}'.format(measurement, ts) # query part for measurement and timestamp for tag_name, v in tag_set.items(): # query part for tag set query += ' AND "{}" = '.format(tag_name) + ("{}".format(v) if isinstance(v, int) else "'{}'".format(v)) row = [v for v in client.query(query).get_points()] # result dictionary blank result = { 'query': query, 'query_results_count': len(row), 'fields_not_in_db': {}, 'fields_not_equal': {}, 'result': False } if result['query_results_count'] != 1: return result # Clean found point from time and tag set dictionary keys row = row[0] del row['time'] for tag_name, _ in tag_set.items(): del row[tag_name] # Compare fields from found point and given point fields_not_in_db = {} fields_not_equal = {} for field_name, v in point.items(): if field_name in row: if row[field_name] == v: del row[field_name] else: fields_not_equal[field_name] = v else: fields_not_in_db[field_name] = v result['fields_not_in_db'] = fields_not_in_db result['fields_not_equal'] = fields_not_equal result['result'] = not fields_not_equal and not fields_not_in_db return result if __name__ == '__main__': test = [ {'input': '1526041380.9045842', 'output': 1526041380904584200} ] for t in test: # @todo find why test did not pass, transformed = 1526041380904584192 if use round() or int() transformed = timestamp_to_influxdb_format(t['input']) is_ok = 'OK' if transformed == t['output'] else 'FAIL' is_eq = '==' if transformed == t['output'] else '!=' print("{}: {}({}) -> {}({}) {} {}".format(is_ok, t['input'], type(t['input']), transformed, type(transformed), is_eq, t['output']))
[]
[]
[ "INFLUXDB_DATABASE", "INFLUXDB_PASSWORD", "INFLUXDB_HOST", "INFLUXDB_PORT", "INFLUXDB_USER", "INFLUXDB_PASSWORD_FILE" ]
[]
["INFLUXDB_DATABASE", "INFLUXDB_PASSWORD", "INFLUXDB_HOST", "INFLUXDB_PORT", "INFLUXDB_USER", "INFLUXDB_PASSWORD_FILE"]
python
6
0
netscaler/config_test.go
/* Copyright 2016 Citrix Systems, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package netscaler import ( "bytes" "fmt" "log" "math/rand" "testing" "time" "os" "github.com/dreampuf/go-nitro/config/basic" "github.com/dreampuf/go-nitro/config/lb" "github.com/dreampuf/go-nitro/config/network" "github.com/dreampuf/go-nitro/config/ns" ) var client *NitroClient //Used to generate random config object names var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") func randomString(n int) string { b := make([]rune, n) for i := range b { b[i] = letters[rand.Intn(len(letters))] } return string(b) } func randomIP() string { return fmt.Sprintf("%d.%d.%d.%d", rand.Intn(125)+1, rand.Intn(252)+1, rand.Intn(252)+1, rand.Intn(252)+1) } //init random and client func init() { rand.Seed(time.Now().UnixNano()) var err error client, err = NewNitroClientFromEnv() if err != nil { log.Fatal("Could not create a client: ", err) } _, ok := os.LookupEnv("NITRO_LOG") //if NITRO_LOG has been set then let the client get it from the environment if !ok { client.SetLogLevel("INFO") } } func TestMain(m *testing.M) { r := m.Run() client.ClearConfig() os.Exit(r) } // Functional tests func TestClearConfig(t *testing.T) { err := client.ClearConfig() if err != nil { t.Error("Could not clear config: ", err) } } func TestAdd(t *testing.T) { rndIP := randomIP() lbName := "test_lb_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName, Ipv46: rndIP, Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } _, err := client.AddResource(Lbvserver.Type(), lbName, &lb1) if err != nil { t.Error("Could not add Lbvserver: ", err) t.Log("Not continuing test") return } rsrc, err := client.FindResource(Lbvserver.Type(), lbName) if err != nil { t.Error("Did not find resource of type ", err, Lbvserver.Type(), ":", lbName) } val, ok := rsrc["ipv46"] if ok { if val != rndIP { t.Error("Wrong ipv46 for lb ", lbName, ": ", val) } val, ok = rsrc["lbmethod"] if val != "ROUNDROBIN" { t.Error("Wrong lbmethod for lb ", lbName, ": ", val) } val, ok = rsrc["servicetype"] if val != "HTTP" { t.Error("Wrong servicetype for lb ", err, lbName, ": ", val) } } if !ok { t.Error("Non existent property in retrieved lb ", lbName) } svcName := randomString(5) rndIP2 := randomIP() service1 := basic.Service{ Name: svcName, Ip: rndIP2, Port: 80, Servicetype: "HTTP", } client.AddResource(Service.Type(), svcName, &service1) _, err = client.FindResource(Service.Type(), svcName) if err != nil { t.Error("Did not find resource of type ", err, Service.Type(), ":", svcName) } } func TestApply(t *testing.T) { aclName := "test_acl_" + randomString(5) acl1 := ns.Nsacl{ Aclname: aclName, Aclaction: "ALLOW", Srcip: true, Srcipval: "192.168.11.10", Destip: true, Destipval: "192.183.83.11", Priority: 1100, } _, err := client.AddResource(Nsacl.Type(), aclName, &acl1) if err != nil { t.Error("Could not add resource Nsacl", err) t.Log("Cannot continue") return } acls := ns.Nsacls{} client.ApplyResource(Nsacls.Type(), &acls) readAcls, err := client.FindResourceArray(Nsacl.Type(), aclName) if err != nil { t.Error("Did not find resource of type ", Nsacl.Type(), err, ":", aclName) } if err == nil { acl2 := readAcls[0] t.Log("Found acl, kernelstate= ", acl2["kernelstate"]) if acl2["kernelstate"].(string) != "APPLIED" { t.Error("ACL created but not APPLIED ", Nsacl.Type(), ":", aclName) } } } func TestUpdate(t *testing.T) { rndIP := randomIP() lbName := "test_lb_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName, Ipv46: rndIP, Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } _, err := client.AddResource(Lbvserver.Type(), lbName, &lb1) if err != nil { t.Error("Could not create LB", err) t.Log("Cannot continue") return } lb1 = lb.Lbvserver{ Name: lbName, Lbmethod: "LEASTCONNECTION", } _, err = client.UpdateResource(Lbvserver.Type(), lbName, &lb1) if err != nil { t.Error("Could not update LB") t.Log("Cannot continue") return } rsrc, err := client.FindResource(Lbvserver.Type(), lbName) if err != nil { t.Error("Did not find resource of type ", Lbvserver.Type(), ":", lbName, err) t.Log("Cannot continue") return } val, ok := rsrc["lbmethod"] if ok { if val != "LEASTCONNECTION" { t.Error("Did not update lb method to LEASTCONNECTION") } } if !ok { t.Error("Failed to retrieve lb vserver object") } } func TestBindUnBind(t *testing.T) { rndIP := randomIP() lbName := "test_lb_" + randomString(5) rndIP2 := randomIP() svcName := "test_svc_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName, Ipv46: rndIP, Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } _, err := client.AddResource(Lbvserver.Type(), lbName, &lb1) if err != nil { t.Error("Could not create LB", err) t.Log("Cannot continue") return } service1 := basic.Service{ Name: svcName, Ip: rndIP2, Port: 80, Servicetype: "HTTP", } _, err = client.AddResource(Service.Type(), svcName, &service1) if err != nil { t.Error("Could not create service", err) t.Log("Cannot continue") return } binding := lb.Lbvserverservicebinding{ Name: lbName, Servicename: svcName, } err = client.BindResource(Lbvserver.Type(), lbName, Service.Type(), svcName, &binding) if err != nil { t.Error("Could not bind LB to svc", err) t.Log("Cannot continue") return } exists := client.ResourceBindingExists(Lbvserver.Type(), lbName, Service.Type(), "servicename", svcName) if !exists { t.Error("Failed to bind service to lb vserver") t.Log("Cannot continue") return } err = client.UnbindResource(Lbvserver.Type(), lbName, Service.Type(), svcName, "servicename") if err != nil { t.Error("Could not unbind LB to svc", err) t.Log("Cannot continue") return } exists = client.ResourceBindingExists(Lbvserver.Type(), lbName, Service.Type(), "servicename", svcName) if exists { t.Error("Failed to unbind service to lb vserver") } } func TestFindBoundResource(t *testing.T) { lbName := "test_lb_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName, Ipv46: randomIP(), Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } _, err := client.AddResource(Lbvserver.Type(), lbName, &lb1) if err != nil { t.Error("Failed to add resource of type ", Lbvserver.Type(), ":", "sample_lb_1", err) t.Log("Cannot continue") return } svcName := "test_svc_" + randomString(5) service1 := basic.Service{ Name: svcName, Ip: randomIP(), Port: 80, Servicetype: "HTTP", } _, err = client.AddResource(Service.Type(), svcName, &service1) if err != nil { t.Error("Failed to add resource of type ", Service.Type(), ":", svcName, err) t.Log("Cannot continue") return } binding := lb.Lbvserverservicebinding{ Name: lbName, Servicename: svcName, } err = client.BindResource(Lbvserver.Type(), lbName, Service.Type(), svcName, &binding) if err != nil { t.Error("Failed to bind resource of type ", Service.Type(), ":", svcName) t.Log("Cannot continue") return } result, err := client.FindBoundResource(Lbvserver.Type(), lbName, Service.Type(), "servicename", svcName) if err != nil { t.Error("Failed to find bound resource of type ", Service.Type(), ":", svcName) t.Log("Cannot continue") return } //t.Log("Found bound resource ", result) if result["servicename"] != svcName { t.Error("Failed to find bound resource of type ", Service.Type(), ":", svcName) } } func TestDelete(t *testing.T) { rndIP := randomIP() lbName := "test_lb_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName, Ipv46: rndIP, Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } _, err := client.AddResource(Lbvserver.Type(), lbName, &lb1) if err != nil { t.Error("Could not create LB", err) t.Log("Cannot continue") return } err = client.DeleteResource(Lbvserver.Type(), lbName) if err != nil { t.Error("Could not delete LB", lbName, err) t.Log("Cannot continue") return } if client.ResourceExists(Lbvserver.Type(), lbName) { t.Error("Failed to delete ", lbName) } } func TestDeleteWithArgs(t *testing.T) { monitorName := "test_lb_monitor_" + randomString(5) lbmonitor := lb.Lbmonitor{ Monitorname: monitorName, Type: "http", Retries: 20, Failureretries: 10, Downtime: 60, } _, err := client.AddResource(Lbmonitor.Type(), monitorName, &lbmonitor) if err != nil { t.Error("Could not create monitor", err) t.Log("Cannot continue") return } args := map[string]string{"type": "http"} err = client.DeleteResourceWithArgsMap(Lbmonitor.Type(), monitorName, args) if err != nil { t.Error("Could not delete monitor", monitorName, err) t.Log("Cannot continue") return } } func TestEnableFeatures(t *testing.T) { features := []string{"SSL", "CS"} err := client.EnableFeatures(features) if err != nil { t.Error("Failed to enable features", err) t.Log("Cannot continue") return } result, err := client.ListEnabledFeatures() if err != nil { t.Error("Failed to retrieve features", err) t.Log("Cannot continue") return } found := 0 for _, f := range features { for _, r := range result { if f == r { found = found + 1 } } } if found != len(features) { t.Error("Requested features do not match enabled features=", features, "result=", result) } } func TestEnableModes(t *testing.T) { modes := []string{"ULFD", "MBF"} err := client.EnableModes(modes) if err != nil { t.Error("Failed to enable modes", err) t.Log("Cannot continue") return } result, err := client.ListEnabledModes() if err != nil { t.Error("Failed to retrieve modes", err) t.Log("Cannot continue") return } found := 0 for _, m := range modes { for _, r := range result { if m == r { found = found + 1 } } } if found != len(modes) { t.Error("Requested modes do not match enabled modes=", modes, "result=", result) } } func TestSaveConfig(t *testing.T) { err := client.SaveConfig() if err != nil { t.Error("Failed to save config", err) } } func TestFindAllResources(t *testing.T) { lbName1 := "test_lb_" + randomString(5) lbName2 := "test_lb_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName1, Ipv46: randomIP(), Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } lb2 := lb.Lbvserver{ Name: lbName2, Ipv46: randomIP(), Lbmethod: "LEASTCONNECTION", Servicetype: "HTTP", Port: 8000, } _, err := client.AddResource(Lbvserver.Type(), lbName1, &lb1) if err != nil { t.Error("Failed to add resource of type ", Lbvserver.Type(), ":", lbName1) t.Log("Cannot continue") return } _, err = client.AddResource(Lbvserver.Type(), lbName2, &lb2) if err != nil { t.Error("Failed to add resource of type ", Lbvserver.Type(), ":", lbName2) t.Log("Cannot continue") return } rsrcs, err := client.FindAllResources(Lbvserver.Type()) if err != nil { t.Error("Did not find resources of type ", Lbvserver.Type(), err) } if len(rsrcs) < 2 { t.Error("Found only ", len(rsrcs), " resources of type ", Lbvserver.Type(), " expected at least 2") } found := 0 for _, v := range rsrcs { name := v["name"].(string) if name == lbName1 || name == lbName2 { found = found + 1 } } if found != 2 { t.Error("Did not find all configured lbvservers") } } func TestFindAllBoundResources(t *testing.T) { lbName1 := "test_lb_" + randomString(5) svcName1 := "test_svc_" + randomString(5) svcName2 := "test_svc_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName1, Ipv46: randomIP(), Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } _, err := client.AddResource(Lbvserver.Type(), lbName1, &lb1) if err != nil { t.Error("Could not create LB") } service1 := basic.Service{ Name: svcName1, Ip: randomIP(), Port: 80, Servicetype: "HTTP", } service2 := basic.Service{ Name: svcName2, Ip: randomIP(), Port: 80, Servicetype: "HTTP", } _, err = client.AddResource(Service.Type(), svcName1, &service1) if err != nil { t.Error("Could not create service service1", err) t.Log("Cannot continue") return } _, err = client.AddResource(Service.Type(), svcName2, &service2) if err != nil { t.Error("Could not create service service2", err) t.Log("Cannot continue") return } binding1 := lb.Lbvserverservicebinding{ Name: lbName1, Servicename: svcName1, } binding2 := lb.Lbvserverservicebinding{ Name: lbName1, Servicename: svcName2, } err = client.BindResource(Lbvserver.Type(), lbName1, Service.Type(), svcName1, &binding1) if err != nil { t.Error("Could not bind service service1") t.Log("Cannot continue") return } err = client.BindResource(Lbvserver.Type(), lbName1, Service.Type(), svcName2, &binding2) if err != nil { t.Error("Could not bind service service2") t.Log("Cannot continue") return } rsrcs, err := client.FindAllBoundResources(Lbvserver.Type(), lbName1, Service.Type()) if err != nil { t.Error("Did not find bound resources of type ", Service.Type()) } if len(rsrcs) < 2 { t.Error("Found only ", len(rsrcs), " resources of type ", Service.Type(), " expected at least 2") t.Log("Cannot continue") return } found := 0 for _, v := range rsrcs { name := v["servicename"].(string) if name == svcName1 || name == svcName2 { found = found + 1 } } if found != 2 { t.Error("Did not find all bound services") } } func TestAction(t *testing.T) { svcGrpName := "test_sg_" + randomString(5) sg1 := basic.Servicegroup{ Servicegroupname: svcGrpName, Servicetype: "http", } _, err := client.AddResource(Servicegroup.Type(), svcGrpName, &sg1) if err != nil { t.Error("Could not add resource service group", err) t.Log("Cannot continue") return } createServer := basic.Server{ Ipaddress: "192.168.1.101", Name: "test-srvr", } _, err = client.AddResource(Server.Type(), "test-server", &createServer) if err != nil { t.Error("Could not add resource server", err) t.Log("Cannot continue") return } bindSvcGrpToServer := basic.Servicegroupservicegroupmemberbinding{ Servicegroupname: svcGrpName, Servername: "test-srvr", Port: 22, } _, err = client.AddResource(Servicegroup_servicegroupmember_binding.Type(), "test-svcgroup", &bindSvcGrpToServer) if err != nil { t.Error("Could not bind resource server", err) t.Log("Cannot continue") return } bindSvcGrpToServer2 := basic.Servicegroupservicegroupmemberbinding{ Servicegroupname: svcGrpName, Ip: "192.168.1.102", Port: 22, } _, err = client.AddResource(Servicegroup_servicegroupmember_binding.Type(), "test-svcgroup", &bindSvcGrpToServer2) if err != nil { t.Error("Could not bind resource server", err) t.Log("Cannot continue") return } sg2 := basic.Servicegroup{ Servicegroupname: svcGrpName, Servername: "test-srvr", Port: 22, Delay: 100, Graceful: "YES", } err = client.ActOnResource(Servicegroup.Type(), &sg2, "disable") if err != nil { t.Error("Could not disable server", err) t.Log("Cannot continue") return } sg3 := basic.Servicegroup{ Servicegroupname: svcGrpName, Servername: "test-srvr", Port: 22, } err = client.ActOnResource(Servicegroup.Type(), &sg3, "enable") if err != nil { t.Error("Could not enable server", err) t.Log("Cannot continue") return } sg4 := basic.Servicegroup{ Servicegroupname: svcGrpName, Newname: svcGrpName + "-NEW", } err = client.ActOnResource(Servicegroup.Type(), &sg4, "rename") if err != nil { t.Error("Could not rename servicegroup", err) t.Log("Cannot continue") return } } func TestUpdateUnnamedResource(t *testing.T) { if os.Getenv("ADC_PLATFORM") == "CPX" { t.Skip("Skipping test not supported by CPX") } rnat := network.Rnat{ Natip: "172.17.0.2", Netmask: "255.255.240.0", Network: "192.168.16.0", } err := client.UpdateUnnamedResource(Rnat.Type(), &rnat) if err != nil { t.Error("Could not add Rnat", err) //t.Log("Cannot continue") return } } func TestFindFilteredResource(t *testing.T) { if os.Getenv("ADC_PLATFORM") == "CPX" { t.Skip("Skipping test not supported by CPX") } rnat := network.Rnat{ Natip: "172.17.0.2", Netmask: "255.255.240.0", Network: "192.168.16.0", } err := client.UpdateUnnamedResource(Rnat.Type(), &rnat) if err != nil { t.Error("Could not add Rnat", err) t.Log("Cannot continue") return } d, err := client.FindFilteredResourceArray(Rnat.Type(), map[string]string{"network": "192.168.16.0", "netmask": "255.255.240.0", "natip": "172.17.0.2"}) if err != nil { t.Error("Could not find Rnat", err) t.Log("Cannot continue") return } if len(d) != 1 { t.Error("Error finding Rnat", fmt.Errorf("Wrong number of RNAT discovered: %d", len(d))) return } rnat2 := d[0] if rnat2["natip"].(string) == "172.17.0.2" && rnat2["netmask"].(string) == "255.255.240.0" && rnat2["network"].(string) == "192.168.16.0" { return } else { t.Error("Error finding Rnat", fmt.Errorf("Discovered RNAT does not match")) } } // TestDesiredStateServicegroupAPI tests the servicegroup_servicegroupmemberlist_binding API // which is used to bind multiple IP-only members to servicegroup in single Nitro call func TestDesiredStateServicegroupAPI(t *testing.T) { svcGrpName := "test_sg_" + randomString(5) sg1 := basic.Servicegroup{ Servicegroupname: svcGrpName, Servicetype: "http", Autoscale: "API", } _, err := client.AddResource(Servicegroup.Type(), svcGrpName, &sg1) if err != nil { t.Error("Could not add resource autoscale service group", err) t.Log("Cannot continue") return } ipmembers := []basic.Member{ { Ip: "1.1.1.1", Port: 80, }, { Ip: "2.2.2.2", Port: 80, }, { Ip: "3.3.3.3", Port: 80, }, } bindSvcGrpToServer := basic.Servicegroupservicegroupmemberlistbinding{ Servicegroupname: svcGrpName, Members: ipmembers, } _, err = client.AddResource(Servicegroup_servicegroupmemberlist_binding.Type(), "test-svcgroup", &bindSvcGrpToServer) if err != nil { t.Error("Could not bind resource server", err) t.Log("Cannot continue") return } } func TestNullAction(t *testing.T) { if os.Getenv("ADC_PLATFORM") == "CPX" { t.Skip("Skipping test not supported by CPX") } reboot := ns.Reboot{ Warm: true, } err := client.ActOnResource("reboot", &reboot, "") if err != nil { t.Error("Could not make null action reboot", err) t.Log("Cannot continue") return } // Add a timeout to wait for instance to be back online time.Sleep(60 * time.Second) } // TestTokenBasedAuth tests token-based authentication and tests if session-is is cleared in case of session-expiry func TestTokenBasedAuth(t *testing.T) { var err error err = client.Login() if err != nil { t.Error("Login Failed") return } rndIP := randomIP() lbName := "test_lb_" + randomString(5) lb1 := lb.Lbvserver{ Name: lbName, Ipv46: rndIP, Lbmethod: "ROUNDROBIN", Servicetype: "HTTP", Port: 8000, } _, err = client.AddResource(Lbvserver.Type(), lbName, &lb1) if err != nil { t.Error("Could not add Lbvserver: ", err) t.Log("Not continuing test") return } rsrc, err := client.FindResource(Lbvserver.Type(), lbName) if err != nil { t.Error("Did not find resource of type ", err, Lbvserver.Type(), ":", lbName) } else { t.Log("LB-METHOD: ", rsrc["lbmethod"]) } err = client.DeleteResource(Lbvserver.Type(), lbName) if err != nil { t.Error("Could not delete LB", lbName, err) t.Log("Cannot continue") return } err = client.Logout() if err != nil { t.Error("Logout Failed") return } // Test if session-id is cleared in case of session-expiry client.timeout = 10 client.Login() time.Sleep(15 * time.Second) _, err = client.AddResource(Lbvserver.Type(), lbName, &lb1) if err != nil { if client.IsLoggedIn() { t.Error("Sessionid not cleared") return } t.Log("sessionid cleared because of session-expiry") } else { t.Error("Adding lbvserver should have failed because of session-expiry") } } func TestConstructQueryString(t *testing.T) { var buf bytes.Buffer log.SetOutput(&buf) generateTestCase := func(findParams FindParams, expected string) func(t *testing.T) { return func(t *testing.T) { output := constructQueryString(&findParams) if output != expected { t.Log(buf.String()) t.Logf("Expected output \"%s\"", expected) t.Logf("Actual output \"%s\"", output) t.Fail() } } } var argsMap, filterMap map[string]string var attrsAry []string var findParams FindParams argsMap = make(map[string]string) argsMap["hello"] = "bye" findParams = FindParams{ ArgsMap: argsMap, } t.Run("CASE=1", generateTestCase(findParams, "?args=hello:bye")) argsMap["bye"] = "hello" findParams = FindParams{ ArgsMap: argsMap, } t.Run("CASE=2", generateTestCase(findParams, "?args=bye:hello,hello:bye")) attrsAry = []string{"hello"} findParams = FindParams{ AttrsAry: attrsAry, } t.Run("CASE=3", generateTestCase(findParams, "?attrs=hello")) attrsAry = append(attrsAry, "bye") t.Run("CASE=4", generateTestCase(findParams, "?attrs=bye,hello")) filterMap = make(map[string]string) filterMap["bye"] = "hello" findParams = FindParams{ FilterMap: filterMap, } t.Run("CASE=5", generateTestCase(findParams, "?filter=bye:hello")) filterMap["hello"] = "bye" t.Run("CASE=6", generateTestCase(findParams, "?filter=bye:hello,hello:bye")) filterMap = make(map[string]string) attrsAry = []string{} argsMap = make(map[string]string) filterMap["bye"] = "hello" attrsAry = append(attrsAry, "hello") argsMap["bye"] = "hello" findParams = FindParams{ FilterMap: filterMap, ArgsMap: argsMap, AttrsAry: attrsAry, } t.Run("CASE=7", generateTestCase(findParams, "?args=bye:hello&filter=bye:hello&attrs=hello")) filterMap["hello"] = "bye" attrsAry = append(attrsAry, "bye") argsMap["hello"] = "bye" expected := "?args=bye:hello,hello:bye&filter=bye:hello,hello:bye&attrs=bye,hello" t.Run("CASE=8", generateTestCase(findParams, expected)) } func TestConstructUrlPathString(t *testing.T) { var buf bytes.Buffer log.SetOutput(&buf) generateTestCase := func(findParams FindParams, expected string) func(t *testing.T) { return func(t *testing.T) { output := constructUrlPathString(&findParams) if output != expected { t.Log(buf.String()) t.Logf("Expected output \"%s\"", expected) t.Logf("Actual output \"%s\"", output) t.Fail() } } } var findParams FindParams findParams = FindParams{ ResourceType: "resourcetype", } t.Run("CASE=1", generateTestCase(findParams, "resourcetype")) findParams = FindParams{ ResourceName: "resourcename", } t.Run("CASE=2", generateTestCase(findParams, "resourcename")) findParams = FindParams{ ResourceType: "resourcetype", ResourceName: "resourcename", } t.Run("CASE=3", generateTestCase(findParams, "resourcetype/resourcename")) } func TestFindResourceArrayWithParams(t *testing.T) { var buf bytes.Buffer log.SetOutput(&buf) testCase1 := func(t *testing.T) { findParams := FindParams{ ResourceType: "lbvserver", ResourceName: "definitelynotexists", ResourceMissingErrorCode: 258, } resource, err := client.FindResourceArrayWithParams(findParams) hasErrors := false if err != nil { hasErrors = true t.Logf("Error from NITRO request: %s", err.Error()) } if len(resource) > 0 { hasErrors = true t.Logf("Resource array not empty") } if hasErrors { t.Log(buf.String()) t.Fail() } } t.Run("CASE=1", testCase1) testCase2 := func(t *testing.T) { argsMap := make(map[string]string) argsMap["filename"] = "ns.conf" argsMap["filelocation"] = "%2Fnsconfig" findParams := FindParams{ ResourceType: "systemfile", ArgsMap: argsMap, } resource, err := client.FindResourceArrayWithParams(findParams) hasErrors := false if err != nil { hasErrors = true t.Logf("Error from NITRO request: %s", err.Error()) } if len(resource) != 1 { hasErrors = true t.Logf("Resource array not exactly 1") } if hasErrors { t.Log(buf.String()) t.Fail() } } t.Run("CASE=2", testCase2) testCase3 := func(t *testing.T) { argsMap := make(map[string]string) //argsMap["filename"] = "ns.conf" argsMap["filelocation"] = "%2Fnsconfig" findParams := FindParams{ ResourceType: "systemfile", ArgsMap: argsMap, } resource, err := client.FindResourceArrayWithParams(findParams) hasErrors := false if err != nil { hasErrors = true t.Logf("Error from NITRO request: %s", err.Error()) } if len(resource) <= 1 { hasErrors = true t.Logf("Resource array len not > 1") } if hasErrors { t.Log(buf.String()) t.Fail() } } t.Run("CASE=3", testCase3) testCase4 := func(t *testing.T) { t.Skipf("TODO: find a resource for which NITRO returns a map instead of an array") } t.Run("CASE=4", testCase4) }
[ "\"ADC_PLATFORM\"", "\"ADC_PLATFORM\"", "\"ADC_PLATFORM\"" ]
[]
[ "ADC_PLATFORM" ]
[]
["ADC_PLATFORM"]
go
1
0
db_tools/import_category_data.py
# encoding: utf-8 __author__ = 'mtianyan' __date__ = '2018/2/14 0014 03:31' # 独立使用django的model import sys import os # 获取当前文件的路径,以及路径的父级文件夹名 pwd = os.path.dirname(os.path.realpath(__file__)) # 将项目目录加入setting sys.path.append(pwd + "../") # manage.py中 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "MxShop_Back.settings") import django django.setup() # 导入这个model必须在初始化django之后,不能放在最上边 from goods.models import GoodsCategory from db_tools.data.category_data import row_data # 一级分类 for lev1_cat in row_data: lev1_intance = GoodsCategory() lev1_intance.code = lev1_cat["code"] lev1_intance.name = lev1_cat["name"] lev1_intance.category_type = 1 lev1_intance.save() # 该一级分类之下的二级分类 for lev2_cat in lev1_cat["sub_categorys"]: lev2_intance = GoodsCategory() lev2_intance.code = lev2_cat["code"] lev2_intance.name = lev2_cat["name"] lev2_intance.category_type = 2 lev2_intance.parent_category = lev1_intance lev2_intance.save() # 该二级分类之下的三级分类 for lev3_cat in lev2_cat["sub_categorys"]: lev3_intance = GoodsCategory() lev3_intance.code = lev3_cat["code"] lev3_intance.name = lev3_cat["name"] lev3_intance.category_type = 3 lev3_intance.parent_category = lev2_intance lev3_intance.save()
[]
[]
[]
[]
[]
python
0
0
cmd/cataloguesvc/main.go
package main import ( "flag" "fmt" "net/http" "os" "os/signal" "path/filepath" "syscall" "github.com/go-kit/kit/log" _ "github.com/go-sql-driver/mysql" "github.com/jmoiron/sqlx" "github.com/prometheus/client_golang/prometheus" stdprometheus "github.com/prometheus/client_golang/prometheus" "github.com/sls-microservices-demo/catalogue" "github.com/weaveworks/common/middleware" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/exporters/otlp" "go.opentelemetry.io/otel/exporters/stdout" "go.opentelemetry.io/otel/propagation" export "go.opentelemetry.io/otel/sdk/export/trace" "go.opentelemetry.io/otel/sdk/resource" sdktrace "go.opentelemetry.io/otel/sdk/trace" "go.opentelemetry.io/otel/semconv" "golang.org/x/net/context" ) const ( ServiceName = "catalogue" ) var ( HTTPLatency = stdprometheus.NewHistogramVec(stdprometheus.HistogramOpts{ Name: "http_request_duration_seconds", Help: "Time (in seconds) spent serving HTTP requests.", Buckets: stdprometheus.DefBuckets, }, []string{"method", "path", "status_code", "isWS"}) ResponseBodySize = stdprometheus.NewHistogramVec(stdprometheus.HistogramOpts{ Name: "http_response_size", Buckets: stdprometheus.DefBuckets, }, []string{"method", "path"}) RequestBodySize = stdprometheus.NewHistogramVec(stdprometheus.HistogramOpts{ Name: "http_request_size", Buckets: stdprometheus.DefBuckets, }, []string{"method", "path"}) InflightRequests = stdprometheus.NewGaugeVec(stdprometheus.GaugeOpts{ Name: "http_inflight_requests", }, []string{"method", "path"}) ) // Log domain. var logger log.Logger var otlpEndpoint string func init() { flag.StringVar(&otlpEndpoint, "otlp-endpoint", os.Getenv("OTLP_ENDPOINT"), "otlp endpoint") } func initTracer() { var traceExporter export.SpanExporter if otlpEndpoint == "stdout" { // Create stdout exporter to be able to retrieve // the collected spans. exporter, err := stdout.NewExporter() if err != nil { panic(err) } logger.Log("register stdout exporter", "") traceExporter = exporter } else if otlpEndpoint != "" { // If the OpenTelemetry Collector is running on a local cluster (minikube or // microk8s), it should be accessible through the NodePort service at the // `localhost:30080` address. Otherwise, replace `localhost` with the // address of your cluster. If you run the app inside k8s, then you can // probably connect directly to the service through dns exp, err := otlp.NewExporter(context.Background(), otlp.WithInsecure(), otlp.WithAddress(otlpEndpoint), //otlp.WithGRPCDialOption(grpc.WithBlock()), // useful for testing ) if err != nil { panic(err) } logger.Log("register otlp exporter", otlpEndpoint) traceExporter = exp } if traceExporter == nil { logger.Log("no opentelemetry exporter", "") return } hostname, _ := os.Hostname() // For the demonstration, use sdktrace.AlwaysSample sampler to sample all traces. // In a production application, use sdktrace.ProbabilitySampler with a desired probability. tp := sdktrace.NewTracerProvider(sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}), sdktrace.WithSyncer(traceExporter), //sdktrace.WithSyncer(&TTE{}), sdktrace.WithResource(resource.NewWithAttributes(semconv.ServiceNameKey.String("catalogue"), semconv.HostNameKey.String(hostname)))) otel.SetTracerProvider(tp) otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{})) } func init() { prometheus.MustRegister(HTTPLatency) prometheus.MustRegister(ResponseBodySize) prometheus.MustRegister(RequestBodySize) prometheus.MustRegister(InflightRequests) } func main() { var ( port = flag.String("port", "80", "Port to bind HTTP listener") // TODO(pb): should be -addr, default ":80" images = flag.String("images", "./images/", "Image path") dsn = flag.String("DSN", "catalogue_user:default_password@tcp(catalogue-db:3306)/socksdb", "Data Source Name: [username[:password]@][protocol[(address)]]/dbname") ) flag.Parse() fmt.Fprintf(os.Stderr, "images: %q\n", *images) abs, err := filepath.Abs(*images) fmt.Fprintf(os.Stderr, "Abs(images): %q (%v)\n", abs, err) pwd, err := os.Getwd() fmt.Fprintf(os.Stderr, "Getwd: %q (%v)\n", pwd, err) files, _ := filepath.Glob(*images + "/*") fmt.Fprintf(os.Stderr, "ls: %q\n", files) // contains a list of all files in the current directory // Mechanical stuff. errc := make(chan error) ctx := context.Background() { logger = log.NewLogfmtLogger(os.Stderr) logger = log.With(logger, "ts", log.DefaultTimestampUTC) logger = log.With(logger, "caller", log.DefaultCaller) initTracer() } // Data domain. db, err := sqlx.Open("mysql", *dsn) if err != nil { logger.Log("err", err) os.Exit(1) } defer db.Close() // Check if DB connection can be made, only for logging purposes, should not fail/exit err = db.Ping() if err != nil { logger.Log("Error", "Unable to connect to Database", "DSN", dsn) } // Service domain. var service catalogue.Service { service = catalogue.NewCatalogueService(db, logger) service = catalogue.LoggingMiddleware(logger)(service) } // Endpoint domain. endpoints := catalogue.MakeEndpoints(service) // HTTP router router := catalogue.MakeHTTPHandler(ctx, endpoints, *images, logger) httpMiddleware := []middleware.Interface{ middleware.Instrument{ Duration: HTTPLatency, RequestBodySize: RequestBodySize, ResponseBodySize: ResponseBodySize, InflightRequests: InflightRequests, RouteMatcher: router, }, } // Handler handler := middleware.Merge(httpMiddleware...).Wrap(router) // Create and launch the HTTP server. go func() { logger.Log("transport", "HTTP", "port", *port) errc <- http.ListenAndServe(":"+*port, handler) }() // Capture interrupts. go func() { c := make(chan os.Signal) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) errc <- fmt.Errorf("%s", <-c) }() logger.Log("exit", <-errc) }
[ "\"OTLP_ENDPOINT\"" ]
[]
[ "OTLP_ENDPOINT" ]
[]
["OTLP_ENDPOINT"]
go
1
0
testing/vcs/test_vcs_1D_datawc_missing.py
import vcs, numpy, cdms2, MV2, os, sys, vcs.testing.regression as regression x = regression.init() yx = x.createyxvsx() data = """ -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. 0.059503571833625334 0.059503571833625334 0.05664014775641405 0.05193557222118004 0.04777129850801233 0.0407139313814465 0.029382624830271705 0.018469399844287374 0.0162382275289592 0.02646680241827459 0.04792041732949079 0.0689138797030203 0.08167038620212037 0.09273558459066569 0.11266293431057901 0.13663018925347364 0.15229174546388072 0.15284435880966177 0.13423845476113883 0.09945904378274077 0.07032267160267985 0.05551039827020481 0.045537187647785464 0.040532491867244946 0.03577527125478327 -999. -999. -999. -0.058062458673116 -0.08764922509099882 -0.11697036914487152 -0.14836133615864944 -0.17956528904564023 -0.21109198032585794 -0.23846429237248942 -0.2598536549218765 -0.27795672866320387 -0.2939939095159731 -0.30541031366330024 -0.307643559333884 -0.30078421139811795 -0.2841339526883441 -0.26485737397202497 -0.24287299694779327 -0.22379014890999907 -0.20121548204699846 -0.1746486732156772 -0.14585019344118372 -0.12070675757803526 -0.0997891159111037 -0.08229393660994214 -0.06779720501287469 -0.057213385470859794 -0.04875768191096844 -0.0402377347189964 -0.030169328367807245 -0.017560662894847895 -0.006968922654137132 0.0009773980274431048 0.007054306637034288 0.010472286514133042 0.010702384151997032 0.009231553701801242 0.007544033101056543 0.004639797857203645 -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. -999. """.split() data = numpy.array(data,dtype=numpy.float) data = MV2.masked_less(data,-900) x.plot(data,yx,bg=1) regression.run(x, "test_vcs_1D_datawc_missing.png")
[]
[]
[]
[]
[]
python
null
null
null
cmd/node.go
package cmd import ( "encoding/hex" "flag" "fmt" "net" "os" "os/signal" "sync" "syscall" "time" "github.com/DataDog/datadog-go/statsd" "github.com/btcsuite/btcd/addrmgr" "github.com/btcsuite/btcd/wire" "github.com/davecgh/go-spew/spew" "github.com/deso-protocol/core/lib" "github.com/deso-protocol/core/migrate" "github.com/deso-protocol/go-deadlock" "github.com/dgraph-io/badger/v3" "github.com/go-pg/pg/v10" "github.com/golang/glog" migrations "github.com/robinjoseph08/go-pg-migrations/v3" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer" "gopkg.in/DataDog/dd-trace-go.v1/profiler" ) type Node struct { Server *lib.Server ChainDB *badger.DB TXIndex *lib.TXIndex Params *lib.DeSoParams Config *Config Postgres *lib.Postgres // IsRunning is false when a NewNode is created, set to true on Start(), set to false // after Stop() is called. Mainly used in testing. IsRunning bool // runningMutex is held whenever we call Start() or Stop() on the node. runningMutex sync.Mutex // internalExitChan is used internally to signal that a node should close. internalExitChan chan struct{} // nodeMessageChan is passed to the core engine and used to trigger node actions such as a restart or database reset. nodeMessageChan chan lib.NodeMessage // stopWaitGroup allows us to wait for the node to fully close. stopWaitGroup sync.WaitGroup } func NewNode(config *Config) *Node { result := Node{} result.Config = config result.Params = config.Params result.internalExitChan = make(chan struct{}) result.nodeMessageChan = make(chan lib.NodeMessage) return &result } // Start is the main function used to kick off the node. The exitChannels are optionally passed by the caller to receive // signals from the node. In particular, exitChannels will be closed by the node when the node is shutting down for good. func (node *Node) Start(exitChannels ...*chan struct{}) { // TODO: Replace glog with logrus so we can also get rid of flag library flag.Set("log_dir", node.Config.LogDirectory) flag.Set("v", fmt.Sprintf("%d", node.Config.GlogV)) flag.Set("vmodule", node.Config.GlogVmodule) flag.Set("alsologtostderr", "true") flag.Parse() glog.CopyStandardLogTo("INFO") node.runningMutex.Lock() defer node.runningMutex.Unlock() node.internalExitChan = make(chan struct{}) node.nodeMessageChan = make(chan lib.NodeMessage) // listenToNodeMessages handles the messages received from the engine through the nodeMessageChan. go node.listenToNodeMessages() // Print config node.Config.Print() // Check for regtest mode if node.Config.Regtest { node.Params.EnableRegtest() } // Validate params validateParams(node.Params) // This is a bit of a hack, and we should deprecate this. We rely on GlobalDeSoParams static variable in only one // place in the core code, namely in encoder migrations. Encoder migrations allow us to update the core database // schema without requiring a resync. GlobalDeSoParams is used so that encoders know if we're on mainnet or testnet. lib.GlobalDeSoParams = *node.Params // Setup Datadog span tracer and profiler if node.Config.DatadogProfiler { tracer.Start() err := profiler.Start(profiler.WithProfileTypes(profiler.CPUProfile, profiler.BlockProfile, profiler.MutexProfile, profiler.GoroutineProfile, profiler.HeapProfile)) if err != nil { glog.Fatal(err) } } if node.Config.TimeEvents { lib.Mode = lib.EnableTimer } // Setup statsd statsdClient, err := statsd.New(fmt.Sprintf("%s:%d", os.Getenv("DD_AGENT_HOST"), 8125)) if err != nil { glog.Fatal(err) } // Setup listeners and peers desoAddrMgr := addrmgr.New(node.Config.DataDirectory, net.LookupIP) desoAddrMgr.Start() // This just gets localhost listening addresses on the protocol port. // Such as [{127.0.0.1 18000 } {::1 18000 }], and associated listener structs. listeningAddrs, listeners := GetAddrsToListenOn(node.Config.ProtocolPort) _ = listeningAddrs // If --connect-ips is not passed, we will connect the addresses from // --add-ips, DNSSeeds, and DNSSeedGenerators. if len(node.Config.ConnectIPs) == 0 { glog.Infof("Looking for AddIPs: %v", len(node.Config.AddIPs)) for _, host := range node.Config.AddIPs { addIPsForHost(desoAddrMgr, host, node.Params) } glog.Infof("Looking for DNSSeeds: %v", len(node.Params.DNSSeeds)) for _, host := range node.Params.DNSSeeds { addIPsForHost(desoAddrMgr, host, node.Params) } // This is where we connect to addresses from DNSSeeds. if !node.Config.PrivateMode { go addSeedAddrsFromPrefixes(desoAddrMgr, node.Params) } } // Setup chain database dbDir := lib.GetBadgerDbPath(node.Config.DataDirectory) opts := lib.PerformanceBadgerOptions(dbDir) opts.ValueDir = dbDir node.ChainDB, err = badger.Open(opts) if err != nil { panic(err) } // Setup snapshot logger if node.Config.LogDBSummarySnapshots { lib.StartDBSummarySnapshots(node.ChainDB) } // Validate that we weren't passed incompatible Hypersync flags lib.ValidateHyperSyncFlags(node.Config.HyperSync, node.Config.SyncType) // Setup postgres using a remote URI. Postgres is not currently supported when we're in hypersync mode. if node.Config.HyperSync && node.Config.PostgresURI != "" { glog.Fatal("--postgres-uri is not supported when --hypersync=true. We're " + "working on Hypersync support for Postgres though!") } var db *pg.DB if node.Config.PostgresURI != "" { options, err := pg.ParseURL(node.Config.PostgresURI) if err != nil { panic(err) } db = pg.Connect(options) node.Postgres = lib.NewPostgres(db) // LoadMigrations registers all the migration files in the migrate package. // See LoadMigrations for more info. migrate.LoadMigrations() // Migrate the database after loading all the migrations. This is equivalent // to running "go run migrate.go migrate". See migrate.go for a migrations CLI tool err = migrations.Run(db, "migrate", []string{"", "migrate"}) if err != nil { panic(err) } } // Setup eventManager eventManager := lib.NewEventManager() // Setup the server. ShouldRestart is used whenever we detect an issue and should restart the node after a recovery // process, just in case. These issues usually arise when the node was shutdown unexpectedly mid-operation. The node // performs regular health checks to detect whenever this occurs. shouldRestart := false node.Server, err, shouldRestart = lib.NewServer( node.Params, listeners, desoAddrMgr, node.Config.ConnectIPs, node.ChainDB, node.Postgres, node.Config.TargetOutboundPeers, node.Config.MaxInboundPeers, node.Config.MinerPublicKeys, node.Config.NumMiningThreads, node.Config.OneInboundPerIp, node.Config.HyperSync, node.Config.SyncType, node.Config.MaxSyncBlockHeight, node.Config.DisableEncoderMigrations, node.Config.RateLimitFeerate, node.Config.MinFeerate, node.Config.StallTimeoutSeconds, node.Config.MaxBlockTemplatesCache, node.Config.MinBlockUpdateInterval, node.Config.BlockCypherAPIKey, true, node.Config.SnapshotBlockHeightPeriod, node.Config.DataDirectory, node.Config.MempoolDumpDirectory, node.Config.DisableNetworking, node.Config.ReadOnlyMode, node.Config.IgnoreInboundInvs, statsdClient, node.Config.BlockProducerSeed, node.Config.TrustedBlockProducerPublicKeys, node.Config.TrustedBlockProducerStartHeight, eventManager, node.nodeMessageChan, ) if err != nil { if shouldRestart { glog.Infof(lib.CLog(lib.Red, fmt.Sprintf("Start: Got en error while starting server and shouldRestart "+ "is true. Node will be erased and resynced. Error: (%v)", err))) node.nodeMessageChan <- lib.NodeErase return } panic(err) } if !shouldRestart { node.Server.Start() // Setup TXIndex - not compatible with postgres if node.Config.TXIndex && node.Postgres == nil { node.TXIndex, err = lib.NewTXIndex(node.Server.GetBlockchain(), node.Params, node.Config.DataDirectory) if err != nil { glog.Fatal(err) } node.Server.TxIndex = node.TXIndex if !shouldRestart { node.TXIndex.Start() } } } node.IsRunning = true if shouldRestart { if node.nodeMessageChan != nil { node.nodeMessageChan <- lib.NodeRestart } } // Detect whenever an interrupt (Ctrl-c) or termination signals are sent. syscallChannel := make(chan os.Signal) signal.Notify(syscallChannel, syscall.SIGINT, syscall.SIGTERM) go func() { // If an internalExitChan is triggered then we won't immediately signal a shutdown to the parent context through // the exitChannels. When internal exit is called, we will just restart the node in the background. select { case _, open := <-node.internalExitChan: if !open { return } case <-syscallChannel: } node.Stop() for _, channel := range exitChannels { if *channel != nil { close(*channel) *channel = nil } } glog.Info(lib.CLog(lib.Yellow, "Core node shutdown complete")) }() } func (node *Node) Stop() { node.runningMutex.Lock() defer node.runningMutex.Unlock() if !node.IsRunning { return } node.IsRunning = false glog.Infof(lib.CLog(lib.Yellow, "Node is shutting down. This might take a minute. Please don't "+ "close the node now or else you might corrupt the state.")) // Server glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: Stopping server...")) node.Server.Stop() glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: Server successfully stopped.")) // Snapshot snap := node.Server.GetBlockchain().Snapshot() if snap != nil { glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: Stopping snapshot...")) snap.Stop() node.closeDb(snap.SnapshotDb, "snapshot") glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: Snapshot successfully stopped.")) } // TXIndex if node.TXIndex != nil { glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: Stopping TXIndex...")) node.TXIndex.Stop() node.closeDb(node.TXIndex.TXIndexChain.DB(), "txindex") glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: TXIndex successfully stopped.")) } // Databases glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: Closing all databases...")) node.closeDb(node.ChainDB, "chain") node.stopWaitGroup.Wait() glog.Infof(lib.CLog(lib.Yellow, "Node.Stop: Databases successfully closed.")) if node.internalExitChan != nil { close(node.internalExitChan) node.internalExitChan = nil } } // Close a database and handle the stopWaitGroup accordingly. We close databases in a go routine to speed up the process. func (node *Node) closeDb(db *badger.DB, dbName string) { node.stopWaitGroup.Add(1) glog.Infof("Node.closeDb: Preparing to close %v db", dbName) go func() { defer node.stopWaitGroup.Done() if err := db.Close(); err != nil { glog.Fatalf(lib.CLog(lib.Red, fmt.Sprintf("Node.Stop: Problem closing %v db: err: (%v)", dbName, err))) } else { glog.Infof(lib.CLog(lib.Yellow, fmt.Sprintf("Node.closeDb: Closed %v Db", dbName))) } }() } // listenToNodeMessages listens to the communication from the engine through the nodeMessageChan. There are currently // two main operations that the engine can request. These are a regular node restart, and a restart with a database // erase. The latter may seem a little harsh, but it is only triggered when the node is really broken and there's // no way we can recover. func (node *Node) listenToNodeMessages(exitChannels ...*chan struct{}) { select { case <-node.internalExitChan: break case operation := <-node.nodeMessageChan: if !node.IsRunning { panic("Node.listenToNodeMessages: Node is currently not running, nodeMessageChan should've not been called!") } glog.Infof("Node.listenToNodeMessages: Stopping node") node.Stop() glog.Infof("Node.listenToNodeMessages: Finished stopping node") switch operation { case lib.NodeErase: if err := os.RemoveAll(node.Config.DataDirectory); err != nil { glog.Fatal(lib.CLog(lib.Red, fmt.Sprintf("IMPORTANT: Problem removing the directory (%v), you "+ "should run `rm -rf %v` to delete it manually. Error: (%v)", node.Config.DataDirectory, node.Config.DataDirectory, err))) return } } glog.Infof("Node.listenToNodeMessages: Restarting node") // Wait a few seconds so that all peer messages we've sent while closing the node get propagated in the network. go node.Start(exitChannels...) break } } func validateParams(params *lib.DeSoParams) { if params.BitcoinBurnAddress == "" { glog.Fatalf("The DeSoParams being used are missing the BitcoinBurnAddress field.") } // Check that TimeBetweenDifficultyRetargets is evenly divisible // by TimeBetweenBlocks. if params.TimeBetweenBlocks == 0 { glog.Fatalf("The DeSoParams being used have TimeBetweenBlocks=0") } numBlocks := params.TimeBetweenDifficultyRetargets / params.TimeBetweenBlocks truncatedTime := params.TimeBetweenBlocks * numBlocks if truncatedTime != params.TimeBetweenDifficultyRetargets { glog.Fatalf("TimeBetweenDifficultyRetargets (%v) should be evenly divisible by "+ "TimeBetweenBlocks (%v)", params.TimeBetweenDifficultyRetargets, params.TimeBetweenBlocks) } if params.GenesisBlock == nil || params.GenesisBlockHashHex == "" { glog.Fatalf("The DeSoParams are missing genesis block info.") } // Compute the merkle root for the genesis block and make sure it matches. merkle, _, err := lib.ComputeMerkleRoot(params.GenesisBlock.Txns) if err != nil { glog.Fatalf("Could not compute a merkle root for the genesis block: %v", err) } if *merkle != *params.GenesisBlock.Header.TransactionMerkleRoot { glog.Fatalf("Genesis block merkle root (%s) not equal to computed merkle root (%s)", hex.EncodeToString(params.GenesisBlock.Header.TransactionMerkleRoot[:]), hex.EncodeToString(merkle[:])) } genesisHash, err := params.GenesisBlock.Header.Hash() if err != nil { glog.Fatalf("Problem hashing header for the GenesisBlock in "+ "the DeSoParams (%+v): %v", params.GenesisBlock.Header, err) } genesisHashHex := hex.EncodeToString(genesisHash[:]) if genesisHashHex != params.GenesisBlockHashHex { glog.Fatalf("GenesisBlockHash in DeSoParams (%s) does not match the block "+ "hash computed (%s) %d %d", params.GenesisBlockHashHex, genesisHashHex, len(params.GenesisBlockHashHex), len(genesisHashHex)) } if params.MinDifficultyTargetHex == "" { glog.Fatalf("The DeSoParams MinDifficultyTargetHex (%s) should be non-empty", params.MinDifficultyTargetHex) } // Check to ensure the genesis block hash meets the initial difficulty target. hexBytes, err := hex.DecodeString(params.MinDifficultyTargetHex) if err != nil || len(hexBytes) != 32 { glog.Fatalf("The DeSoParams MinDifficultyTargetHex (%s) with length (%d) is "+ "invalid: %v", params.MinDifficultyTargetHex, len(params.MinDifficultyTargetHex), err) } if params.MaxDifficultyRetargetFactor == 0 { glog.Fatalf("The DeSoParams MaxDifficultyRetargetFactor is unset") } } func GetAddrsToListenOn(protocolPort uint16) ([]net.TCPAddr, []net.Listener) { listeningAddrs := []net.TCPAddr{} listeners := []net.Listener{} ifaceAddrs, err := net.InterfaceAddrs() if err != nil { return nil, nil } for _, iAddr := range ifaceAddrs { ifaceIP, _, err := net.ParseCIDR(iAddr.String()) if err != nil { continue } if ifaceIP.IsLinkLocalUnicast() { continue } netAddr := net.TCPAddr{ IP: ifaceIP, Port: int(protocolPort), } listener, err := net.Listen(netAddr.Network(), netAddr.String()) if err != nil { continue } listeners = append(listeners, listener) listeningAddrs = append(listeningAddrs, netAddr) } return listeningAddrs, listeners } func addIPsForHost(desoAddrMgr *addrmgr.AddrManager, host string, params *lib.DeSoParams) { ipAddrs, err := net.LookupIP(host) if err != nil { glog.V(2).Infof("_addSeedAddrs: DNS discovery failed on seed host (continuing on): %s %v\n", host, err) return } if len(ipAddrs) == 0 { glog.V(2).Infof("_addSeedAddrs: No IPs found for host: %s\n", host) return } // Don't take more than 5 IPs per host. ipsPerHost := 5 if len(ipAddrs) > ipsPerHost { glog.V(1).Infof("_addSeedAddrs: Truncating IPs found from %d to %d\n", len(ipAddrs), ipsPerHost) ipAddrs = ipAddrs[:ipsPerHost] } glog.V(1).Infof("_addSeedAddrs: Adding seed IPs from seed %s: %v\n", host, ipAddrs) // Convert addresses to NetAddress'es. netAddrs := make([]*wire.NetAddress, len(ipAddrs)) for ii, ip := range ipAddrs { netAddrs[ii] = wire.NewNetAddressTimestamp( // We initialize addresses with a // randomly selected "last seen time" between 3 // and 7 days ago similar to what bitcoind does. time.Now().Add(-1*time.Second*time.Duration(lib.SecondsIn3Days+ lib.RandInt32(lib.SecondsIn4Days))), 0, ip, params.DefaultSocketPort) } glog.V(1).Infof("_addSeedAddrs: Computed the following wire.NetAddress'es: %s", spew.Sdump(netAddrs)) // Normally the second argument is the source who told us about the // addresses we're adding. In this case since the source is a DNS seed // just use the first address in the fetch as the source. desoAddrMgr.AddAddresses(netAddrs, netAddrs[0]) } // Must be run in a goroutine. This function continuously adds IPs from a DNS seed // prefix+suffix by iterating up through all of the possible numeric values, which are typically // [0, 10] func addSeedAddrsFromPrefixes(desoAddrMgr *addrmgr.AddrManager, params *lib.DeSoParams) { MaxIterations := 20 go func() { for dnsNumber := 0; dnsNumber < MaxIterations; dnsNumber++ { var wg deadlock.WaitGroup for _, dnsGeneratorOuter := range params.DNSSeedGenerators { wg.Add(1) go func(dnsGenerator []string) { dnsString := fmt.Sprintf("%s%d%s", dnsGenerator[0], dnsNumber, dnsGenerator[1]) glog.V(2).Infof("_addSeedAddrsFromPrefixes: Querying DNS seed: %s", dnsString) addIPsForHost(desoAddrMgr, dnsString, params) wg.Done() }(dnsGeneratorOuter) } wg.Wait() } }() }
[ "\"DD_AGENT_HOST\"" ]
[]
[ "DD_AGENT_HOST" ]
[]
["DD_AGENT_HOST"]
go
1
0
go/parquet/encryption_read_config_test.go
// Licensed to the Apache Software Foundation (ASF) under one // or more contributor license agreements. See the NOTICE file // distributed with this work for additional information // regarding copyright ownership. The ASF licenses this file // to you under the Apache License, Version 2.0 (the // "License"); you may not use this file except in compliance // with the License. You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package parquet_test import ( "encoding/binary" "fmt" "os" "path" "testing" "github.com/apache/arrow/go/v8/arrow/memory" "github.com/apache/arrow/go/v8/parquet" "github.com/apache/arrow/go/v8/parquet/file" "github.com/apache/arrow/go/v8/parquet/internal/encryption" "github.com/stretchr/testify/suite" ) /* * This file contains a unit-test for reading encrypted Parquet files with * different decryption configurations. * * The unit-test is called multiple times, each time to decrypt parquet files using * different decryption configuration as described below. * In each call two encrypted files are read: one temporary file that was generated using * encryption_write_config_test.go test and will be deleted upon * reading it, while the second resides in * parquet-testing/data repository. Those two encrypted files were encrypted using the * same encryption configuration. * The encrypted parquet file names are passed as parameter to the unit-test. * * A detailed description of the Parquet Modular Encryption specification can be found * here: * https://github.com/apache/parquet-format/blob/encryption/Encryption.md * * The following decryption configurations are used to decrypt each parquet file: * * - Decryption configuration 1: Decrypt using key retriever that holds the keys of * two encrypted columns and the footer key. * - Decryption configuration 2: Decrypt using key retriever that holds the keys of * two encrypted columns and the footer key. Supplies * aad_prefix to verify file identity. * - Decryption configuration 3: Decrypt using explicit column and footer keys * (instead of key retrieval callback). * - Decryption Configuration 4: PlainText Footer mode - test legacy reads, * read the footer + all non-encrypted columns. * (pairs with encryption configuration 3) * * The encrypted parquet files that is read was encrypted using one of the configurations * below: * * - Encryption configuration 1: Encrypt all columns and the footer with the same key. * (uniform encryption) * - Encryption configuration 2: Encrypt two columns and the footer, with different * keys. * - Encryption configuration 3: Encrypt two columns, with different keys. * Don’t encrypt footer (to enable legacy readers) * - plaintext footer mode. * - Encryption configuration 4: Encrypt two columns and the footer, with different * keys. Supply aad_prefix for file identity * verification. * - Encryption configuration 5: Encrypt two columns and the footer, with different * keys. Supply aad_prefix, and call * disable_aad_prefix_storage to prevent file * identity storage in file metadata. * - Encryption configuration 6: Encrypt two columns and the footer, with different * keys. Use the alternative (AES_GCM_CTR_V1) algorithm. */ func getDataDir() string { datadir := os.Getenv("PARQUET_TEST_DATA") if datadir == "" { panic("please point the PARQUET_TEST_DATA environment variable to the test data dir") } return datadir } type TestDecryptionSuite struct { suite.Suite pathToDouble string pathToFloat string decryptionConfigs []*parquet.FileDecryptionProperties footerEncryptionKey string colEncryptionKey1 string colEncryptionKey2 string fileName string } func (d *TestDecryptionSuite) TearDownSuite() { os.Remove(tempdir) } func TestFileEncryptionDecryption(t *testing.T) { suite.Run(t, new(EncryptionConfigTestSuite)) suite.Run(t, new(TestDecryptionSuite)) } func (d *TestDecryptionSuite) SetupSuite() { d.pathToDouble = "double_field" d.pathToFloat = "float_field" d.footerEncryptionKey = FooterEncryptionKey d.colEncryptionKey1 = ColumnEncryptionKey1 d.colEncryptionKey2 = ColumnEncryptionKey2 d.fileName = FileName d.createDecryptionConfigs() } func (d *TestDecryptionSuite) createDecryptionConfigs() { // Decryption configuration 1: Decrypt using key retriever callback that holds the // keys of two encrypted columns and the footer key. stringKr1 := make(encryption.StringKeyIDRetriever) stringKr1.PutKey("kf", d.footerEncryptionKey) stringKr1.PutKey("kc1", d.colEncryptionKey1) stringKr1.PutKey("kc2", d.colEncryptionKey2) d.decryptionConfigs = append(d.decryptionConfigs, parquet.NewFileDecryptionProperties(parquet.WithKeyRetriever(stringKr1))) // Decryption configuration 2: Decrypt using key retriever callback that holds the // keys of two encrypted columns and the footer key. Supply aad_prefix. stringKr2 := make(encryption.StringKeyIDRetriever) stringKr2.PutKey("kf", d.footerEncryptionKey) stringKr2.PutKey("kc1", d.colEncryptionKey1) stringKr2.PutKey("kc2", d.colEncryptionKey2) d.decryptionConfigs = append(d.decryptionConfigs, parquet.NewFileDecryptionProperties(parquet.WithKeyRetriever(stringKr2), parquet.WithDecryptAadPrefix(d.fileName))) // Decryption configuration 3: Decrypt using explicit column and footer keys. Supply // aad_prefix. decryptCols := make(parquet.ColumnPathToDecryptionPropsMap) decryptCols[d.pathToFloat] = parquet.NewColumnDecryptionProperties(d.pathToFloat, parquet.WithDecryptKey(d.colEncryptionKey2)) decryptCols[d.pathToDouble] = parquet.NewColumnDecryptionProperties(d.pathToDouble, parquet.WithDecryptKey(d.colEncryptionKey1)) d.decryptionConfigs = append(d.decryptionConfigs, parquet.NewFileDecryptionProperties(parquet.WithFooterKey(d.footerEncryptionKey), parquet.WithColumnKeys(decryptCols))) // Decryption Configuration 4: use plaintext footer mode, read only footer + plaintext // columns. d.decryptionConfigs = append(d.decryptionConfigs, nil) } func (d *TestDecryptionSuite) decryptFile(filename string, decryptConfigNum int) { // if we get decryption_config_num = x then it means the actual number is x+1 // and since we want decryption_config_num=4 we set the condition to 3 props := parquet.NewReaderProperties(memory.DefaultAllocator) if decryptConfigNum != 3 { props.FileDecryptProps = d.decryptionConfigs[decryptConfigNum].Clone("") } fileReader, err := file.OpenParquetFile(filename, false, file.WithReadProps(props)) if err != nil { panic(err) } defer fileReader.Close() // get metadata fileMetadata := fileReader.MetaData() // get number of rowgroups numRowGroups := len(fileMetadata.RowGroups) // number of columns numColumns := fileMetadata.Schema.NumColumns() d.Equal(8, numColumns) for r := 0; r < numRowGroups; r++ { rowGroupReader := fileReader.RowGroup(r) // get rowgroup meta rgMeta := fileMetadata.RowGroup(r) valuesRead := 0 rowsRead := int64(0) // get col reader for boolean column colReader := rowGroupReader.Column(0) boolReader := colReader.(*file.BooleanColumnChunkReader) // get column chunk metadata for boolean column boolMd, _ := rgMeta.ColumnChunk(0) // Read all rows in column i := 0 for boolReader.HasNext() { var val [1]bool // read one value at a time. the number of rows read is returned. values // read contains the number of non-null rows rowsRead, valuesRead, _ = boolReader.ReadBatch(1, val[:], nil, nil) // ensure only 1 value is read d.EqualValues(1, rowsRead) // there are no null values d.EqualValues(1, valuesRead) // verify the value expected := i%2 == 0 d.Equal(expected, val[0], "i: ", i) i++ } d.EqualValues(i, boolMd.NumValues()) // Get column reader for int32 column colReader = rowGroupReader.Column(1) int32reader := colReader.(*file.Int32ColumnChunkReader) int32md, _ := rgMeta.ColumnChunk(1) // Read all rows in column i = 0 for int32reader.HasNext() { var val [1]int32 // read one value at a time. the number of rows read is returned. values // read contains the number of non-null rows rowsRead, valuesRead, _ = int32reader.ReadBatch(1, val[:], nil, nil) // ensure only 1 value is read d.EqualValues(1, rowsRead) // there are no null values d.EqualValues(1, valuesRead) // verify the value d.EqualValues(i, val[0]) i++ } d.EqualValues(i, int32md.NumValues()) // Get column reader for int64 column colReader = rowGroupReader.Column(2) int64reader := colReader.(*file.Int64ColumnChunkReader) int64md, _ := rgMeta.ColumnChunk(2) // Read all rows in column i = 0 for int64reader.HasNext() { var ( val [1]int64 def [1]int16 rep [1]int16 ) // read one value at a time. the number of rows read is returned. values // read contains the number of non-null rows rowsRead, valuesRead, _ = int64reader.ReadBatch(1, val[:], def[:], rep[:]) // ensure only 1 value is read d.EqualValues(1, rowsRead) // there are no null values d.EqualValues(1, valuesRead) // verify the value expectedValue := int64(i) * 1000 * 1000 * 1000 * 1000 d.Equal(expectedValue, val[0]) if i%2 == 0 { d.EqualValues(1, rep[0]) } else { d.Zero(rep[0]) } i++ } d.EqualValues(i, int64md.NumValues()) // Get column reader for int96 column colReader = rowGroupReader.Column(3) int96reader := colReader.(*file.Int96ColumnChunkReader) int96md, _ := rgMeta.ColumnChunk(3) // Read all rows in column i = 0 for int96reader.HasNext() { var ( val [1]parquet.Int96 ) // read one value at a time. the number of rows read is returned. values // read contains the number of non-null rows rowsRead, valuesRead, _ = int96reader.ReadBatch(1, val[:], nil, nil) // ensure only 1 value is read d.EqualValues(1, rowsRead) // there are no null values d.EqualValues(1, valuesRead) // verify the value var expectedValue parquet.Int96 binary.LittleEndian.PutUint32(expectedValue[:4], uint32(i)) binary.LittleEndian.PutUint32(expectedValue[4:], uint32(i+1)) binary.LittleEndian.PutUint32(expectedValue[8:], uint32(i+2)) d.Equal(expectedValue, val[0]) i++ } d.EqualValues(i, int96md.NumValues()) // these two columns are always encrypted when we write them, so don't // try to read them during the plaintext test. if props.FileDecryptProps != nil { // Get column reader for the float column colReader = rowGroupReader.Column(4) floatReader := colReader.(*file.Float32ColumnChunkReader) floatmd, _ := rgMeta.ColumnChunk(4) i = 0 for floatReader.HasNext() { var value [1]float32 // read one value at a time. the number of rows read is returned. values // read contains the number of non-null rows rowsRead, valuesRead, _ = floatReader.ReadBatch(1, value[:], nil, nil) // ensure only 1 value is read d.EqualValues(1, rowsRead) // there are no null values d.EqualValues(1, valuesRead) // verify the value expectedValue := float32(i) * 1.1 d.Equal(expectedValue, value[0]) i++ } d.EqualValues(i, floatmd.NumValues()) // Get column reader for the double column colReader = rowGroupReader.Column(5) dblReader := colReader.(*file.Float64ColumnChunkReader) dblmd, _ := rgMeta.ColumnChunk(5) i = 0 for dblReader.HasNext() { var value [1]float64 // read one value at a time. the number of rows read is returned. values // read contains the number of non-null rows rowsRead, valuesRead, _ = dblReader.ReadBatch(1, value[:], nil, nil) // ensure only 1 value is read d.EqualValues(1, rowsRead) // there are no null values d.EqualValues(1, valuesRead) // verify the value expectedValue := float64(i) * 1.1111111 d.Equal(expectedValue, value[0]) i++ } d.EqualValues(i, dblmd.NumValues()) } colReader = rowGroupReader.Column(6) bareader := colReader.(*file.ByteArrayColumnChunkReader) bamd, _ := rgMeta.ColumnChunk(6) i = 0 for bareader.HasNext() { var value [1]parquet.ByteArray var def [1]int16 rowsRead, valuesRead, _ := bareader.ReadBatch(1, value[:], def[:], nil) d.EqualValues(1, rowsRead) expected := [10]byte{'p', 'a', 'r', 'q', 'u', 'e', 't', 0, 0, 0} expected[7] = byte('0') + byte(i/100) expected[8] = byte('0') + byte(i/10)%10 expected[9] = byte('0') + byte(i%10) if i%2 == 0 { d.Equal(1, valuesRead) d.Len(value[0], 10) d.EqualValues(expected[:], value[0]) d.EqualValues(1, def[0]) } else { d.Zero(valuesRead) d.Zero(def[0]) } i++ } d.EqualValues(i, bamd.NumValues()) } } func (d *TestDecryptionSuite) checkResults(fileName string, decryptionConfig, encryptionConfig uint) { decFn := func() { d.decryptFile(fileName, int(decryptionConfig-1)) } // Encryption configuration number 5 contains aad_prefix and disable_aad_prefix_storage // an exception is expected to be thrown if the file is not decrypted with aad_prefix if encryptionConfig == 5 { if decryptionConfig == 1 || decryptionConfig == 3 { d.Panics(decFn) return } } // decryption config number two contains aad_prefix. an exception // is expected to be thrown if the file was not encrypted with the same aad_prefix if decryptionConfig == 2 { if encryptionConfig != 5 && encryptionConfig != 4 { d.Panics(decFn) return } } // decryption config 4 can only work when the encryption config is 3 if decryptionConfig == 4 && encryptionConfig != 3 { return } d.NotPanics(decFn) } // Read encrypted parquet file. // the test reads two parquet files that were encrypted using the same encryption config // one was generated in encryption_write_configurations_test.go tests and is deleted // once the file is read and the second exists in parquet-testing/data folder func (d *TestDecryptionSuite) TestDecryption() { tests := []struct { file string config uint }{ {"uniform_encryption.parquet.encrypted", 1}, {"encrypt_columns_and_footer.parquet.encrypted", 2}, {"encrypt_columns_plaintext_footer.parquet.encrypted", 3}, {"encrypt_columns_and_footer_aad.parquet.encrypted", 4}, {"encrypt_columns_and_footer_disable_aad_storage.parquet.encrypted", 5}, {"encrypt_columns_and_footer_ctr.parquet.encrypted", 6}, } for _, tt := range tests { d.Run(tt.file, func() { // decrypt file that was generated in encryption-write-tests tmpFile := path.Join(tempdir, "tmp_"+tt.file) d.Require().FileExists(tmpFile) // iterate over decryption configs and use each one to read the encrypted file for idx := range d.decryptionConfigs { decConfig := idx + 1 d.checkResults(tmpFile, uint(decConfig), tt.config) } os.Remove(tmpFile) file := path.Join(getDataDir(), tt.file) d.Require().FileExists(file) for idx := range d.decryptionConfigs { decConfig := idx + 1 d.Run(fmt.Sprintf("config %d", decConfig), func() { d.checkResults(file, uint(decConfig), tt.config) }) } }) } }
[ "\"PARQUET_TEST_DATA\"" ]
[]
[ "PARQUET_TEST_DATA" ]
[]
["PARQUET_TEST_DATA"]
go
1
0
context/context.go
package context import ( "net/http" _ "net/http/pprof" "os" "github.com/0xAX/notificator" "github.com/erroneousboat/termui" termbox "github.com/nsf/termbox-go" "github.com/erroneousboat/slack-term/config" "github.com/erroneousboat/slack-term/service" "github.com/erroneousboat/slack-term/views" ) const ( CommandMode = "command" InsertMode = "insert" SearchMode = "search" ) type AppContext struct { EventQueue chan termbox.Event Service *service.SlackService Body *termui.Grid View *views.View Config *config.Config Debug bool Mode string Notify *notificator.Notificator } // CreateAppContext creates an application context which can be passed // and referenced througout the application func CreateAppContext(flgConfig string, flgToken string, flgDebug bool) (*AppContext, error) { if flgDebug { go func() { http.ListenAndServe(":6060", nil) }() } // Loading screen views.Loading() // Load config config, err := config.NewConfig(flgConfig) if err != nil { return nil, err } // When slack token isn't set in the config file, we'll check // the command-line flag or the environment variable if config.SlackToken == "" { if flgToken != "" { config.SlackToken = flgToken } else { config.SlackToken = os.Getenv("SLACK_TOKEN") } } // Create Service svc, err := service.NewSlackService(config) if err != nil { return nil, err } // Create the main view view := views.CreateView(config, svc) // Setup the interface if flgDebug { termui.Body.AddRows( termui.NewRow( termui.NewCol(config.SidebarWidth, 0, view.Channels), termui.NewCol(config.MainWidth-5, 0, view.Chat), termui.NewCol(config.MainWidth-6, 0, view.Debug), ), termui.NewRow( termui.NewCol(config.SidebarWidth, 0, view.Mode), termui.NewCol(config.MainWidth, 0, view.Input), ), ) } else { termui.Body.AddRows( termui.NewRow( termui.NewCol(config.SidebarWidth, 0, view.Channels), termui.NewCol(config.MainWidth, 0, view.Chat), ), termui.NewRow( termui.NewCol(config.SidebarWidth, 0, view.Mode), termui.NewCol(config.MainWidth, 0, view.Input), ), ) } termui.Body.Align() termui.Render(termui.Body) return &AppContext{ EventQueue: make(chan termbox.Event, 20), Service: svc, Body: termui.Body, View: view, Config: config, Debug: flgDebug, Mode: CommandMode, Notify: notificator.New(notificator.Options{AppName: "slack-term"}), }, nil }
[ "\"SLACK_TOKEN\"" ]
[]
[ "SLACK_TOKEN" ]
[]
["SLACK_TOKEN"]
go
1
0
CTCI/FrequencyQueries.py
import math import os import random import re import sys def freqQuery(queries): datadict = {} out = [] for query in queries: if (query[0]==1): if (query[1] in datadict): datadict[query[1]] += 1 else: datadict[query[1]] = 1 elif (query[0]==2): if (query[1] in datadict): if (datadict[query[1]] != 0): datadict[query[1]] -= 1 else: if (query[1] in datadict.values()): out.append("1") else: out.append("0") return out if __name__ == '__main__': fptr = open(os.environ['OUTPUT_PATH'], 'w') q = int(input().strip()) queries = [] for _ in range(q): queries.append(list(map(int, input().rstrip().split()))) ans = freqQuery(queries) fptr.write('\n'.join(map(str, ans))) fptr.write('\n') fptr.close()
[]
[]
[ "OUTPUT_PATH" ]
[]
["OUTPUT_PATH"]
python
1
0