_eȱ}֔*eOXㅈjEus \G+!Q(U jKZ ^Z3Gx%^9'aY&ElBŌH^eЍnL& hc*p偀#-]
$"|%"b9#)2_ 3hP\([pE0I ,u'g~´4Ɯ_HxI/gv{{聎|ʰX[ Ҭ!*DNnRpDҸn
מ9f2< jG>/)v Rѐ[/
:vn .
Z9Nܫˀy $!DPYaC9Ǜ|"G-9KFu(ޟr/97"yTWa A_zP@y[' 5d"*[s䪪`v NYNu\0:ʊKy+py-3|+#чmPe$$\=tAɄZnI+_~ȉS m_ZP iizh']-JEv/DcjZ]{0~ƹf'#<~_?ꓪ
J'Qnj-Iœ꾁n~vxȧ>7+|ۚ5U#0Ħ+I1
'rWX6'왽7~IEbNᨵj `j;E4[~%s*;:З|}V_% ~t:J:'y( Nb N|eQ!Gwߴ`jrM L8Ȧ| g5@8(쉾$+(? Ӓ$ŋb3!;3pÜb3B"*DPb4727|ThR$ Q{P#9ٜu+埤JQ,)2}^EQ}؎h3 n:I! eGxrܰs!8:JP(%tENɌ@cCi5gE_ĚM E@0#fu/42o|[Ifsoևen 2')Ga̭6ܲt$r6{BҠQɌlq'D
MtWj.
Y>?u6"!;yIҌHTI^9Y·/,$)_= ǟc.!+IG2iiUԚ8ء`$z$DBT$:~q (
5xPHP+?~ snT.|# K R":璪 {$)O~6 Li
י au@ /kJ$*gEMw,4.N* qEtwuE !iLhNGߢ^"*}"W69:1ʿc;w/MI;Ky@V[_E __{S^ҿFM[FB䄢ʇ"OO OINMn4pNd`0)'VLErXs^ >vJ:")wz'/ ܱjI`E9VH_ u ,dBȂX-VQ N
32sֹUN)0=v释;3ۖ4C"tzކGAXָ ((t(Ȃ3ǐܒkAC
'ݞ|PRiPh(2A#y,V, EV'Ҟ~b:@R4i%R>]m#@fZMTBFRDt!IIug->d
kC
TW©#o1G<}5)f3JHDe)DBmDVnnc9HsB(|*yy Y#뵟J< F#pBQcq#`%w"b'G""2S pNѴ"c Q< (0! #)ɘ. cE|T6[! q2Q .Qd oYMj |&Ө195#9~pHPΖмdQ
K-fg5 X/ŀ%!5 @~"rG4"w
ɴDt f_J&u!Hn ! G;wtcl鉨V|TR%%J^ʅWi>253Fk֘a\l=_B}FZB
R!kCG}E$u2Ɋ3i*wRt!I8LjIQ
k"QNDRja Fg4dq Q0@04p1Icd%p }yM NI(EJ !5%BLUX{uJG՚kkh#?8*Gpr9%mѰQ/E`%0)dB0 Kus6Iϕd4 dw.gV8 9;\Qf]s9>l
?MAC l7o֙I6휝 I2 ]re_d\,Yس|)h3H]dXށzj]Y{d+҈H$ ,o%#ע x,p>A &d{JvmC߿r zPI0*frE(X8]
uOva28d ]fXhLe~ԪT-+iZPHdVO :ԶeC@vNt34NG:Ho_dp#{N;!6wM
P˳ʲ24 Ň@{ߏڍ]#g*r:HE ="(ih#TQ,B7 hX98jVo.]|^̞)ײz 0RjX6 >#`abF3pi>KHJVN k >N(_^Ob!4* "HNz9&\VlX
˫l
a89p[B| rF& ګĜmշt+BOT1onyi D J2546%',EaO [H`z#@Bw\rq iy[hBzdK`u88ЂUeUvA|Pd QrPLE䄎Lmuf_ &z*5d e31# KP[V{wsoo^4ۮ C |84)9~ FRcZ2,5pd G)CR;AA
lnܹ> kUmFDh8UKD@S~<D7brˡd|l0بEJv#!W0
JՍ&)1&lj|k%(Nn}胒ʠHV͞#iU*Kӈ"מX+?9F t7 Rd=d5"eޑ㽋 ,piۯX C 譼bKɩL(}V֮'Z4(pYqVn=5V%ߖHJ2*Qu6ڔHEvE;ӄ)Sol>=z:zZFR ]h DjČUv%SvHBD(bڹdRLUXW\;I= ft+\S6 Jϝ9jG A
ck͚cbIYn4*aE`g!YL2^t7Z=OG>s4̆%V]A
*2Qr{ʲQdz!&_: ["(4$E;m
r^ ~͆m9Ȉ@Կo8AA5q JnYn;rOP^$Sb+=99)6"ˉXyI 01lkRxMZWHX(<>`9<:x)ֹdќe%Z^ FmJ16
2{1\8 jCVI=Ғ&=ID~o9s uFR uaOƃ8)4]
kL:рȍؑQR*L-9tU,@
$m}-,Kn30څS-^;6's7L1L{;l"C 3MJ>n)#)@0 VvS^\4y/^LjnDZ
JNE )ܒ[%lc T[ٔ&rK!Rd)K=IQL .gD4!Ϊ3 6aVuUIQB&[Zt
kjh]S X϶4tz^TԦ|6DR&3yf@th%3nW&,HZ1 yaړ[la [ظ۲: #)9:3@[߃ߏAvvM2 a8ɢЪW++tq g EB=N+6Z^NMQy%^eiZ<iz{TH\^( f;A@wc YM:1Qu+Il^I& #οy Y *&-K b+GA2slY{l7 %OmʗၲO肆S0\se)
@NQ|I#i` K?( o 0`^ҽ1#)CdX oG⥢hS諂dT"+`(2;Cfŝe}ؕuOq 8$)`@IMx%gMA 4D2@!I3P+3 0!ЦPl$WZc |s~%) i%iWXIF>Rc
Oc\ JҦ\~ˤMg<@ %HIۥ3vd68!+ݴB5+RUM{63wbgzpuQ GM;4e=D pÎ5Ψj-h ELԈNf`Bdry仢_ژARXc>`8.N5x6e, `0U[V`>(*
{c3T!+ %e IR92x
t<'0MJ:T^&?;
Аʞ*yb*{QoҦPD'\h* =C!PTD(brc(E36NԞ_ RyOp?ST9WLvFRt ~pM=\dQ EG0YiyWw7:}:!To'bB {Q<ꓶ iS_El6[x '6jΟ"g{ CpbE%[Tb1n7[bFoMqN!\ٞ6*H E"^`gs aGd1"="'<=T1HF؋¶DL>ce8>y?6ٍ.)fFcuki3.[Q@'v6Ib%/^8TE,dVV_#E kV.jIp | }gV%2vHV7ƦiB6ihv҆7%-i@M R6Xljd 2 l݇w3v5jٙ|> ;;^0ģ̔G* E\05P}bCt @ IDATJjד}1 6@TTHyp{~_XLWKp!ҭ P`Ei⡓Q@m嫮/S KDfʊ4.^JѻoJoM7;6mg;\ %TT"q!''5Ϯk [h{q BQ1' H +J8?3G PR+푱Ⱥ;^Ӵn
[W_7_##gu5LS+&#KӾf}>9*DК%+ڙmꂇFJXTEs'?i,#~r8,J2ʃuA @b+Vx,@(.uK:ؑи';Ii"sMNyЋ?./UI2Mb\cdkgS}q&ީ23:&ӓyc2|,DnPTPdIKh|ā, PU>ȷu_d4¤ux _<o)sZ@~̄3rVD+-4ǤgEfr)\R03>bҭƂ|T/Eb$ s_&f^ungCW:XK =@Mtpo3
@[WNcG^;r|cxp,m?d:=سZۓJK
2"/" N۞ g{B *bD8D @
(Lt܅l/՟^^yn7WR Ә*e9'q ,{+vHEEƨd:} Pl<6AމRi(k_nlz &n!Re 3
v3Odg_|`m}M_W<) /
Zʨ W֗U'*;0$ s)]a.a:(%iՏc6])Ƴ
T1TEW˗t[ٍ0c6::5Ƙou2@ym\u"pN9 IO_P:JLfKٿKGNp? XD>A*v-xEzZb}Zө բ]z
1®bzՔAM ok1;
) dC ;V(W
yyBI| *fҨуf(}y
QznʤuubOOQRmuJeM@%V+8c3
D**Xd@m],baCmwVVBǚgW ~ ֏m֫2>Y+N&U ' my'H (+@UX~z*ȊG ^Da"A)O^+jlH"\F؋Shj 9ӌզzad }}ύU^xd1Mm¡g 2yf救vBI< PDf|Yi9OLV*. uxg+PA(@UzNsz,DY72n`aXBYyϱѣY&G8["x₴K ɒR"-*x&f/V* d<>QG^d @a/2AIG@*t:9ЖӚ-5 [s ;ɕ bWP/_!\M X GO:W܁UtA(G:8ʼ[ƋŖ ػz}T@4On=̣)|Rb1ͬ )֓$|s 6=yϻ&[7SeJ9+*SJ^|| XʵG
ig/
x O!@? N\SWS| hv89Bۊ݅A@Eo5DN-j
)L]EQFN8wq/D" ((eyi ,]1+&f˖S]90eͤ\pWDjS**Fi+phVPP0d+kA{C" ' 8*Y\\hʙHqErg lMwR<0 dqe& SZ_kR
Jb()r"1 (._
L[ XRӺ e\}˹RpSQ[%'~ Zt
0)' Ǒ$K
_xRgJJeG
& ]`5@7J:pO=δV@}RQ 0Wz2}k%ucSFfi5M t J>j
/~/1OYKg0YAt:1@\'L8ѐC-K]JpU/Zen_:zYrZMG'^2ʢ$ˡ!9ہ4VGY()q %@ QR4ExdU͌1aX$1m9*uoR .^Uɋ?^%kIJ()p0T69)S._N0qsT |?vnLh N/ :V[P4h6jA!Ҝ.()E P 4 /Ir@^X@,ZvRn<7e 6>yOkE.h_F(bk.G /pa]6@9 +įGN 5Izxm۲q4>CA}3峑J GFXnr =+#ѓco>/e Y8 -2?XϋoN SHGs`m
&&fNuqF
~و O4 }-r;ƴg'0K@pM6[rK**;vWh d|l OZ9ia6O] tXgMcNT<()1@G_\5 |#& V^U}5+2SʍqE:>_ʋp\TR&-?3z^
15=Ɵ
[/U iLh%TPz6[B5Ab[ y!UࡤTPA:Nbz
jLMXa^K嶬Wm
jT;zBՎbmM W2_ mkj5u!泟ض0T& '>e |U[MS{a )'%\}> QcWy8_y#bQod&-q;o!ȊZPc8 _ە@;OR~9=4&!B</g6|*a *KVY]_xy
J@>Lw ]C*(E֔M[đJ" KJ%M &Nrfm]jJZrui(xEtSJ
ݢ aU).-&_o
͘mh`ږjwRǣI7D]Ow{PɟD.$wF^\k^HY5A JJ1((k]HI)&|~j ˿#>PQRZ4RZJ1>^ kB0 I$SW(%YqAʉM-n
$ %O*N5e6},0L=@,2SBByG]4FHƥ\g~jkSYjGBMUIyi/d=sq+HEDBpjeD 1wKN)'S]~utk
% %BO,N|,\QnsxX@]Kq8uP꣖W 3@c|bF0~ى(!v+;v*S;"Rɧ&~ \`x,X/_r csg<GJn_4cZ(qPR<~ x] 3iV8:V- !M@4Ķ+;Yjfz 5
IeqMq%o8q/ ~Cn_vyɇ 4uЍN+=*\ISޘ4)b=댩o<`HwDCgQ~NF1S>.D¥fherTtY[2+B=<8
WYd|
a!!0 ݟYtU`*{ ^$)
MYRRjx16Pp&zDR %K3gCU`5C?M%šʹBW+,ϾBZ;=.8yB). Wb/΄钿m4yb$T&yre/k8k>9L33Q9菇lb8ܾ:k8()v /@g q7ܬ
3O3n7mL9MѺXR풒B \߰-o[@I8]GŴ fȇҬìBGPx;+_AUH , 뫋~kӕ3?v4zRTIQٜubMXyu|:HL|TwmO}T2}eB JJ( ^!@7r~Jǃi{mrpܢ7s-KzL7, P8Hf6jݏ 0nYZZrYeW
~,hoR78x[e$EeKteC+[HJNs,c6Ւ_ȿ@l;zW!=TJNDb8}f.g4qh, P?oCD`s>5m0Hd鍽|4 r_
%@ ?. _XL=`i.-礰.ꩃX) g;(^[EBJIBRX3knx;WtR1\YcMfbbe⧾W {º5n_& {H Az+Y^Cr, 5j`(n˹($ӌ1䬑TВ4o6n^GI2&|mNV3f3~ah!tkK,"Zo\Y4D!HmMV!.Rʈ^Pp]
3뤨t=R$ʉQ9c}a6{wx8:ܾr)cFc ʆQ0*Q(A@gRrHVOE f;@?x䳒\l=z6M+Sv5~PuΏQI16.bSDO)-OvbSǞcMb=wDj|K}ߢ6HN I1B͂>ifr5m@a[B1J B P6~`'IeL&A,0*>)4
F='U5A/Dӭʆ맱uyF5(sL+)AY r( smx+ E)
?IB vˎl<"Q1-
z }wմܶT^;N}wzN1d/}L[bP"
A[ѕ}[~짟 c_rc7Ӧ]t ^nҺoHGi
x[n_nk|J*JʅnzVå1\N^n-\0L
g bL%WV4?`|$[@i|HTÃ.#E"+J=0p]YX=;FX"=ng [YqyJN 7<+cTx rOlGVL)#51_PvbvC>UL Js(gO:!d\) ezCsT^hFSƾن8})Y"r4HzEWO1c&N]EJ7p5y|%\-,oeÖ&{I17G^%'t\ 4(()ƸmMh-L$t I
!ȇi Fg}sqMhqJ[Ѩ"z8l?\<奔6FF 09ve핿u/ӝ)p 2&YY,0#{{wκGQx#LL('ȵ0+=Wxގ'τmAIqi(5 l7NA leKVjE{+Y(֓9o8`dL 31<|ʪ _^p2+wəF
az~5ҲɊ?^~t*CVH*#d[&'iӝ+qJJ<ɾ)/ Nߟk=芢"HQ=]#`ˑ8# ⁓P",yKr
cio%A߬l:=_ 2ksd;'?*jլ[[͎- gaoR.dc`CI`R2L!{ύ7kMk'8J}wW)vhp^ȽeOj Q*hiVK[)d]aDڨ=iaֆa)WD7Xsm&-eD??{bbkr3Dp:VJG'ל~3ʛ><ؙ 4'~G߭ο'W>\+b 0,SLa*Y!7I-Xo <ҿrd~i ] =| .H*y{^FŃrBJTN
7nU~%3=&w ZZ6۠a ;9%i% P|L.]Hԁ!G!JJaCB '~fW2-!~EzM;+?;1Ymld5]AˉBٍI$MbPRҀwB_͡YuA'r5YϼʎyrҪBwYkԃ4L4d`| oJPdp7F.ORy)D9Õ _@,?dݪ'GzJܪ[YYt _K$#9FVNe5>\os.@8872qW+\gZQ!kʬV zv()2cXiݬ\PIŤLm4V2?qqۧoYeENle_.z@K(̍_៛WU~{?䡶1v9C!R<[P;?n
%@I) AZO¶/'dEl#ϲC R3
EH뙬'r2 픙Gͽd~۱f`VIq|Je)fzL8
f5Iw_KVҵƏx%/^응Cj$r#EE 亴L}/`|ΥYV}dM.ѷ[m|' wwm4
%%+> 7R\
$mN3uN}8/[uN*(3Jj~暡#'()9xRi)g25}Ca08G@2_\z)ߥVd*a ;M.zZؔ[ x@ثd9|TUYAe2d7J&m 2|/TO4/gYTLڛYs(v, @IɈś; ެn%tz ; ʺMR9I`88ij
32,'rb_9IULL{k yC&L;R?kǯN4h$p7l
lZ?F!._ E ;o e58i1QQt#)y*Rɺ|]즀PH F ^hs]I8C>~aߌvë0J6:?2 x0ʥnBezTN/+-JRa3Z5seQ
ص{٢) xGGNlG|FYIQ/S*y-%8ޛ?LkKЋqM0CU2ֱQ[7 vxTb]ͥbv>:_W(rumq`ҽ) ~tT6(LILۣޤXG{ONhy z+
@ ȇgmw:rF:S'T:U՟"Ych|_~diPt8 >lGY|49TL_` zS,JƟ`D;cѽ5ALFݠ]r?}T5o\JRB, =`
'Rl08 m`C"w~wkd d;N6m;]2?]Aۓs/İmb_ T'iiEa
q1'cT\ެקvaeV21&vom & >\bG 3"qs:{]eaF^虿OD p;J[_n14fK%yfVs?h cVRNXe֯ Ya)
L2]10S)Bn϶쒳rҧ &fab}y-)zq^ 4}onh*, P>t_s: j2D粞dkWE%~()h[Q.fYƆ@+J'hbE&d`Vc^RN*m*MO9"Xԛ.]**-"*3L> G]^
`" >)'3% = ҥj^N**+؆N+DY]V#ދV49PR
X RA7Vvˤ\ZJaR.
R@ۭ(*JKE&5%46" ]\=i5Nv@ liΟo]+-ŒWN2)]mN`Yل 0%Z!Y
)
WH
)) I+tm)1{ڥB~1-oRQi5,QJ y){m+fY A d毯*Myr hLf ?ݗ ߿L젤d}#8&?6*@ YST}9'LXaG3?a..ņ>h>h*'HAfڼM
f8qPR2@®6Ev83Ț s1(
bUQik̓E :*GEZRԺ}vb
E Q" Ne*rCSy uO()Z/` ʃXhdJ"_D${䁒ⅳPe2k*zӊ
)8#O.mf䛳E4/76;cs̍ v|dF0&&Wɵf'bth"z,N#ۜ82xdN HEEۛf䓮_Gco "֔V>aM@zGRT*"Κ{Zz+CV>\KI!"|hwzlЧaʃW _>ٻꎿ; @i#';_NyrӢlxjPR8V>#`GQ87 EeҚQmc+
ުTTD< 6TP/wAKecߋyM6w/"tǯ
vw?-BU~vCz1V= Z>*ǤB ĦTT8F-!jY@ٳ-u Py SǤrՃ }=acX `饢27 ):EaH#@('Y
:s]ҽ:1l() X ߰ ġ' %%?RqL
ϫ/n[_ciU'x@bfzό\^Z c 1 z(v~3>F~_c'jpeT6i=ј{m&
Ò |Jv\8u4 e?-(L}|tmזʪbeLc 8I`{cZv3m(wjJ9 (>&nt>ָ$gXvg#CNJ86*'lːw.d C)iO_l;,*#C"j1δuP $p$quxa7&mV6 ) ڮ\22RsQPkfhks1 r۽X%:ԠXn':J((z<]A1?uͪx,JԄV+@zpϘK_& LcOc
ɉ
dU*(U'oˡL,n]4] N2Sk_"Sne'sM= :iU9汬j"jփ8 %$ ?zx zpm_2տ`6c<W|n\m% ]99ϷNh^)sHܳt8b>`ҭE}PN,P`*7{8g w^/ۘS3V'K.Ilxɢe=p=2%wJ:k h .Yg;r2O ( c4}4yo8f+?giWΟ TGm$#uA&1IFX痯U _sҎ|/tʾq`G^}c-\x?h/,e{t)k7 AtXvRNzӚI F42gґ |3>ь/ x&$a Fj {О>MP RVfeEzmX9fjz_~}lu @ ;1x=w({ٺ#}3F~E 9[mvzR|=Ct!VCve/ycg-?#ٳaBÍ GzudmK[}ܿ.;S[O{!
gm >9K@+LK)D(ׯˠMʅl,b)f~2kYe=k/]R_V[\,k M
;m?rvĞg N@r &tۆ ۂ[`7|eV y2ٖ6lǰ H@P? ZoBo(LKLsD^:P/aRփ &1tɠe6Xt%Dt{.+>A _
S)pW#W0o^PRy^Z=9q~2^AkBޫ YC B@WV
lOH_GJ!lD@>hh9F/RJ㒑PARiFe(n% 5&* p.Ol lzdqtCQL/RofI;<;r{eO ƾ bW|LEJ#ӋkJ]R`%*nk )G
I)&yyOV O JJ~F(^0f`A*9%ȳ;u WGoǩ Pd;+q-sI
ytB`եz,i "B)O⦋YPYPRZkL_F7^f:##RP"Xވ Pd)uT`Sy!-2X@t"HDUV5a֝?ѿ9M|>ESe* Ǝ /w
^! ߂S|ނ I1 FNB)Hy]F&)`)6-KWB:QˉbJJ3fAQ::Rz2GV1qwomw@ JD`M2AoH*ݶրIUNI (I]<.|aȤv6^ /"&fBy KJDm+*\<=
i vX?ld`֓bG? 0DoÀ#{ͨ2#el .fLCuH"X~taƑ IDATt$cA~( bR,.#G7ǻ¶q2~mzli
hScLitA&_η~
OOIp-RN.T159OVEDSe(%-On' F˄6\HasxX m]4sjũ\x\(
[#7'o@Ef4҃z$kv_ O?
?3%ԏQ&͡~s?˙@_X(!|f${,l>/egriiC:b)FFD ۺ2}c8ҏAH'J$ %'7 F;YU֓vYLNk;ޙm~Tmovi.c)(er0UWd7M"#|buЕQ'[=;Jmk6kZ%c I܅=N@*+]?~ b'qx,zngG?ߍDž'0/d~哮tAHF T 2*zrƷxZ H% %% &'
֓ g=]dx2]iuMؤ[i `ʅaIx3#ݕh鐒xs쭁A ("{vu5
.aEAƚ& yºBB<{J"]iu.
0R?7ٔcr?a٭
_T6ʅ<A @ @98Dz*Z/n=㌏qǫ/n$
+ w bls PIԘ%NA @ @PR\Z=NͰa20R "& K$_k IENDB` golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/example_test.go 0000664 0000000 0000000 00000012553 14563666056 0025305 0 ustar 00root root 0000000 0000000 package scalewaysdkgo
import (
"fmt"
"time"
"github.com/scaleway/scaleway-sdk-go/api/instance/v1"
"github.com/scaleway/scaleway-sdk-go/api/lb/v1"
"github.com/scaleway/scaleway-sdk-go/scw"
)
func Example_apiClient() {
// Create a Scaleway client
client, err := scw.NewClient(
scw.WithAuth("ACCESS_KEY", "SECRET_KEY"), // Get your credentials at https://console.scaleway.com/project/credentials
)
if err != nil {
// handle error
}
// Create SDK objects for specific Scaleway Products
instanceAPI := instance.NewAPI(client)
lbAPI := lb.NewAPI(client)
// Start using the SDKs
_, _ = instanceAPI, lbAPI
}
func Example_apiClientWithConfig() {
// Get Scaleway Config
config, err := scw.LoadConfig()
if err != nil {
// handle error
}
// Use active profile
profile, err := config.GetActiveProfile()
if err != nil {
// handle error
}
// Create a Scaleway client
client, err := scw.NewClient(
scw.WithProfile(profile),
scw.WithEnv(), // env variable may overwrite profile values
)
if err != nil {
// handle error
}
// Create SDK objects for specific Scaleway Products
instanceAPI := instance.NewAPI(client)
lbAPI := lb.NewAPI(client)
// Start using the SDKs
_, _ = instanceAPI, lbAPI
}
func Example_listServers() {
// Create a Scaleway client
client, err := scw.NewClient(
scw.WithAuth("ACCESS_KEY", "SECRET_KEY"), // Get your credentials at https://console.scaleway.com/project/credentials
)
if err != nil {
// handle error
}
// Create SDK objects for Scaleway Instance product
instanceAPI := instance.NewAPI(client)
// Call the ListServers method on the Instance SDK
response, err := instanceAPI.ListServers(&instance.ListServersRequest{
Zone: scw.ZoneFrPar1,
})
if err != nil {
// handle error
}
// Do something with the response...
fmt.Println(response)
}
func Example_listServersWithZones() {
// Create a Scaleway client
client, err := scw.NewClient(
scw.WithAuth("ACCESS_KEY", "SECRET_KEY"), // Get your credentials at https://console.scaleway.com/project/credentials
)
if err != nil {
// handle error
}
// Create SDK objects for Scaleway Instance product
instanceAPI := instance.NewAPI(client)
// Call the ListServers method on the Instance SDK
response, err := instanceAPI.ListServers(&instance.ListServersRequest{},
// Add WithZones option to list servers from multiple zones
scw.WithZones(scw.ZoneFrPar1, scw.ZoneNlAms1, scw.ZonePlWaw1))
if err != nil {
// handle error
}
// Do something with the response...
fmt.Println(response)
}
func Example_createServer() {
// Create a Scaleway client
client, err := scw.NewClient(
scw.WithAuth("ACCESS_KEY", "SECRET_KEY"), // Get your credentials at https://console.scaleway.com/project/credentials
scw.WithDefaultOrganizationID("ORGANIZATION_ID"),
scw.WithDefaultZone(scw.ZoneFrPar1),
)
if err != nil {
panic(err)
}
// Create SDK objects for Scaleway Instance and marketplace
instanceAPI := instance.NewAPI(client)
serverType := "DEV1-S"
image := "ubuntu_focal"
// Create a new DEV1-S server
createRes, err := instanceAPI.CreateServer(&instance.CreateServerRequest{
Name: "my-server-01",
CommercialType: serverType,
Image: image,
DynamicIPRequired: scw.BoolPtr(true),
})
if err != nil {
panic(err)
}
// Start the server and wait until it's ready.
timeout := 5 * time.Minute
err = instanceAPI.ServerActionAndWait(&instance.ServerActionAndWaitRequest{
ServerID: createRes.Server.ID,
Action: instance.ServerActionPoweron,
Timeout: &timeout,
})
if err != nil {
panic(err)
}
}
func Example_rebootAllServers() {
// Create a Scaleway client
client, err := scw.NewClient(
scw.WithAuth("ACCESS_KEY", "SECRET_KEY"), // Get your credentials at https://console.scaleway.com/project/credentials
scw.WithDefaultZone(scw.ZoneFrPar1),
)
if err != nil {
panic(err)
}
// Create SDK objects for Scaleway Instance product
instanceAPI := instance.NewAPI(client)
// Call the ListServers method of the Instance SDK
response, err := instanceAPI.ListServers(&instance.ListServersRequest{})
if err != nil {
panic(err)
}
// For each server if they are running we reboot them using ServerActionAndWait
timeout := 5 * time.Minute
for _, server := range response.Servers {
if server.State == instance.ServerStateRunning {
fmt.Println("Rebooting server with ID", server.ID)
err = instanceAPI.ServerActionAndWait(&instance.ServerActionAndWaitRequest{
ServerID: server.ID,
Action: instance.ServerActionReboot,
Timeout: &timeout,
})
if err != nil {
panic(err)
}
}
}
fmt.Println("All servers were successfully rebooted")
}
func Example_createLoadBalancer() {
// Create a Scaleway client
client, err := scw.NewClient(
scw.WithAuth("ACCESS_KEY", "SECRET_KEY"), // Get your credentials at https://console.scaleway.com/project/credentials
)
if err != nil {
// handle error
}
// Create SDK objects for Scaleway LoadConfig Balancer product
lbAPI := lb.NewAPI(client)
// Call the CreateLb method on the LB SDK to create a new load balancer.
newLB, err := lbAPI.CreateLB(&lb.CreateLBRequest{
Name: "My new load balancer",
Description: "This is a example of a load balancer",
OrganizationID: scw.StringPtr("000a115d-2852-4b0a-9ce8-47f1134ba95a"),
Region: scw.RegionFrPar,
})
if err != nil {
// handle error
}
// Do something with the newly created LB...
fmt.Println(newLB)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/go.mod 0000664 0000000 0000000 00000000223 14563666056 0023361 0 ustar 00root root 0000000 0000000 module github.com/scaleway/scaleway-sdk-go
go 1.17
require (
github.com/dnaeon/go-vcr v1.2.0 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
)
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/go.sum 0000664 0000000 0000000 00000001266 14563666056 0023416 0 ustar 00root root 0000000 0000000 github.com/dnaeon/go-vcr v1.2.0 h1:zHCHvJYTMh1N7xnV7zf1m1GPBF9Ad0Jk/whtQ1663qI=
github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/ 0000775 0000000 0000000 00000000000 14563666056 0024072 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/async/ 0000775 0000000 0000000 00000000000 14563666056 0025207 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/async/wait.go 0000664 0000000 0000000 00000004050 14563666056 0026501 0 ustar 00root root 0000000 0000000 package async
import (
"fmt"
"time"
)
var (
defaultInterval = time.Second
defaultTimeout = time.Minute * 5
)
type IntervalStrategy func() <-chan time.Time
// WaitSyncConfig defines the waiting options.
type WaitSyncConfig struct {
// This method will be called from another goroutine.
Get func() (value interface{}, isTerminal bool, err error)
IntervalStrategy IntervalStrategy
Timeout time.Duration
}
// LinearIntervalStrategy defines a linear interval duration.
func LinearIntervalStrategy(interval time.Duration) IntervalStrategy {
return func() <-chan time.Time {
return time.After(interval)
}
}
// FibonacciIntervalStrategy defines an interval duration who follow the Fibonacci sequence.
func FibonacciIntervalStrategy(base time.Duration, factor float32) IntervalStrategy {
var x, y float32 = 0, 1
return func() <-chan time.Time {
x, y = y, x+(y*factor)
return time.After(time.Duration(x) * base)
}
}
// WaitSync waits and returns when a given stop condition is true or if an error occurs.
func WaitSync(config *WaitSyncConfig) (terminalValue interface{}, err error) {
// initialize configuration
if config.IntervalStrategy == nil {
config.IntervalStrategy = LinearIntervalStrategy(defaultInterval)
}
if config.Timeout == 0 {
config.Timeout = defaultTimeout
}
resultValue := make(chan interface{})
resultErr := make(chan error)
timeout := make(chan bool)
go func() {
for {
// get the payload
value, stopCondition, err := config.Get()
// send the payload
if err != nil {
resultErr <- err
return
}
if stopCondition {
resultValue <- value
return
}
// waiting for an interval before next get() call or a timeout
select {
case <-timeout:
return
case <-config.IntervalStrategy():
// sleep
}
}
}()
// waiting for a result or a timeout
select {
case val := <-resultValue:
return val, nil
case err := <-resultErr:
return nil, err
case <-time.After(config.Timeout):
timeout <- true
return nil, fmt.Errorf("timeout after %v", config.Timeout)
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/async/wait_test.go 0000664 0000000 0000000 00000005453 14563666056 0027550 0 ustar 00root root 0000000 0000000 package async
import (
"fmt"
"testing"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
const flakiness = 500 * time.Millisecond
type value struct {
doneIterations int
totalDuration time.Duration
}
func getMock(iterations int, sleepTime time.Duration) func() (interface{}, bool, error) {
cpt := iterations
var startTime time.Time
return func() (interface{}, bool, error) {
if cpt == iterations {
startTime = time.Now()
}
cpt--
// fake working time
time.Sleep(sleepTime)
v := &value{
doneIterations: iterations - cpt,
totalDuration: time.Since(startTime),
}
return v, cpt == 0, nil
}
}
func TestWaitSync(t *testing.T) {
testsCases := []struct {
name string
config *WaitSyncConfig
expValue interface{}
expErr error
}{
{
name: "With default timeout and interval",
config: &WaitSyncConfig{
Get: getMock(2, 0),
},
expValue: &value{
doneIterations: 2,
totalDuration: time.Second,
},
},
{
name: "With useless timeout",
config: &WaitSyncConfig{
Get: getMock(2, time.Second),
Timeout: 4 * time.Second,
},
expValue: &value{
doneIterations: 2,
totalDuration: 3 * time.Second,
},
},
{
name: "Should timeout",
config: &WaitSyncConfig{
Get: getMock(2, 2*time.Second),
Timeout: time.Second,
},
expValue: nil,
expErr: fmt.Errorf("timeout after 1s"),
},
{
name: "With interval",
config: &WaitSyncConfig{
Get: getMock(2, 0),
IntervalStrategy: LinearIntervalStrategy(2 * time.Second),
},
expValue: &value{
doneIterations: 2,
totalDuration: 2 * time.Second,
},
},
{
name: "With fibonacci interval",
config: &WaitSyncConfig{
Get: getMock(5, 0),
IntervalStrategy: FibonacciIntervalStrategy(time.Second, 1),
},
expValue: &value{
doneIterations: 5,
totalDuration: 7 * time.Second,
},
},
{
name: "Should timeout with interval",
config: &WaitSyncConfig{
Get: getMock(2, time.Second),
Timeout: 2 * time.Second,
IntervalStrategy: LinearIntervalStrategy(2 * time.Second),
},
expValue: nil,
expErr: fmt.Errorf("timeout after 2s"),
},
}
for _, c := range testsCases {
c := c // do not remove me
t.Run(c.name, func(t *testing.T) {
t.Parallel()
terminalValue, err := WaitSync(c.config)
testhelpers.Equals(t, c.expErr, err)
if c.expValue != nil {
exp := c.expValue.(*value)
acc := terminalValue.(*value)
testhelpers.Equals(t, exp.doneIterations, acc.doneIterations)
ok := exp.totalDuration > acc.totalDuration-flakiness && exp.totalDuration < acc.totalDuration+flakiness
testhelpers.Assert(t, ok, "totalDuration don't match the target: (acc: %v, exp: %v)", acc.totalDuration, exp.totalDuration)
}
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/auth/ 0000775 0000000 0000000 00000000000 14563666056 0025033 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/auth/access_key.go 0000664 0000000 0000000 00000000713 14563666056 0027474 0 ustar 00root root 0000000 0000000 package auth
import "net/http"
type AccessKeyOnly struct {
// auth config may contain an access key without being authenticated
AccessKey string
}
// NewNoAuth return an auth with no authentication method
func NewAccessKeyOnly(accessKey string) *AccessKeyOnly {
return &AccessKeyOnly{accessKey}
}
func (t *AccessKeyOnly) Headers() http.Header {
return http.Header{}
}
func (t *AccessKeyOnly) AnonymizedHeaders() http.Header {
return http.Header{}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/auth/auth.go 0000664 0000000 0000000 00000001320 14563666056 0026317 0 ustar 00root root 0000000 0000000 package auth
import "net/http"
// Auth implement methods required for authentication.
// Valid authentication are currently a token or no auth.
type Auth interface {
// Headers returns headers that must be add to the http request
Headers() http.Header
// AnonymizedHeaders returns an anonymised version of Headers()
// This method could be use for logging purpose.
AnonymizedHeaders() http.Header
}
type headerAnonymizer func(header http.Header) http.Header
var headerAnonymizers = []headerAnonymizer{
AnonymizeTokenHeaders,
AnonymizeJWTHeaders,
}
func AnonymizeHeaders(headers http.Header) http.Header {
for _, anonymizer := range headerAnonymizers {
headers = anonymizer(headers)
}
return headers
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/auth/jwt.go 0000664 0000000 0000000 00000002246 14563666056 0026172 0 ustar 00root root 0000000 0000000 package auth
import (
"net/http"
"strings"
)
// JWT is the session token used in browser.
type JWT struct {
Token string
}
// XSessionTokenHeader is Scaleway auth header for browser
const XSessionTokenHeader = "x-session-token" // #nosec G101
// NewJWT create a token authentication from a jwt
func NewJWT(token string) *JWT {
return &JWT{Token: token}
}
// Headers returns headers that must be added to the http request
func (j *JWT) Headers() http.Header {
headers := http.Header{}
headers.Set(XSessionTokenHeader, j.Token)
return headers
}
func AnonymizeJWTHeaders(headers http.Header) http.Header {
token := headers.Get(XSessionTokenHeader)
if token != "" {
headers.Set(XSessionTokenHeader, HideJWT(token))
}
return headers
}
// AnonymizedHeaders returns an anonymized version of Headers()
// This method could be used for logging purpose.
func (j *JWT) AnonymizedHeaders() http.Header {
return AnonymizeJWTHeaders(j.Headers())
}
func HideJWT(token string) string {
if len(token) == 0 {
return ""
}
// token should be (header).(payload).(signature)
lastDot := strings.LastIndex(token, ".")
if lastDot != -1 {
token = token[:lastDot]
}
return token
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/auth/no_auth.go 0000664 0000000 0000000 00000000460 14563666056 0027017 0 ustar 00root root 0000000 0000000 package auth
import "net/http"
type NoAuth struct {
}
// NewNoAuth return an auth with no authentication method
func NewNoAuth() *NoAuth {
return &NoAuth{}
}
func (t *NoAuth) Headers() http.Header {
return http.Header{}
}
func (t *NoAuth) AnonymizedHeaders() http.Header {
return http.Header{}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/auth/token.go 0000664 0000000 0000000 00000002422 14563666056 0026502 0 ustar 00root root 0000000 0000000 package auth
import "net/http"
// Token is the pair accessKey + secretKey.
// This type is public because it's an internal package.
type Token struct {
AccessKey string
SecretKey string
}
// XAuthTokenHeader is Scaleway standard auth header
const XAuthTokenHeader = "X-Auth-Token" // #nosec G101
// NewToken create a token authentication from an
// access key and a secret key
func NewToken(accessKey, secretKey string) *Token {
return &Token{AccessKey: accessKey, SecretKey: secretKey}
}
// Headers returns headers that must be add to the http request
func (t *Token) Headers() http.Header {
headers := http.Header{}
headers.Set(XAuthTokenHeader, t.SecretKey)
return headers
}
func AnonymizeTokenHeaders(headers http.Header) http.Header {
key := headers.Get(XAuthTokenHeader)
if key != "" {
headers.Set(XAuthTokenHeader, HideSecretKey(key))
}
return headers
}
// AnonymizedHeaders returns an anonymized version of Headers()
// This method could be use for logging purpose.
func (t *Token) AnonymizedHeaders() http.Header {
return AnonymizeTokenHeaders(t.Headers())
}
func HideSecretKey(k string) string {
switch {
case len(k) == 0:
return ""
case len(k) > 8:
return k[0:8] + "-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
default:
return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/auth/token_test.go 0000664 0000000 0000000 00000000540 14563666056 0027540 0 ustar 00root root 0000000 0000000 package auth
import (
"net/http"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
func TestToken_Headers(t *testing.T) {
const (
accessKey = "ACCESS_KEY"
secretKey = "SECRET_KEY"
)
auth := NewToken(accessKey, secretKey)
testhelpers.Equals(t, http.Header{
"X-Auth-Token": []string{secretKey},
}, auth.Headers())
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/e2e/ 0000775 0000000 0000000 00000000000 14563666056 0024545 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/e2e/errors_test.go 0000664 0000000 0000000 00000006243 14563666056 0027454 0 ustar 00root root 0000000 0000000 package e2e
import (
"testing"
"github.com/scaleway/scaleway-sdk-go/api/test/v1"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
"github.com/scaleway/scaleway-sdk-go/scw"
)
func TestStandardErrors(t *testing.T) {
client, _, _, err := newE2EClient(true)
testhelpers.AssertNoError(t, err)
t.Run("not found", func(t *testing.T) {
_, err = client.GetHuman(&test.GetHumanRequest{
HumanID: "b3ba839a-dcf2-4b0a-ac81-fc32370052a0",
})
testhelpers.Equals(t, &scw.ResourceNotFoundError{
Resource: "human",
ResourceID: "b3ba839a-dcf2-4b0a-ac81-fc32370052a0",
RawBody: []byte(`{"message":"resource is not found","resource":"human","resource_id":"b3ba839a-dcf2-4b0a-ac81-fc32370052a0","type":"not_found"}`),
}, err)
})
t.Run("invalid argument", func(t *testing.T) {
_, err = client.CreateHuman(&test.CreateHumanRequest{
AltitudeInMeter: -7000000,
})
testhelpers.Equals(t, &scw.InvalidArgumentsError{
Details: []scw.InvalidArgumentsErrorDetail{
{
ArgumentName: "altitude_in_meter",
Reason: "constraint",
HelpMessage: "lowest altitude on earth is -6371km",
},
},
RawBody: []byte(`{"details":[{"argument_name":"altitude_in_meter","help_message":"lowest altitude on earth is -6371km","reason":"constraint"}],"message":"invalid argument(s)","type":"invalid_arguments"}`),
}, err)
})
t.Run("quotas exceeded", func(t *testing.T) {
var humans []*test.Human
for i := 0; i < 10; i++ {
human, err := client.CreateHuman(&test.CreateHumanRequest{})
testhelpers.AssertNoError(t, err)
humans = append(humans, human)
}
_, err = client.CreateHuman(&test.CreateHumanRequest{})
testhelpers.Equals(t, &scw.QuotasExceededError{
Details: []scw.QuotasExceededErrorDetail{
{
Resource: "human",
Quota: 10,
Current: 10,
},
},
RawBody: []byte(`{"details":[{"current":10,"quota":10,"resource":"human"}],"message":"quota(s) exceeded for this resource","type":"quotas_exceeded"}`),
}, err)
for _, human := range humans {
_, err := client.DeleteHuman(&test.DeleteHumanRequest{HumanID: human.ID})
testhelpers.AssertNoError(t, err)
}
})
t.Run("transient state", func(t *testing.T) {
human, err := client.CreateHuman(&test.CreateHumanRequest{})
testhelpers.AssertNoError(t, err)
defer func() {
_, _ = client.DeleteHuman(&test.DeleteHumanRequest{HumanID: human.ID})
}()
_, err = client.RunHuman(&test.RunHumanRequest{HumanID: human.ID})
testhelpers.AssertNoError(t, err)
_, err = client.UpdateHuman(&test.UpdateHumanRequest{HumanID: human.ID})
testhelpers.Equals(t, &scw.TransientStateError{
Resource: "human",
ResourceID: human.ID,
CurrentState: "running",
RawBody: []byte(`{"current_state":"running","message":"resource is in a transient state","resource":"human","resource_id":"` + human.ID + `","type":"transient_state"}`),
}, err)
})
t.Run("out of stock", func(t *testing.T) {
_, err = client.CreateHuman(&test.CreateHumanRequest{
ShoeSize: 60,
})
testhelpers.Equals(t, &scw.OutOfStockError{
Resource: "ShoeSize60",
RawBody: []byte(`{"message":"resource is out of stock","resource":"ShoeSize60","type":"out_of_stock"}`),
}, err)
})
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/e2e/human_test.go 0000664 0000000 0000000 00000012050 14563666056 0027241 0 ustar 00root root 0000000 0000000 package e2e
import (
"testing"
"github.com/scaleway/scaleway-sdk-go/api/test/v1"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
"github.com/scaleway/scaleway-sdk-go/scw"
)
var (
defaultOrganizationID = "6170692e-7363-616c-6577-61792e636f6d" // hint: | xxd -ps -r
)
func newE2EClient(withAuthInClient bool) (*test.API, string, string, error) {
client, err := scw.NewClient(
scw.WithDefaultRegion(scw.RegionFrPar),
scw.WithDefaultOrganizationID(defaultOrganizationID),
scw.WithUserAgent("sdk-e2e-test"),
)
if err != nil {
return nil, "", "", err
}
testClient := test.NewAPI(client)
registerResponse, err := testClient.Register(&test.RegisterRequest{
Username: "sidi",
})
if err != nil {
return nil, "", "", err
}
if withAuthInClient {
client, err = scw.NewClient(
scw.WithDefaultRegion(scw.RegionFrPar),
scw.WithDefaultOrganizationID(defaultOrganizationID),
scw.WithAuth(registerResponse.AccessKey, registerResponse.SecretKey),
scw.WithUserAgent("sdk-e2e-test"),
)
testClient = test.NewAPI(client)
}
return testClient, registerResponse.AccessKey, registerResponse.SecretKey, err
}
func TestAuthInRequest(t *testing.T) {
client, accessKey, secretKey, err := newE2EClient(false)
testhelpers.AssertNoError(t, err)
requestWithAuth := scw.WithAuthRequest(accessKey, secretKey)
_, err = client.CreateHuman(&test.CreateHumanRequest{}, requestWithAuth)
testhelpers.AssertNoError(t, err)
}
func TestHuman(t *testing.T) {
client, _, _, err := newE2EClient(true)
testhelpers.AssertNoError(t, err)
// create
human, err := client.CreateHuman(&test.CreateHumanRequest{
Height: 170.5,
ShoeSize: 35.1,
AltitudeInMeter: -12,
AltitudeInMillimeter: -12050,
FingersCount: 21,
HairCount: 9223372036854775808,
IsHappy: true,
EyesColor: test.EyeColorsAmber,
OrganizationID: scw.StringPtr("b3ba839a-dcf2-4b0a-ac81-fc32370052a0"),
})
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, human.Height, 170.5)
testhelpers.Equals(t, human.ShoeSize, float32(35.1))
testhelpers.Equals(t, human.AltitudeInMeter, int32(-12))
testhelpers.Equals(t, human.AltitudeInMillimeter, int64(-12050))
testhelpers.Equals(t, human.FingersCount, uint32(21))
testhelpers.Equals(t, human.HairCount, uint64(9223372036854775808))
testhelpers.Equals(t, human.IsHappy, true)
testhelpers.Equals(t, human.EyesColor, test.EyeColorsAmber)
testhelpers.Equals(t, human.OrganizationID, "b3ba839a-dcf2-4b0a-ac81-fc32370052a0")
// single parameter update
human, err = client.UpdateHuman(&test.UpdateHumanRequest{
HumanID: human.ID,
IsHappy: scw.BoolPtr(false),
})
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, human.Height, 170.5)
testhelpers.Equals(t, human.ShoeSize, float32(35.1))
testhelpers.Equals(t, human.AltitudeInMeter, int32(-12))
testhelpers.Equals(t, human.AltitudeInMillimeter, int64(-12050))
testhelpers.Equals(t, human.FingersCount, uint32(21))
testhelpers.Equals(t, human.HairCount, uint64(9223372036854775808))
testhelpers.Equals(t, human.IsHappy, false)
testhelpers.Equals(t, human.EyesColor, test.EyeColorsAmber)
testhelpers.Equals(t, human.OrganizationID, "b3ba839a-dcf2-4b0a-ac81-fc32370052a0")
// update
human, err = client.UpdateHuman(&test.UpdateHumanRequest{
HumanID: human.ID,
Height: scw.Float64Ptr(155.666),
ShoeSize: scw.Float32Ptr(36.0),
AltitudeInMeter: scw.Int32Ptr(2147483647),
AltitudeInMillimeter: scw.Int64Ptr(2147483647285),
FingersCount: scw.Uint32Ptr(20),
HairCount: scw.Uint64Ptr(9223372036854775809),
IsHappy: scw.BoolPtr(true),
EyesColor: test.EyeColorsBlue,
})
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, human.Height, 155.666)
testhelpers.Equals(t, human.ShoeSize, float32(36.0))
testhelpers.Equals(t, human.AltitudeInMeter, int32(2147483647))
testhelpers.Equals(t, human.AltitudeInMillimeter, int64(2147483647285))
testhelpers.Equals(t, human.FingersCount, uint32(20))
testhelpers.Equals(t, human.HairCount, uint64(9223372036854775809))
testhelpers.Equals(t, human.IsHappy, true)
testhelpers.Equals(t, human.EyesColor, test.EyeColorsBlue)
testhelpers.Equals(t, human.OrganizationID, "b3ba839a-dcf2-4b0a-ac81-fc32370052a0")
// get
human, err = client.GetHuman(&test.GetHumanRequest{
HumanID: human.ID,
})
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, human.Height, 155.666)
testhelpers.Equals(t, human.ShoeSize, float32(36.0))
testhelpers.Equals(t, human.AltitudeInMeter, int32(2147483647))
testhelpers.Equals(t, human.AltitudeInMillimeter, int64(2147483647285))
testhelpers.Equals(t, human.FingersCount, uint32(20))
testhelpers.Equals(t, human.HairCount, uint64(9223372036854775809))
testhelpers.Equals(t, human.IsHappy, true)
testhelpers.Equals(t, human.EyesColor, test.EyeColorsBlue)
testhelpers.Equals(t, human.OrganizationID, "b3ba839a-dcf2-4b0a-ac81-fc32370052a0")
// delete
_, err = client.DeleteHuman(&test.DeleteHumanRequest{
HumanID: human.ID,
})
testhelpers.AssertNoError(t, err)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/errors/ 0000775 0000000 0000000 00000000000 14563666056 0025406 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/errors/error.go 0000664 0000000 0000000 00000001526 14563666056 0027072 0 ustar 00root root 0000000 0000000 package errors
import "fmt"
// Error is a base error that implement scw.SdkError
type Error struct {
Str string
Err error
}
// Error implement standard xerror.Wrapper interface
func (e *Error) Unwrap() error {
return e.Err
}
// Error implement standard error interface
func (e *Error) Error() string {
str := "scaleway-sdk-go: " + e.Str
if e.Err != nil {
str += ": " + e.Err.Error()
}
return str
}
// IsScwSdkError implement SdkError interface
func (e *Error) IsScwSdkError() {}
// New creates a new error with that same interface as fmt.Errorf
func New(format string, args ...interface{}) *Error {
return &Error{
Str: fmt.Sprintf(format, args...),
}
}
// Wrap an error with additional information
func Wrap(err error, format string, args ...interface{}) *Error {
return &Error{
Err: err,
Str: fmt.Sprintf(format, args...),
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/generic/ 0000775 0000000 0000000 00000000000 14563666056 0025506 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/generic/fields.go 0000664 0000000 0000000 00000000647 14563666056 0027312 0 ustar 00root root 0000000 0000000 package generic
import "reflect"
// HasField returns true if given struct has a field with given name
// Also allow a slice, it will use the underlying type
func HasField(i interface{}, fieldName string) bool {
value := reflect.Indirect(reflect.ValueOf(i))
typ := value.Type()
if value.Kind() == reflect.Slice {
typ = indirectType(typ.Elem())
}
_, fieldExists := typ.FieldByName(fieldName)
return fieldExists
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/generic/fields_test.go 0000664 0000000 0000000 00000001432 14563666056 0030342 0 ustar 00root root 0000000 0000000 package generic
import "testing"
func TestHasField(t *testing.T) {
tests := []struct {
name string
i interface{}
fieldName string
want bool
}{
{
"native type",
struct {
Zone string
}{},
"Zone",
true,
},
{
"ptr type",
struct {
Zone *string
}{},
"Zone",
true,
},
{
"invalid case",
struct {
Zone *string
}{},
"zone",
false,
},
{
"slice",
[]struct {
Zone string
}{},
"Zone",
true,
},
{
"slice invalid case",
[]struct {
Zone string
}{},
"zone",
false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := HasField(tt.i, tt.fieldName); got != tt.want {
t.Errorf("HasField() = %v, want %v", got, tt.want)
}
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/generic/ptr.go 0000664 0000000 0000000 00000000234 14563666056 0026641 0 ustar 00root root 0000000 0000000 package generic
import "reflect"
func indirectType(typ reflect.Type) reflect.Type {
if typ.Kind() == reflect.Ptr {
return typ.Elem()
}
return typ
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/generic/sort.go 0000664 0000000 0000000 00000001047 14563666056 0027026 0 ustar 00root root 0000000 0000000 package generic
import (
"reflect"
"sort"
)
// SortSliceByField sorts given slice of struct by passing the specified field to given compare function
// given slice must be a slice of Ptr
func SortSliceByField(list interface{}, field string, compare func(interface{}, interface{}) bool) {
listValue := reflect.ValueOf(list)
sort.SliceStable(list, func(i, j int) bool {
field1 := listValue.Index(i).Elem().FieldByName(field).Interface()
field2 := listValue.Index(j).Elem().FieldByName(field).Interface()
return compare(field1, field2)
})
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/generic/sort_test.go 0000664 0000000 0000000 00000001053 14563666056 0030062 0 ustar 00root root 0000000 0000000 package generic
import (
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
func Test_SortSliceByField(t *testing.T) {
type Elem struct {
Field string
}
elems := []*Elem{
{"2"},
{"1"},
{"3"},
}
SortSliceByField(elems, "Field", func(i interface{}, i2 interface{}) bool {
return i.(string) < i2.(string)
})
testhelpers.Assert(t, elems[0].Field == "1", "slice is not sorted")
testhelpers.Assert(t, elems[1].Field == "2", "slice is not sorted")
testhelpers.Assert(t, elems[2].Field == "3", "slice is not sorted")
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/marshaler/ 0000775 0000000 0000000 00000000000 14563666056 0026050 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/marshaler/duration.go 0000664 0000000 0000000 00000010102 14563666056 0030216 0 ustar 00root root 0000000 0000000 package marshaler
import (
"encoding/json"
"time"
)
// Duration implements a JSON Marshaler to encode a time.Duration in milliseconds.
type Duration int64
const milliSec = Duration(time.Millisecond)
// NewDuration converts a *time.Duration to a *Duration type.
func NewDuration(t *time.Duration) *Duration {
if t == nil {
return nil
}
d := Duration(t.Nanoseconds())
return &d
}
// Standard converts a *Duration to a *time.Duration type.
func (d *Duration) Standard() *time.Duration {
return (*time.Duration)(d)
}
// MarshalJSON encodes the Duration in milliseconds.
func (d Duration) MarshalJSON() ([]byte, error) {
return json.Marshal(int64(d / milliSec))
}
// UnmarshalJSON decodes milliseconds to Duration.
func (d *Duration) UnmarshalJSON(b []byte) error {
var tmp int64
err := json.Unmarshal(b, &tmp)
if err != nil {
return err
}
*d = Duration(tmp) * milliSec
return nil
}
// DurationSlice is a slice of *Duration
type DurationSlice []*Duration
// NewDurationSlice converts a []*time.Duration to a DurationSlice type.
func NewDurationSlice(t []*time.Duration) DurationSlice {
ds := make([]*Duration, len(t))
for i := range ds {
ds[i] = NewDuration(t[i])
}
return ds
}
// Standard converts a DurationSlice to a []*time.Duration type.
func (ds *DurationSlice) Standard() []*time.Duration {
t := make([]*time.Duration, len(*ds))
for i := range t {
t[i] = (*ds)[i].Standard()
}
return t
}
// Durationint32Map is a int32 map of *Duration
type Durationint32Map map[int32]*Duration
// NewDurationint32Map converts a map[int32]*time.Duration to a Durationint32Map type.
func NewDurationint32Map(t map[int32]*time.Duration) Durationint32Map {
dm := make(Durationint32Map, len(t))
for i := range t {
dm[i] = NewDuration(t[i])
}
return dm
}
// Standard converts a Durationint32Map to a map[int32]*time.Duration type.
func (dm *Durationint32Map) Standard() map[int32]*time.Duration {
t := make(map[int32]*time.Duration, len(*dm))
for key, value := range *dm {
t[key] = value.Standard()
}
return t
}
// LongDuration implements a JSON Marshaler to encode a time.Duration in days.
type LongDuration int64
const day = LongDuration(time.Hour) * 24
// NewLongDuration converts a *time.Duration to a *LongDuration type.
func NewLongDuration(t *time.Duration) *LongDuration {
if t == nil {
return nil
}
d := LongDuration(t.Nanoseconds())
return &d
}
// Standard converts a *LongDuration to a *time.Duration type.
func (d *LongDuration) Standard() *time.Duration {
return (*time.Duration)(d)
}
// MarshalJSON encodes the LongDuration in days.
func (d LongDuration) MarshalJSON() ([]byte, error) {
return json.Marshal(int64(d / day))
}
// UnmarshalJSON decodes days to LongDuration.
func (d *LongDuration) UnmarshalJSON(b []byte) error {
var tmp int64
err := json.Unmarshal(b, &tmp)
if err != nil {
return err
}
*d = LongDuration(tmp) * day
return nil
}
// LongDurationSlice is a slice of *LongDuration
type LongDurationSlice []*LongDuration
// NewLongDurationSlice converts a []*time.Duration to a LongDurationSlice type.
func NewLongDurationSlice(t []*time.Duration) LongDurationSlice {
ds := make([]*LongDuration, len(t))
for i := range ds {
ds[i] = NewLongDuration(t[i])
}
return ds
}
// Standard converts a LongDurationSlice to a []*time.Duration type.
func (ds *LongDurationSlice) Standard() []*time.Duration {
t := make([]*time.Duration, len(*ds))
for i := range t {
t[i] = (*ds)[i].Standard()
}
return t
}
// LongDurationint32Map is a int32 map of *LongDuration
type LongDurationint32Map map[int32]*LongDuration
// NewLongDurationint32Map converts a map[int32]*time.LongDuration to a LongDurationint32Map type.
func NewLongDurationint32Map(t map[int32]*time.Duration) LongDurationint32Map {
dm := make(LongDurationint32Map, len(t))
for i := range t {
dm[i] = NewLongDuration(t[i])
}
return dm
}
// Standard converts a LongDurationint32Map to a map[int32]*time.LongDuration type.
func (dm *LongDurationint32Map) Standard() map[int32]*time.Duration {
t := make(map[int32]*time.Duration, len(*dm))
for key, value := range *dm {
t[key] = value.Standard()
}
return t
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/parameter/ 0000775 0000000 0000000 00000000000 14563666056 0026052 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/parameter/query.go 0000664 0000000 0000000 00000002121 14563666056 0027542 0 ustar 00root root 0000000 0000000 package parameter
import (
"fmt"
"net"
"net/url"
"reflect"
"time"
"github.com/scaleway/scaleway-sdk-go/scw"
)
// AddToQuery add a key/value pair to an URL query
func AddToQuery(query url.Values, key string, value interface{}) {
elemValue := reflect.ValueOf(value)
if elemValue.Kind() == reflect.Invalid || elemValue.Kind() == reflect.Ptr && elemValue.IsNil() {
return
}
for elemValue.Kind() == reflect.Ptr {
elemValue = reflect.ValueOf(value).Elem()
}
elemType := elemValue.Type()
switch {
case elemType == reflect.TypeOf(net.IP{}):
query.Add(key, value.(*net.IP).String())
case elemType == reflect.TypeOf(net.IPNet{}):
query.Add(key, value.(*net.IPNet).String())
case elemType == reflect.TypeOf(scw.IPNet{}):
query.Add(key, value.(*scw.IPNet).String())
case elemType.Kind() == reflect.Slice:
for i := 0; i < elemValue.Len(); i++ {
query.Add(key, fmt.Sprint(elemValue.Index(i).Interface()))
}
case elemType == reflect.TypeOf(time.Time{}):
query.Add(key, value.(*time.Time).Format(time.RFC3339))
default:
query.Add(key, fmt.Sprint(elemValue.Interface()))
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/testhelpers/ 0000775 0000000 0000000 00000000000 14563666056 0026434 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/testhelpers/httprecorder/ 0000775 0000000 0000000 00000000000 14563666056 0031141 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/testhelpers/httprecorder/recorder.go 0000664 0000000 0000000 00000005510 14563666056 0033276 0 ustar 00root root 0000000 0000000 package httprecorder
import (
"fmt"
"net/http"
"os"
"strings"
"github.com/dnaeon/go-vcr/cassette"
"github.com/dnaeon/go-vcr/recorder"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/scw"
)
// IsUpdatingCassette returns true if we are updating cassettes.
func IsUpdatingCassette() bool {
return os.Getenv("SDK_UPDATE_CASSETTES") == "true"
}
// CreateRecordedScwClient creates a new scw.Client that records all HTTP requests in a cassette.
// This cassette is then replayed whenever tests are executed again. This means that once the
// requests are recorded in the cassette, no more real HTTP request must be made to run the tests.
//
// It is important to call add a `defer recorder.Stop()` so the given cassette files are correctly
// closed and saved after the requests.
//
// To update the cassette files, add `SDK_UPDATE_CASSETTES=true` to the environment variables.
// When updating cassettes, make sure your Scaleway credentials are set in your config or in the
// variables `SCW_ACCESS_KEY` and `SCW_SECRET_KEY`.
func CreateRecordedScwClient(cassetteName string) (*scw.Client, *recorder.Recorder, error) {
UpdateCassette := IsUpdatingCassette()
var activeProfile *scw.Profile
recorderMode := recorder.ModeReplaying
if UpdateCassette {
recorderMode = recorder.ModeRecording
config, err := scw.LoadConfig()
if err != nil {
return nil, nil, err
}
activeProfile, err = config.GetActiveProfile()
if err != nil {
return nil, nil, err
}
}
// Setup recorder and scw client
r, err := recorder.NewAsMode(fmt.Sprintf("testdata/%s", cassetteName), recorderMode, nil)
if err != nil {
return nil, nil, err
}
// Add a filter which removes Authorization headers from all requests:
r.AddFilter(func(i *cassette.Interaction) error {
delete(i.Request.Headers, "x-auth-token")
delete(i.Request.Headers, "X-Auth-Token")
if UpdateCassette {
secretKey := *activeProfile.SecretKey
if i != nil && strings.Contains(fmt.Sprintf("%v", *i), secretKey) {
panic(errors.New("found secret key in cassette"))
}
}
return nil
})
// Create new http.Client where transport is the recorder
httpClient := &http.Client{Transport: r}
var client *scw.Client
if UpdateCassette {
// When updating the recoreded test requests, we need the access key and secret key.
client, err = scw.NewClient(
scw.WithHTTPClient(httpClient),
scw.WithProfile(activeProfile),
scw.WithEnv(),
scw.WithDefaultRegion(scw.RegionFrPar),
scw.WithDefaultZone(scw.ZoneFrPar1),
)
if err != nil {
return nil, nil, err
}
} else {
// No need for auth when using cassette
client, err = scw.NewClient(
scw.WithHTTPClient(httpClient),
scw.WithDefaultRegion(scw.RegionFrPar),
scw.WithDefaultZone(scw.ZoneFrPar1),
)
if err != nil {
return nil, nil, err
}
}
return client, r, nil
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/internal/testhelpers/test_helpers.go 0000664 0000000 0000000 00000001743 14563666056 0031471 0 ustar 00root root 0000000 0000000 package testhelpers
import (
"fmt"
"path/filepath"
"reflect"
"runtime"
"testing"
)
// Assert fails the test if the condition is false.
func Assert(tb testing.TB, condition bool, msg string, v ...interface{}) {
if !condition {
_, file, line, _ := runtime.Caller(1)
fmt.Printf("\033[31m%s:%d: "+msg+"\033[39m\n\n", append([]interface{}{filepath.Base(file), line}, v...)...)
tb.FailNow()
}
}
// AssertNoError fails the test if an err is not nil.
func AssertNoError(tb testing.TB, err error) {
if err != nil {
_, file, line, _ := runtime.Caller(1)
fmt.Printf("\033[31m%s:%d: unexpected error: %s\033[39m\n\n", filepath.Base(file), line, err.Error())
tb.FailNow()
}
}
// Equals fails the test if exp is not equal to act.
func Equals(tb testing.TB, exp, act interface{}) {
if !reflect.DeepEqual(exp, act) {
_, file, line, _ := runtime.Caller(1)
fmt.Printf("\033[31m%s:%d:\n\n\texp: %#v\n\n\tgot: %#v\033[39m\n\n", filepath.Base(file), line, exp, act)
tb.FailNow()
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/logger/ 0000775 0000000 0000000 00000000000 14563666056 0023535 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/logger/default_logger.go 0000664 0000000 0000000 00000006370 14563666056 0027055 0 ustar 00root root 0000000 0000000 package logger
import (
"fmt"
"io"
"io/ioutil"
"log"
"os"
"strconv"
)
var DefaultLogger = newLogger(os.Stderr, LogLevelWarning)
var logger Logger = DefaultLogger
// loggerT is the default logger used by scaleway-sdk-go.
type loggerT struct {
m [4]*log.Logger
v LogLevel
}
// Init create a new default logger.
// Not mutex-protected, should be called before any scaleway-sdk-go functions.
func (g *loggerT) Init(w io.Writer, level LogLevel) {
g.m = newLogger(w, level).m
g.v = level
}
// Debugf logs to the DEBUG log. Arguments are handled in the manner of fmt.Printf.
func Debugf(format string, args ...interface{}) { logger.Debugf(format, args...) }
func (g *loggerT) Debugf(format string, args ...interface{}) {
g.m[LogLevelDebug].Printf(format, args...)
}
// Infof logs to the INFO log. Arguments are handled in the manner of fmt.Printf.
func Infof(format string, args ...interface{}) { logger.Infof(format, args...) }
func (g *loggerT) Infof(format string, args ...interface{}) {
g.m[LogLevelInfo].Printf(format, args...)
}
// Warningf logs to the WARNING log. Arguments are handled in the manner of fmt.Printf.
func Warningf(format string, args ...interface{}) { logger.Warningf(format, args...) }
func (g *loggerT) Warningf(format string, args ...interface{}) {
g.m[LogLevelWarning].Printf(format, args...)
}
// Errorf logs to the ERROR log. Arguments are handled in the manner of fmt.Printf.
func Errorf(format string, args ...interface{}) { logger.Errorf(format, args...) }
func (g *loggerT) Errorf(format string, args ...interface{}) {
g.m[LogLevelError].Printf(format, args...)
}
// ShouldLog reports whether verbosity level l is at least the requested verbose level.
func ShouldLog(level LogLevel) bool { return logger.ShouldLog(level) }
func (g *loggerT) ShouldLog(level LogLevel) bool {
return level >= g.v
}
func isEnabled(envKey string) bool {
env, exist := os.LookupEnv(envKey)
if !exist {
return false
}
value, err := strconv.ParseBool(env)
if err != nil {
fmt.Fprintf(os.Stderr, "ERROR: environment variable %s has invalid boolean value\n", envKey)
}
return value
}
// newLogger creates a logger to be used as default logger.
// All logs are written to w.
func newLogger(w io.Writer, level LogLevel) *loggerT {
errorW := ioutil.Discard
warningW := ioutil.Discard
infoW := ioutil.Discard
debugW := ioutil.Discard
if isEnabled(DebugEnv) {
level = LogLevelDebug
}
switch level {
case LogLevelDebug:
debugW = w
case LogLevelInfo:
infoW = w
case LogLevelWarning:
warningW = w
case LogLevelError:
errorW = w
}
// Error logs will be written to errorW, warningW, infoW and debugW.
// Warning logs will be written to warningW, infoW and debugW.
// Info logs will be written to infoW and debugW.
// Debug logs will be written to debugW.
var m [4]*log.Logger
m[LogLevelError] = log.New(io.MultiWriter(debugW, infoW, warningW, errorW),
severityName[LogLevelError]+": ", log.LstdFlags)
m[LogLevelWarning] = log.New(io.MultiWriter(debugW, infoW, warningW),
severityName[LogLevelWarning]+": ", log.LstdFlags)
m[LogLevelInfo] = log.New(io.MultiWriter(debugW, infoW),
severityName[LogLevelInfo]+": ", log.LstdFlags)
m[LogLevelDebug] = log.New(debugW,
severityName[LogLevelDebug]+": ", log.LstdFlags)
return &loggerT{m: m, v: level}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/logger/logger.go 0000664 0000000 0000000 00000003164 14563666056 0025347 0 ustar 00root root 0000000 0000000 package logger
import "os"
type LogLevel int
const DebugEnv = "SCW_DEBUG"
const (
// LogLevelDebug indicates Debug severity.
LogLevelDebug LogLevel = iota
// LogLevelInfo indicates Info severity.
LogLevelInfo
// LogLevelWarning indicates Warning severity.
LogLevelWarning
// LogLevelError indicates Error severity.
LogLevelError
)
// severityName contains the string representation of each severity.
var severityName = []string{
LogLevelDebug: "DEBUG",
LogLevelInfo: "INFO",
LogLevelWarning: "WARNING",
LogLevelError: "ERROR",
}
// Logger does underlying logging work for scaleway-sdk-go.
type Logger interface {
// Debugf logs to DEBUG log. Arguments are handled in the manner of fmt.Printf.
Debugf(format string, args ...interface{})
// Infof logs to INFO log. Arguments are handled in the manner of fmt.Printf.
Infof(format string, args ...interface{})
// Warningf logs to WARNING log. Arguments are handled in the manner of fmt.Printf.
Warningf(format string, args ...interface{})
// Errorf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.
Errorf(format string, args ...interface{})
// ShouldLog reports whether verbosity level l is at least the requested verbose level.
ShouldLog(level LogLevel) bool
}
// SetLogger sets logger that is used in by the SDK.
// Not mutex-protected, should be called before any scaleway-sdk-go functions.
func SetLogger(l Logger) {
logger = l
}
// EnableDebugMode enable LogLevelDebug on the default logger.
// If a custom logger was provided with SetLogger this method has no effect.
func EnableDebugMode() {
DefaultLogger.Init(os.Stderr, LogLevelDebug)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/logger/logger_test.go 0000664 0000000 0000000 00000003412 14563666056 0026402 0 ustar 00root root 0000000 0000000 package logger
import (
"bytes"
"os"
"strings"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
var (
expectedErrorf = "ERROR: cd"
expectedWarningf = "WARNING: ij"
expectedInfof = "INFO: op"
expectedDebugf = "DEBUG: uv"
)
func TestDebug(t *testing.T) {
buf := &bytes.Buffer{}
logThings(newLogger(buf, LogLevelDebug))
testThings(t, []string{
expectedErrorf,
expectedWarningf,
expectedInfof,
expectedDebugf,
}, buf.String())
}
func TestInfo(t *testing.T) {
buf := &bytes.Buffer{}
logThings(newLogger(buf, LogLevelInfo))
testThings(t, []string{
expectedErrorf,
expectedWarningf,
expectedInfof,
}, buf.String())
}
func TestWarning(t *testing.T) {
buf := &bytes.Buffer{}
logThings(newLogger(buf, LogLevelWarning))
testThings(t, []string{
expectedErrorf,
expectedWarningf,
}, buf.String())
}
func TestError(t *testing.T) {
buf := &bytes.Buffer{}
logThings(newLogger(buf, LogLevelError))
testThings(t, []string{
expectedErrorf,
}, buf.String())
}
func TestEnableDebugMode(t *testing.T) {
_defaultLogger := DefaultLogger
DefaultLogger = newLogger(os.Stderr, LogLevelWarning)
EnableDebugMode()
testhelpers.Equals(t, true, DefaultLogger.ShouldLog(LogLevelDebug))
DefaultLogger = _defaultLogger
}
func testThings(t *testing.T, expectedEvents []string, actualOutput string) {
lines := strings.Split(actualOutput, "\n")
for i, line := range lines[:len(lines)-1] { // last line is always empty
tmp := strings.Split(line, " ")
actualMessage := strings.Join(append([]string{tmp[0]}, tmp[3:]...), " ") // date and hour is not kept
testhelpers.Equals(t, expectedEvents[i], actualMessage)
}
}
func logThings(log Logger) {
log.Errorf("c%s", "d")
log.Warningf("i%s", "j")
log.Infof("o%s", "p")
log.Debugf("u%s", "v")
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/namegenerator/ 0000775 0000000 0000000 00000000000 14563666056 0025105 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/namegenerator/name_generator.go 0000664 0000000 0000000 00000143072 14563666056 0030431 0 ustar 00root root 0000000 0000000 // Source: github.com/docker/docker/pkg/namesgenerator
package namegenerator
import (
"math/rand"
"strings"
"time"
)
var r *rand.Rand
func init() {
source := rand.NewSource(time.Now().UnixNano())
r = rand.New(source)
}
var (
left = [...]string{
"admiring",
"adoring",
"affectionate",
"agitated",
"amazing",
"angry",
"awesome",
"beautiful",
"blissful",
"bold",
"boring",
"brave",
"busy",
"charming",
"clever",
"cocky",
"cool",
"compassionate",
"competent",
"condescending",
"confident",
"cranky",
"crazy",
"dazzling",
"determined",
"distracted",
"dreamy",
"eager",
"ecstatic",
"elastic",
"elated",
"elegant",
"eloquent",
"epic",
"exciting",
"fervent",
"festive",
"flamboyant",
"focused",
"friendly",
"frosty",
"funny",
"gallant",
"gifted",
"goofy",
"gracious",
"great",
"happy",
"hardcore",
"heuristic",
"hopeful",
"hungry",
"infallible",
"inspiring",
"interesting",
"intelligent",
"jolly",
"jovial",
"keen",
"kind",
"laughing",
"loving",
"lucid",
"magical",
"mystifying",
"modest",
"musing",
"naughty",
"nervous",
"nice",
"nifty",
"nostalgic",
"objective",
"optimistic",
"peaceful",
"pedantic",
"pensive",
"practical",
"priceless",
"quirky",
"quizzical",
"recursing",
"relaxed",
"reverent",
"romantic",
"sad",
"serene",
"sharp",
"silly",
"sleepy",
"stoic",
"strange",
"stupefied",
"suspicious",
"sweet",
"tender",
"thirsty",
"trusting",
"unruffled",
"upbeat",
"vibrant",
"vigilant",
"vigorous",
"wizardly",
"wonderful",
"xenodochial",
"youthful",
"zealous",
"zen",
}
// Docker, starting from 0.7.x, generates names from notable scientists and hackers.
// Please, for any amazing man that you add to the list, consider adding an equally amazing woman to it, and vice versa.
right = [...]string{
// Muhammad ibn Jābir al-Ḥarrānī al-Battānī was a founding father of astronomy. https://en.wikipedia.org/wiki/Mu%E1%B8%A5ammad_ibn_J%C4%81bir_al-%E1%B8%A4arr%C4%81n%C4%AB_al-Batt%C4%81n%C4%AB
"albattani",
// Frances E. Allen, became the first female IBM Fellow in 1989. In 2006, she became the first female recipient of the ACM's Turing Award. https://en.wikipedia.org/wiki/Frances_E._Allen
"allen",
// June Almeida - Scottish virologist who took the first pictures of the rubella virus - https://en.wikipedia.org/wiki/June_Almeida
"almeida",
// Kathleen Antonelli, American computer programmer and one of the six original programmers of the ENIAC - https://en.wikipedia.org/wiki/Kathleen_Antonelli
"antonelli",
// Maria Gaetana Agnesi - Italian mathematician, philosopher, theologian and humanitarian. She was the first woman to write a mathematics handbook and the first woman appointed as a Mathematics Professor at a University. https://en.wikipedia.org/wiki/Maria_Gaetana_Agnesi
"agnesi",
// Archimedes was a physicist, engineer and mathematician who invented too many things to list them here. https://en.wikipedia.org/wiki/Archimedes
"archimedes",
// Maria Ardinghelli - Italian translator, mathematician and physicist - https://en.wikipedia.org/wiki/Maria_Ardinghelli
"ardinghelli",
// Aryabhata - Ancient Indian mathematician-astronomer during 476-550 CE https://en.wikipedia.org/wiki/Aryabhata
"aryabhata",
// Wanda Austin - Wanda Austin is the President and CEO of The Aerospace Corporation, a leading architect for the US security space programs. https://en.wikipedia.org/wiki/Wanda_Austin
"austin",
// Charles Babbage invented the concept of a programmable computer. https://en.wikipedia.org/wiki/Charles_Babbage.
"babbage",
// Stefan Banach - Polish mathematician, was one of the founders of modern functional analysis. https://en.wikipedia.org/wiki/Stefan_Banach
"banach",
// Buckaroo Banzai and his mentor Dr. Hikita perfectd the "oscillation overthruster", a device that allows one to pass through solid matter. - https://en.wikipedia.org/wiki/The_Adventures_of_Buckaroo_Banzai_Across_the_8th_Dimension
"banzai",
// John Bardeen co-invented the transistor - https://en.wikipedia.org/wiki/John_Bardeen
"bardeen",
// Jean Bartik, born Betty Jean Jennings, was one of the original programmers for the ENIAC computer. https://en.wikipedia.org/wiki/Jean_Bartik
"bartik",
// Laura Bassi, the world's first female professor https://en.wikipedia.org/wiki/Laura_Bassi
"bassi",
// Hugh Beaver, British engineer, founder of the Guinness Book of World Records https://en.wikipedia.org/wiki/Hugh_Beaver
"beaver",
// Alexander Graham Bell - an eminent Scottish-born scientist, inventor, engineer and innovator who is credited with inventing the first practical telephone - https://en.wikipedia.org/wiki/Alexander_Graham_Bell
"bell",
// Karl Friedrich Benz - a German automobile engineer. Inventor of the first practical motorcar. https://en.wikipedia.org/wiki/Karl_Benz
"benz",
// Homi J Bhabha - was an Indian nuclear physicist, founding director, and professor of physics at the Tata Institute of Fundamental Research. Colloquially known as "father of Indian nuclear programme"- https://en.wikipedia.org/wiki/Homi_J._Bhabha
"bhabha",
// Bhaskara II - Ancient Indian mathematician-astronomer whose work on calculus predates Newton and Leibniz by over half a millennium - https://en.wikipedia.org/wiki/Bh%C4%81skara_II#Calculus
"bhaskara",
// Sue Black - British computer scientist and campaigner. She has been instrumental in saving Bletchley Park, the site of World War II codebreaking - https://en.wikipedia.org/wiki/Sue_Black_(computer_scientist)
"black",
// Elizabeth Helen Blackburn - Australian-American Nobel laureate; best known for co-discovering telomerase. https://en.wikipedia.org/wiki/Elizabeth_Blackburn
"blackburn",
// Elizabeth Blackwell - American doctor and first American woman to receive a medical degree - https://en.wikipedia.org/wiki/Elizabeth_Blackwell
"blackwell",
// Niels Bohr is the father of quantum theory. https://en.wikipedia.org/wiki/Niels_Bohr.
"bohr",
// Kathleen Booth, she's credited with writing the first assembly language. https://en.wikipedia.org/wiki/Kathleen_Booth
"booth",
// Anita Borg - Anita Borg was the founding director of the Institute for Women and Technology (IWT). https://en.wikipedia.org/wiki/Anita_Borg
"borg",
// Satyendra Nath Bose - He provided the foundation for Bose–Einstein statistics and the theory of the Bose–Einstein condensate. - https://en.wikipedia.org/wiki/Satyendra_Nath_Bose
"bose",
// Katherine Louise Bouman is an imaging scientist and Assistant Professor of Computer Science at the California Institute of Technology. She researches computational methods for imaging, and developed an algorithm that made possible the picture first visualization of a black hole using the Event Horizon Telescope. - https://en.wikipedia.org/wiki/Katie_Bouman
"bouman",
// Evelyn Boyd Granville - She was one of the first African-American woman to receive a Ph.D. in mathematics; she earned it in 1949 from Yale University. https://en.wikipedia.org/wiki/Evelyn_Boyd_Granville
"boyd",
// Brahmagupta - Ancient Indian mathematician during 598-670 CE who gave rules to compute with zero - https://en.wikipedia.org/wiki/Brahmagupta#Zero
"brahmagupta",
// Walter Houser Brattain co-invented the transistor - https://en.wikipedia.org/wiki/Walter_Houser_Brattain
"brattain",
// Emmett Brown invented time travel. https://en.wikipedia.org/wiki/Emmett_Brown (thanks Brian Goff)
"brown",
// Linda Brown Buck - American biologist and Nobel laureate best known for her genetic and molecular analyses of the mechanisms of smell. https://en.wikipedia.org/wiki/Linda_B._Buck
"buck",
// Dame Susan Jocelyn Bell Burnell - Northern Irish astrophysicist who discovered radio pulsars and was the first to analyse them. https://en.wikipedia.org/wiki/Jocelyn_Bell_Burnell
"burnell",
// Annie Jump Cannon - pioneering female astronomer who classified hundreds of thousands of stars and created the system we use to understand stars today. https://en.wikipedia.org/wiki/Annie_Jump_Cannon
"cannon",
// Rachel Carson - American marine biologist and conservationist, her book Silent Spring and other writings are credited with advancing the global environmental movement. https://en.wikipedia.org/wiki/Rachel_Carson
"carson",
// Dame Mary Lucy Cartwright - British mathematician who was one of the first to study what is now known as chaos theory. Also known for Cartwright's theorem which finds applications in signal processing. https://en.wikipedia.org/wiki/Mary_Cartwright
"cartwright",
// Vinton Gray Cerf - American Internet pioneer, recognised as one of "the fathers of the Internet". With Robert Elliot Kahn, he designed TCP and IP, the primary data communication protocols of the Internet and other computer networks. https://en.wikipedia.org/wiki/Vint_Cerf
"cerf",
// Subrahmanyan Chandrasekhar - Astrophysicist known for his mathematical theory on different stages and evolution in structures of the stars. He has won nobel prize for physics - https://en.wikipedia.org/wiki/Subrahmanyan_Chandrasekhar
"chandrasekhar",
// Sergey Alexeyevich Chaplygin (Russian: Серге́й Алексе́евич Чаплы́гин; April 5, 1869 – October 8, 1942) was a Russian and Soviet physicist, mathematician, and mechanical engineer. He is known for mathematical formulas such as Chaplygin's equation and for a hypothetical substance in cosmology called Chaplygin gas, named after him. https://en.wikipedia.org/wiki/Sergey_Chaplygin
"chaplygin",
// Émilie du Châtelet - French natural philosopher, mathematician, physicist, and author during the early 1730s, known for her translation of and commentary on Isaac Newton's book Principia containing basic laws of physics. https://en.wikipedia.org/wiki/%C3%89milie_du_Ch%C3%A2telet
"chatelet",
// Asima Chatterjee was an Indian organic chemist noted for her research on vinca alkaloids, development of drugs for treatment of epilepsy and malaria - https://en.wikipedia.org/wiki/Asima_Chatterjee
"chatterjee",
// Pafnuty Chebyshev - Russian mathematician. He is known fo his works on probability, statistics, mechanics, analytical geometry and number theory https://en.wikipedia.org/wiki/Pafnuty_Chebyshev
"chebyshev",
// Bram Cohen - American computer programmer and author of the BitTorrent peer-to-peer protocol. https://en.wikipedia.org/wiki/Bram_Cohen
"cohen",
// David Lee Chaum - American computer scientist and cryptographer. Known for his seminal contributions in the field of anonymous communication. https://en.wikipedia.org/wiki/David_Chaum
"chaum",
// Joan Clarke - Bletchley Park code breaker during the Second World War who pioneered techniques that remained top secret for decades. Also an accomplished numismatist https://en.wikipedia.org/wiki/Joan_Clarke
"clarke",
// Jane Colden - American botanist widely considered the first female American botanist - https://en.wikipedia.org/wiki/Jane_Colden
"colden",
// Gerty Theresa Cori - American biochemist who became the third woman—and first American woman—to win a Nobel Prize in science, and the first woman to be awarded the Nobel Prize in Physiology or Medicine. Cori was born in Prague. https://en.wikipedia.org/wiki/Gerty_Cori
"cori",
// Seymour Roger Cray was an American electrical engineer and supercomputer architect who designed a series of computers that were the fastest in the world for decades. https://en.wikipedia.org/wiki/Seymour_Cray
"cray",
// This entry reflects a husband and wife team who worked together:
// Joan Curran was a Welsh scientist who developed radar and invented chaff, a radar countermeasure. https://en.wikipedia.org/wiki/Joan_Curran
// Samuel Curran was an Irish physicist who worked alongside his wife during WWII and invented the proximity fuse. https://en.wikipedia.org/wiki/Samuel_Curran
"curran",
// Marie Curie discovered radioactivity. https://en.wikipedia.org/wiki/Marie_Curie.
"curie",
// Charles Darwin established the principles of natural evolution. https://en.wikipedia.org/wiki/Charles_Darwin.
"darwin",
// Leonardo Da Vinci invented too many things to list here. https://en.wikipedia.org/wiki/Leonardo_da_Vinci.
"davinci",
// A. K. (Alexander Keewatin) Dewdney, Canadian mathematician, computer scientist, author and filmmaker. Contributor to Scientific American's "Computer Recreations" from 1984 to 1991. Author of Core War (program), The Planiverse, The Armchair Universe, The Magic Machine, The New Turing Omnibus, and more. https://en.wikipedia.org/wiki/Alexander_Dewdney
"dewdney",
// Satish Dhawan - Indian mathematician and aerospace engineer, known for leading the successful and indigenous development of the Indian space programme. https://en.wikipedia.org/wiki/Satish_Dhawan
"dhawan",
// Bailey Whitfield Diffie - American cryptographer and one of the pioneers of public-key cryptography. https://en.wikipedia.org/wiki/Whitfield_Diffie
"diffie",
// Edsger Wybe Dijkstra was a Dutch computer scientist and mathematical scientist. https://en.wikipedia.org/wiki/Edsger_W._Dijkstra.
"dijkstra",
// Paul Adrien Maurice Dirac - English theoretical physicist who made fundamental contributions to the early development of both quantum mechanics and quantum electrodynamics. https://en.wikipedia.org/wiki/Paul_Dirac
"dirac",
// Agnes Meyer Driscoll - American cryptanalyst during World Wars I and II who successfully cryptanalysed a number of Japanese ciphers. She was also the co-developer of one of the cipher machines of the US Navy, the CM. https://en.wikipedia.org/wiki/Agnes_Meyer_Driscoll
"driscoll",
// Donna Dubinsky - played an integral role in the development of personal digital assistants (PDAs) serving as CEO of Palm, Inc. and co-founding Handspring. https://en.wikipedia.org/wiki/Donna_Dubinsky
"dubinsky",
// Annie Easley - She was a leading member of the team which developed software for the Centaur rocket stage and one of the first African-Americans in her field. https://en.wikipedia.org/wiki/Annie_Easley
"easley",
// Thomas Alva Edison, prolific inventor https://en.wikipedia.org/wiki/Thomas_Edison
"edison",
// Albert Einstein invented the general theory of relativity. https://en.wikipedia.org/wiki/Albert_Einstein
"einstein",
// Alexandra Asanovna Elbakyan (Russian: Алекса́ндра Аса́новна Элбакя́н) is a Kazakhstani graduate student, computer programmer, internet pirate in hiding, and the creator of the site Sci-Hub. Nature has listed her in 2016 in the top ten people that mattered in science, and Ars Technica has compared her to Aaron Swartz. - https://en.wikipedia.org/wiki/Alexandra_Elbakyan
"elbakyan",
// Taher A. ElGamal - Egyptian cryptographer best known for the ElGamal discrete log cryptosystem and the ElGamal digital signature scheme. https://en.wikipedia.org/wiki/Taher_Elgamal
"elgamal",
// Gertrude Elion - American biochemist, pharmacologist and the 1988 recipient of the Nobel Prize in Medicine - https://en.wikipedia.org/wiki/Gertrude_Elion
"elion",
// James Henry Ellis - British engineer and cryptographer employed by the GCHQ. Best known for conceiving for the first time, the idea of public-key cryptography. https://en.wikipedia.org/wiki/James_H._Ellis
"ellis",
// Douglas Engelbart gave the mother of all demos: https://en.wikipedia.org/wiki/Douglas_Engelbart
"engelbart",
// Euclid invented geometry. https://en.wikipedia.org/wiki/Euclid
"euclid",
// Leonhard Euler invented large parts of modern mathematics. https://de.wikipedia.org/wiki/Leonhard_Euler
"euler",
// Michael Faraday - British scientist who contributed to the study of electromagnetism and electrochemistry. https://en.wikipedia.org/wiki/Michael_Faraday
"faraday",
// Horst Feistel - German-born American cryptographer who was one of the earliest non-government researchers to study the design and theory of block ciphers. Co-developer of DES and Lucifer. Feistel networks, a symmetric structure used in the construction of block ciphers are named after him. https://en.wikipedia.org/wiki/Horst_Feistel
"feistel",
// Pierre de Fermat pioneered several aspects of modern mathematics. https://en.wikipedia.org/wiki/Pierre_de_Fermat
"fermat",
// Enrico Fermi invented the first nuclear reactor. https://en.wikipedia.org/wiki/Enrico_Fermi.
"fermi",
// Richard Feynman was a key contributor to quantum mechanics and particle physics. https://en.wikipedia.org/wiki/Richard_Feynman
"feynman",
// Benjamin Franklin is famous for his experiments in electricity and the invention of the lightning rod.
"franklin",
// Yuri Alekseyevich Gagarin - Soviet pilot and cosmonaut, best known as the first human to journey into outer space. https://en.wikipedia.org/wiki/Yuri_Gagarin
"gagarin",
// Galileo was a founding father of modern astronomy, and faced politics and obscurantism to establish scientific truth. https://en.wikipedia.org/wiki/Galileo_Galilei
"galileo",
// Évariste Galois - French mathematician whose work laid the foundations of Galois theory and group theory, two major branches of abstract algebra, and the subfield of Galois connections, all while still in his late teens. https://en.wikipedia.org/wiki/%C3%89variste_Galois
"galois",
// Kadambini Ganguly - Indian physician, known for being the first South Asian female physician, trained in western medicine, to graduate in South Asia. https://en.wikipedia.org/wiki/Kadambini_Ganguly
"ganguly",
// William Henry "Bill" Gates III is an American business magnate, philanthropist, investor, computer programmer, and inventor. https://en.wikipedia.org/wiki/Bill_Gates
"gates",
// Johann Carl Friedrich Gauss - German mathematician who made significant contributions to many fields, including number theory, algebra, statistics, analysis, differential geometry, geodesy, geophysics, mechanics, electrostatics, magnetic fields, astronomy, matrix theory, and optics. https://en.wikipedia.org/wiki/Carl_Friedrich_Gauss
"gauss",
// Marie-Sophie Germain - French mathematician, physicist and philosopher. Known for her work on elasticity theory, number theory and philosophy. https://en.wikipedia.org/wiki/Sophie_Germain
"germain",
// Adele Goldberg, was one of the designers and developers of the Smalltalk language. https://en.wikipedia.org/wiki/Adele_Goldberg_(computer_scientist)
"goldberg",
// Adele Goldstine, born Adele Katz, wrote the complete technical description for the first electronic digital computer, ENIAC. https://en.wikipedia.org/wiki/Adele_Goldstine
"goldstine",
// Shafi Goldwasser is a computer scientist known for creating theoretical foundations of modern cryptography. Winner of 2012 ACM Turing Award. https://en.wikipedia.org/wiki/Shafi_Goldwasser
"goldwasser",
// James Golick, all around gangster.
"golick",
// Jane Goodall - British primatologist, ethologist, and anthropologist who is considered to be the world's foremost expert on chimpanzees - https://en.wikipedia.org/wiki/Jane_Goodall
"goodall",
// Stephen Jay Gould was was an American paleontologist, evolutionary biologist, and historian of science. He is most famous for the theory of punctuated equilibrium - https://en.wikipedia.org/wiki/Stephen_Jay_Gould
"gould",
// Carolyn Widney Greider - American molecular biologist and joint winner of the 2009 Nobel Prize for Physiology or Medicine for the discovery of telomerase. https://en.wikipedia.org/wiki/Carol_W._Greider
"greider",
// Alexander Grothendieck - German-born French mathematician who became a leading figure in the creation of modern algebraic geometry. https://en.wikipedia.org/wiki/Alexander_Grothendieck
"grothendieck",
// Lois Haibt - American computer scientist, part of the team at IBM that developed FORTRAN - https://en.wikipedia.org/wiki/Lois_Haibt
"haibt",
// Margaret Hamilton - Director of the Software Engineering Division of the MIT Instrumentation Laboratory, which developed on-board flight software for the Apollo space program. https://en.wikipedia.org/wiki/Margaret_Hamilton_(scientist)
"hamilton",
// Caroline Harriet Haslett - English electrical engineer, electricity industry administrator and champion of women's rights. Co-author of British Standard 1363 that specifies AC power plugs and sockets used across the United Kingdom (which is widely considered as one of the safest designs). https://en.wikipedia.org/wiki/Caroline_Haslett
"haslett",
// Stephen Hawking pioneered the field of cosmology by combining general relativity and quantum mechanics. https://en.wikipedia.org/wiki/Stephen_Hawking
"hawking",
// Martin Edward Hellman - American cryptologist, best known for his invention of public-key cryptography in co-operation with Whitfield Diffie and Ralph Merkle. https://en.wikipedia.org/wiki/Martin_Hellman
"hellman",
// Werner Heisenberg was a founding father of quantum mechanics. https://en.wikipedia.org/wiki/Werner_Heisenberg
"heisenberg",
// Grete Hermann was a German philosopher noted for her philosophical work on the foundations of quantum mechanics. https://en.wikipedia.org/wiki/Grete_Hermann
"hermann",
// Caroline Lucretia Herschel - German astronomer and discoverer of several comets. https://en.wikipedia.org/wiki/Caroline_Herschel
"herschel",
// Heinrich Rudolf Hertz - German physicist who first conclusively proved the existence of the electromagnetic waves. https://en.wikipedia.org/wiki/Heinrich_Hertz
"hertz",
// Jaroslav Heyrovský was the inventor of the polarographic method, father of the electroanalytical method, and recipient of the Nobel Prize in 1959. His main field of work was polarography. https://en.wikipedia.org/wiki/Jaroslav_Heyrovsk%C3%BD
"heyrovsky",
// Dorothy Hodgkin was a British biochemist, credited with the development of protein crystallography. She was awarded the Nobel Prize in Chemistry in 1964. https://en.wikipedia.org/wiki/Dorothy_Hodgkin
"hodgkin",
// Douglas R. Hofstadter is an American professor of cognitive science and author of the Pulitzer Prize and American Book Award-winning work Goedel, Escher, Bach: An Eternal Golden Braid in 1979. A mind-bending work which coined Hofstadter's Law: "It always takes longer than you expect, even when you take into account Hofstadter's Law." https://en.wikipedia.org/wiki/Douglas_Hofstadter
"hofstadter",
// Erna Schneider Hoover revolutionized modern communication by inventing a computerized telephone switching method. https://en.wikipedia.org/wiki/Erna_Schneider_Hoover
"hoover",
// Grace Hopper developed the first compiler for a computer programming language and is credited with popularizing the term "debugging" for fixing computer glitches. https://en.wikipedia.org/wiki/Grace_Hopper
"hopper",
// Frances Hugle, she was an American scientist, engineer, and inventor who contributed to the understanding of semiconductors, integrated circuitry, and the unique electrical principles of microscopic materials. https://en.wikipedia.org/wiki/Frances_Hugle
"hugle",
// Hypatia - Greek Alexandrine Neoplatonist philosopher in Egypt who was one of the earliest mothers of mathematics - https://en.wikipedia.org/wiki/Hypatia
"hypatia",
// Teruko Ishizaka - Japanese scientist and immunologist who co-discovered the antibody class Immunoglobulin E. https://en.wikipedia.org/wiki/Teruko_Ishizaka
"ishizaka",
// Mary Jackson, American mathematician and aerospace engineer who earned the highest title within NASA's engineering department - https://en.wikipedia.org/wiki/Mary_Jackson_(engineer)
"jackson",
// Yeong-Sil Jang was a Korean scientist and astronomer during the Joseon Dynasty; he invented the first metal printing press and water gauge. https://en.wikipedia.org/wiki/Jang_Yeong-sil
"jang",
// Betty Jennings - one of the original programmers of the ENIAC. https://en.wikipedia.org/wiki/ENIAC - https://en.wikipedia.org/wiki/Jean_Bartik
"jennings",
// Mary Lou Jepsen, was the founder and chief technology officer of One Laptop Per Child (OLPC), and the founder of Pixel Qi. https://en.wikipedia.org/wiki/Mary_Lou_Jepsen
"jepsen",
// Katherine Coleman Goble Johnson - American physicist and mathematician contributed to the NASA. https://en.wikipedia.org/wiki/Katherine_Johnson
"johnson",
// Irène Joliot-Curie - French scientist who was awarded the Nobel Prize for Chemistry in 1935. Daughter of Marie and Pierre Curie. https://en.wikipedia.org/wiki/Ir%C3%A8ne_Joliot-Curie
"joliot",
// Karen Spärck Jones came up with the concept of inverse document frequency, which is used in most search engines today. https://en.wikipedia.org/wiki/Karen_Sp%C3%A4rck_Jones
"jones",
// A. P. J. Abdul Kalam - is an Indian scientist aka Missile Man of India for his work on the development of ballistic missile and launch vehicle technology - https://en.wikipedia.org/wiki/A._P._J._Abdul_Kalam
"kalam",
// Sergey Petrovich Kapitsa (Russian: Серге́й Петро́вич Капи́ца; 14 February 1928 – 14 August 2012) was a Russian physicist and demographer. He was best known as host of the popular and long-running Russian scientific TV show, Evident, but Incredible. His father was the Nobel laureate Soviet-era physicist Pyotr Kapitsa, and his brother was the geographer and Antarctic explorer Andrey Kapitsa. - https://en.wikipedia.org/wiki/Sergey_Kapitsa
"kapitsa",
// Susan Kare, created the icons and many of the interface elements for the original Apple Macintosh in the 1980s, and was an original employee of NeXT, working as the Creative Director. https://en.wikipedia.org/wiki/Susan_Kare
"kare",
// Mstislav Keldysh - a Soviet scientist in the field of mathematics and mechanics, academician of the USSR Academy of Sciences (1946), President of the USSR Academy of Sciences (1961–1975), three times Hero of Socialist Labor (1956, 1961, 1971), fellow of the Royal Society of Edinburgh (1968). https://en.wikipedia.org/wiki/Mstislav_Keldysh
"keldysh",
// Mary Kenneth Keller, Sister Mary Kenneth Keller became the first American woman to earn a PhD in Computer Science in 1965. https://en.wikipedia.org/wiki/Mary_Kenneth_Keller
"keller",
// Johannes Kepler, German astronomer known for his three laws of planetary motion - https://en.wikipedia.org/wiki/Johannes_Kepler
"kepler",
// Omar Khayyam - Persian mathematician, astronomer and poet. Known for his work on the classification and solution of cubic equations, for his contribution to the understanding of Euclid's fifth postulate and for computing the length of a year very accurately. https://en.wikipedia.org/wiki/Omar_Khayyam
"khayyam",
// Har Gobind Khorana - Indian-American biochemist who shared the 1968 Nobel Prize for Physiology - https://en.wikipedia.org/wiki/Har_Gobind_Khorana
"khorana",
// Jack Kilby invented silicone integrated circuits and gave Silicon Valley its name. - https://en.wikipedia.org/wiki/Jack_Kilby
"kilby",
// Maria Kirch - German astronomer and first woman to discover a comet - https://en.wikipedia.org/wiki/Maria_Margarethe_Kirch
"kirch",
// Donald Knuth - American computer scientist, author of "The Art of Computer Programming" and creator of the TeX typesetting system. https://en.wikipedia.org/wiki/Donald_Knuth
"knuth",
// Sophie Kowalevski - Russian mathematician responsible for important original contributions to analysis, differential equations and mechanics - https://en.wikipedia.org/wiki/Sofia_Kovalevskaya
"kowalevski",
// Marie-Jeanne de Lalande - French astronomer, mathematician and cataloguer of stars - https://en.wikipedia.org/wiki/Marie-Jeanne_de_Lalande
"lalande",
// Hedy Lamarr - Actress and inventor. The principles of her work are now incorporated into modern Wi-Fi, CDMA and Bluetooth technology. https://en.wikipedia.org/wiki/Hedy_Lamarr
"lamarr",
// Leslie B. Lamport - American computer scientist. Lamport is best known for his seminal work in distributed systems and was the winner of the 2013 Turing Award. https://en.wikipedia.org/wiki/Leslie_Lamport
"lamport",
// Mary Leakey - British paleoanthropologist who discovered the first fossilized Proconsul skull - https://en.wikipedia.org/wiki/Mary_Leakey
"leakey",
// Henrietta Swan Leavitt - she was an American astronomer who discovered the relation between the luminosity and the period of Cepheid variable stars. https://en.wikipedia.org/wiki/Henrietta_Swan_Leavitt
"leavitt",
// Esther Miriam Zimmer Lederberg - American microbiologist and a pioneer of bacterial genetics. https://en.wikipedia.org/wiki/Esther_Lederberg
"lederberg",
// Inge Lehmann - Danish seismologist and geophysicist. Known for discovering in 1936 that the Earth has a solid inner core inside a molten outer core. https://en.wikipedia.org/wiki/Inge_Lehmann
"lehmann",
// Daniel Lewin - Mathematician, Akamai co-founder, soldier, 9/11 victim-- Developed optimization techniques for routing traffic on the internet. Died attempting to stop the 9-11 hijackers. https://en.wikipedia.org/wiki/Daniel_Lewin
"lewin",
// Ruth Lichterman - one of the original programmers of the ENIAC. https://en.wikipedia.org/wiki/ENIAC - https://en.wikipedia.org/wiki/Ruth_Teitelbaum
"lichterman",
// Barbara Liskov - co-developed the Liskov substitution principle. Liskov was also the winner of the Turing Prize in 2008. - https://en.wikipedia.org/wiki/Barbara_Liskov
"liskov",
// Ada Lovelace invented the first algorithm. https://en.wikipedia.org/wiki/Ada_Lovelace (thanks James Turnbull)
"lovelace",
// Auguste and Louis Lumière - the first filmmakers in history - https://en.wikipedia.org/wiki/Auguste_and_Louis_Lumi%C3%A8re
"lumiere",
// Mahavira - Ancient Indian mathematician during 9th century AD who discovered basic algebraic identities - https://en.wikipedia.org/wiki/Mah%C4%81v%C4%ABra_(mathematician)
"mahavira",
// Lynn Margulis (b. Lynn Petra Alexander) - an American evolutionary theorist and biologist, science author, educator, and popularizer, and was the primary modern proponent for the significance of symbiosis in evolution. - https://en.wikipedia.org/wiki/Lynn_Margulis
"margulis",
// Yukihiro Matsumoto - Japanese computer scientist and software programmer best known as the chief designer of the Ruby programming language. https://en.wikipedia.org/wiki/Yukihiro_Matsumoto
"matsumoto",
// James Clerk Maxwell - Scottish physicist, best known for his formulation of electromagnetic theory. https://en.wikipedia.org/wiki/James_Clerk_Maxwell
"maxwell",
// Maria Mayer - American theoretical physicist and Nobel laureate in Physics for proposing the nuclear shell model of the atomic nucleus - https://en.wikipedia.org/wiki/Maria_Mayer
"mayer",
// John McCarthy invented LISP: https://en.wikipedia.org/wiki/John_McCarthy_(computer_scientist)
"mccarthy",
// Barbara McClintock - a distinguished American cytogeneticist, 1983 Nobel Laureate in Physiology or Medicine for discovering transposons. https://en.wikipedia.org/wiki/Barbara_McClintock
"mcclintock",
// Anne Laura Dorinthea McLaren - British developmental biologist whose work helped lead to human in-vitro fertilisation. https://en.wikipedia.org/wiki/Anne_McLaren
"mclaren",
// Malcolm McLean invented the modern shipping container: https://en.wikipedia.org/wiki/Malcom_McLean
"mclean",
// Kay McNulty - one of the original programmers of the ENIAC. https://en.wikipedia.org/wiki/ENIAC - https://en.wikipedia.org/wiki/Kathleen_Antonelli
"mcnulty",
// Gregor Johann Mendel - Czech scientist and founder of genetics. https://en.wikipedia.org/wiki/Gregor_Mendel
"mendel",
// Dmitri Mendeleev - a chemist and inventor. He formulated the Periodic Law, created a farsighted version of the periodic table of elements, and used it to correct the properties of some already discovered elements and also to predict the properties of eight elements yet to be discovered. https://en.wikipedia.org/wiki/Dmitri_Mendeleev
"mendeleev",
// Lise Meitner - Austrian/Swedish physicist who was involved in the discovery of nuclear fission. The element meitnerium is named after her - https://en.wikipedia.org/wiki/Lise_Meitner
"meitner",
// Carla Meninsky, was the game designer and programmer for Atari 2600 games Dodge 'Em and Warlords. https://en.wikipedia.org/wiki/Carla_Meninsky
"meninsky",
// Ralph C. Merkle - American computer scientist, known for devising Merkle's puzzles - one of the very first schemes for public-key cryptography. Also, inventor of Merkle trees and co-inventor of the Merkle-Damgård construction for building collision-resistant cryptographic hash functions and the Merkle-Hellman knapsack cryptosystem. https://en.wikipedia.org/wiki/Ralph_Merkle
"merkle",
// Johanna Mestorf - German prehistoric archaeologist and first female museum director in Germany - https://en.wikipedia.org/wiki/Johanna_Mestorf
"mestorf",
// Marvin Minsky - Pioneer in Artificial Intelligence, co-founder of the MIT's AI Lab, won the Turing Award in 1969. https://en.wikipedia.org/wiki/Marvin_Minsky
"minsky",
// Maryam Mirzakhani - an Iranian mathematician and the first woman to win the Fields Medal. https://en.wikipedia.org/wiki/Maryam_Mirzakhani
"mirzakhani",
// Gordon Earle Moore - American engineer, Silicon Valley founding father, author of Moore's law. https://en.wikipedia.org/wiki/Gordon_Moore
"moore",
// Samuel Morse - contributed to the invention of a single-wire telegraph system based on European telegraphs and was a co-developer of the Morse code - https://en.wikipedia.org/wiki/Samuel_Morse
"morse",
// Ian Murdock - founder of the Debian project - https://en.wikipedia.org/wiki/Ian_Murdock
"murdock",
// May-Britt Moser - Nobel prize winner neuroscientist who contributed to the discovery of grid cells in the brain. https://en.wikipedia.org/wiki/May-Britt_Moser
"moser",
// John Napier of Merchiston - Scottish landowner known as an astronomer, mathematician and physicist. Best known for his discovery of logarithms. https://en.wikipedia.org/wiki/John_Napier
"napier",
// John Forbes Nash, Jr. - American mathematician who made fundamental contributions to game theory, differential geometry, and the study of partial differential equations. https://en.wikipedia.org/wiki/John_Forbes_Nash_Jr.
"nash",
// John von Neumann - todays computer architectures are based on the von Neumann architecture. https://en.wikipedia.org/wiki/Von_Neumann_architecture
"neumann",
// Isaac Newton invented classic mechanics and modern optics. https://en.wikipedia.org/wiki/Isaac_Newton
"newton",
// Xavier Niel - ;) https://en.wikipedia.org/wiki/Xavier_Niel
"niel",
// Florence Nightingale, more prominently known as a nurse, was also the first female member of the Royal Statistical Society and a pioneer in statistical graphics https://en.wikipedia.org/wiki/Florence_Nightingale#Statistics_and_sanitary_reform
"nightingale",
// Alfred Nobel - a Swedish chemist, engineer, innovator, and armaments manufacturer (inventor of dynamite) - https://en.wikipedia.org/wiki/Alfred_Nobel
"nobel",
// Emmy Noether, German mathematician. Noether's Theorem is named after her. https://en.wikipedia.org/wiki/Emmy_Noether
"noether",
// Poppy Northcutt. Poppy Northcutt was the first woman to work as part of NASA’s Mission Control. http://www.businessinsider.com/poppy-northcutt-helped-apollo-astronauts-2014-12?op=1
"northcutt",
// Robert Noyce invented silicone integrated circuits and gave Silicon Valley its name. - https://en.wikipedia.org/wiki/Robert_Noyce
"noyce",
// Panini - Ancient Indian linguist and grammarian from 4th century CE who worked on the world's first formal system - https://en.wikipedia.org/wiki/P%C4%81%E1%B9%87ini#Comparison_with_modern_formal_systems
"panini",
// Ambroise Pare invented modern surgery. https://en.wikipedia.org/wiki/Ambroise_Par%C3%A9
"pare",
// Blaise Pascal, French mathematician, physicist, and inventor - https://en.wikipedia.org/wiki/Blaise_Pascal
"pascal",
// Louis Pasteur discovered vaccination, fermentation and pasteurization. https://en.wikipedia.org/wiki/Louis_Pasteur.
"pasteur",
// Cecilia Payne-Gaposchkin was an astronomer and astrophysicist who, in 1925, proposed in her Ph.D. thesis an explanation for the composition of stars in terms of the relative abundances of hydrogen and helium. https://en.wikipedia.org/wiki/Cecilia_Payne-Gaposchkin
"payne",
// Radia Perlman is a software designer and network engineer and most famous for her invention of the spanning-tree protocol (STP). https://en.wikipedia.org/wiki/Radia_Perlman
"perlman",
// Rob Pike was a key contributor to Unix, Plan 9, the X graphic system, utf-8, and the Go programming language. https://en.wikipedia.org/wiki/Rob_Pike
"pike",
// Henri Poincaré made fundamental contributions in several fields of mathematics. https://en.wikipedia.org/wiki/Henri_Poincar%C3%A9
"poincare",
// Laura Poitras is a director and producer whose work, made possible by open source crypto tools, advances the causes of truth and freedom of information by reporting disclosures by whistleblowers such as Edward Snowden. https://en.wikipedia.org/wiki/Laura_Poitras
"poitras",
// Tat’yana Avenirovna Proskuriakova (Russian: Татья́на Авени́ровна Проскуряко́ва) (January 23 [O.S. January 10] 1909 – August 30, 1985) was a Russian-American Mayanist scholar and archaeologist who contributed significantly to the deciphering of Maya hieroglyphs, the writing system of the pre-Columbian Maya civilization of Mesoamerica. https://en.wikipedia.org/wiki/Tatiana_Proskouriakoff
"proskuriakova",
// Claudius Ptolemy - a Greco-Egyptian writer of Alexandria, known as a mathematician, astronomer, geographer, astrologer, and poet of a single epigram in the Greek Anthology - https://en.wikipedia.org/wiki/Ptolemy
"ptolemy",
// C. V. Raman - Indian physicist who won the Nobel Prize in 1930 for proposing the Raman effect. - https://en.wikipedia.org/wiki/C._V._Raman
"raman",
// Srinivasa Ramanujan - Indian mathematician and autodidact who made extraordinary contributions to mathematical analysis, number theory, infinite series, and continued fractions. - https://en.wikipedia.org/wiki/Srinivasa_Ramanujan
"ramanujan",
// Sally Kristen Ride was an American physicist and astronaut. She was the first American woman in space, and the youngest American astronaut. https://en.wikipedia.org/wiki/Sally_Ride
"ride",
// Rita Levi-Montalcini - Won Nobel Prize in Physiology or Medicine jointly with colleague Stanley Cohen for the discovery of nerve growth factor (https://en.wikipedia.org/wiki/Rita_Levi-Montalcini)
"montalcini",
// Dennis Ritchie - co-creator of UNIX and the C programming language. - https://en.wikipedia.org/wiki/Dennis_Ritchie
"ritchie",
// Ida Rhodes - American pioneer in computer programming, designed the first computer used for Social Security. https://en.wikipedia.org/wiki/Ida_Rhodes
"rhodes",
// Julia Hall Bowman Robinson - American mathematician renowned for her contributions to the fields of computability theory and computational complexity theory. https://en.wikipedia.org/wiki/Julia_Robinson
"robinson",
// Wilhelm Conrad Röntgen - German physicist who was awarded the first Nobel Prize in Physics in 1901 for the discovery of X-rays (Röntgen rays). https://en.wikipedia.org/wiki/Wilhelm_R%C3%B6ntgen
"roentgen",
// Rosalind Franklin - British biophysicist and X-ray crystallographer whose research was critical to the understanding of DNA - https://en.wikipedia.org/wiki/Rosalind_Franklin
"rosalind",
// Vera Rubin - American astronomer who pioneered work on galaxy rotation rates. https://en.wikipedia.org/wiki/Vera_Rubin
"rubin",
// Meghnad Saha - Indian astrophysicist best known for his development of the Saha equation, used to describe chemical and physical conditions in stars - https://en.wikipedia.org/wiki/Meghnad_Saha
"saha",
// Jean E. Sammet developed FORMAC, the first widely used computer language for symbolic manipulation of mathematical formulas. https://en.wikipedia.org/wiki/Jean_E._Sammet
"sammet",
// Mildred Sanderson - American mathematician best known for Sanderson's theorem concerning modular invariants. https://en.wikipedia.org/wiki/Mildred_Sanderson
"sanderson",
// Satoshi Nakamoto is the name used by the unknown person or group of people who developed bitcoin, authored the bitcoin white paper, and created and deployed bitcoin's original reference implementation. https://en.wikipedia.org/wiki/Satoshi_Nakamoto
"satoshi",
// Adi Shamir - Israeli cryptographer whose numerous inventions and contributions to cryptography include the Ferge Fiat Shamir identification scheme, the Rivest Shamir Adleman (RSA) public-key cryptosystem, the Shamir's secret sharing scheme, the breaking of the Merkle-Hellman cryptosystem, the TWINKLE and TWIRL factoring devices and the discovery of differential cryptanalysis (with Eli Biham). https://en.wikipedia.org/wiki/Adi_Shamir
"shamir",
// Claude Shannon - The father of information theory and founder of digital circuit design theory. (https://en.wikipedia.org/wiki/Claude_Shannon)
"shannon",
// Carol Shaw - Originally an Atari employee, Carol Shaw is said to be the first female video game designer. https://en.wikipedia.org/wiki/Carol_Shaw_(video_game_designer)
"shaw",
// Dame Stephanie "Steve" Shirley - Founded a software company in 1962 employing women working from home. https://en.wikipedia.org/wiki/Steve_Shirley
"shirley",
// William Shockley co-invented the transistor - https://en.wikipedia.org/wiki/William_Shockley
"shockley",
// Lina Solomonovna Stern (or Shtern; Russian: Лина Соломоновна Штерн; 26 August 1878 – 7 March 1968) was a Soviet biochemist, physiologist and humanist whose medical discoveries saved thousands of lives at the fronts of World War II. She is best known for her pioneering work on blood–brain barrier, which she described as hemato-encephalic barrier in 1921. https://en.wikipedia.org/wiki/Lina_Stern
"shtern",
// Françoise Barré-Sinoussi - French virologist and Nobel Prize Laureate in Physiology or Medicine; her work was fundamental in identifying HIV as the cause of AIDS. https://en.wikipedia.org/wiki/Fran%C3%A7oise_Barr%C3%A9-Sinoussi
"sinoussi",
// Betty Snyder - one of the original programmers of the ENIAC. https://en.wikipedia.org/wiki/ENIAC - https://en.wikipedia.org/wiki/Betty_Holberton
"snyder",
// Cynthia Solomon - Pioneer in the fields of artificial intelligence, computer science and educational computing. Known for creation of Logo, an educational programming language. https://en.wikipedia.org/wiki/Cynthia_Solomon
"solomon",
// Frances Spence - one of the original programmers of the ENIAC. https://en.wikipedia.org/wiki/ENIAC - https://en.wikipedia.org/wiki/Frances_Spence
"spence",
// Richard Matthew Stallman - the founder of the Free Software movement, the GNU project, the Free Software Foundation, and the League for Programming Freedom. He also invented the concept of copyleft to protect the ideals of this movement, and enshrined this concept in the widely-used GPL (General Public License) for software. https://en.wikiquote.org/wiki/Richard_Stallman
"stallman",
// Michael Stonebraker is a database research pioneer and architect of Ingres, Postgres, VoltDB and SciDB. Winner of 2014 ACM Turing Award. https://en.wikipedia.org/wiki/Michael_Stonebraker
"stonebraker",
// Ivan Edward Sutherland - American computer scientist and Internet pioneer, widely regarded as the father of computer graphics. https://en.wikipedia.org/wiki/Ivan_Sutherland
"sutherland",
// Janese Swanson (with others) developed the first of the Carmen Sandiego games. She went on to found Girl Tech. https://en.wikipedia.org/wiki/Janese_Swanson
"swanson",
// Aaron Swartz was influential in creating RSS, Markdown, Creative Commons, Reddit, and much of the internet as we know it today. He was devoted to freedom of information on the web. https://en.wikiquote.org/wiki/Aaron_Swartz
"swartz",
// Bertha Swirles was a theoretical physicist who made a number of contributions to early quantum theory. https://en.wikipedia.org/wiki/Bertha_Swirles
"swirles",
// Helen Brooke Taussig - American cardiologist and founder of the field of paediatric cardiology. https://en.wikipedia.org/wiki/Helen_B._Taussig
"taussig",
// Valentina Tereshkova is a Russian engineer, cosmonaut and politician. She was the first woman to fly to space in 1963. In 2013, at the age of 76, she offered to go on a one-way mission to Mars. https://en.wikipedia.org/wiki/Valentina_Tereshkova
"tereshkova",
// Nikola Tesla invented the AC electric system and every gadget ever used by a James Bond villain. https://en.wikipedia.org/wiki/Nikola_Tesla
"tesla",
// Marie Tharp - American geologist and oceanic cartographer who co-created the first scientific map of the Atlantic Ocean floor. Her work led to the acceptance of the theories of plate tectonics and continental drift. https://en.wikipedia.org/wiki/Marie_Tharp
"tharp",
// Ken Thompson - co-creator of UNIX and the C programming language - https://en.wikipedia.org/wiki/Ken_Thompson
"thompson",
// Linus Torvalds invented Linux and Git. https://en.wikipedia.org/wiki/Linus_Torvalds
"torvalds",
// Youyou Tu - Chinese pharmaceutical chemist and educator known for discovering artemisinin and dihydroartemisinin, used to treat malaria, which has saved millions of lives. Joint winner of the 2015 Nobel Prize in Physiology or Medicine. https://en.wikipedia.org/wiki/Tu_Youyou
"tu",
// Alan Turing was a founding father of computer science. https://en.wikipedia.org/wiki/Alan_Turing.
"turing",
// Varahamihira - Ancient Indian mathematician who discovered trigonometric formulae during 505-587 CE - https://en.wikipedia.org/wiki/Var%C4%81hamihira#Contributions
"varahamihira",
// Dorothy Vaughan was a NASA mathematician and computer programmer on the SCOUT launch vehicle program that put America's first satellites into space - https://en.wikipedia.org/wiki/Dorothy_Vaughan
"vaughan",
// Sir Mokshagundam Visvesvaraya - is a notable Indian engineer. He is a recipient of the Indian Republic's highest honour, the Bharat Ratna, in 1955. On his birthday, 15 September is celebrated as Engineer's Day in India in his memory - https://en.wikipedia.org/wiki/Visvesvaraya
"visvesvaraya",
// Christiane Nüsslein-Volhard - German biologist, won Nobel Prize in Physiology or Medicine in 1995 for research on the genetic control of embryonic development. https://en.wikipedia.org/wiki/Christiane_N%C3%BCsslein-Volhard
"volhard",
// Cédric Villani - French mathematician, won Fields Medal, Fermat Prize and Poincaré Price for his work in differential geometry and statistical mechanics. https://en.wikipedia.org/wiki/C%C3%A9dric_Villani
"villani",
// Marlyn Wescoff - one of the original programmers of the ENIAC. https://en.wikipedia.org/wiki/ENIAC - https://en.wikipedia.org/wiki/Marlyn_Meltzer
"wescoff",
// Sylvia B. Wilbur - British computer scientist who helped develop the ARPANET, was one of the first to exchange email in the UK and a leading researcher in computer-supported collaborative work. https://en.wikipedia.org/wiki/Sylvia_Wilbur
"wilbur",
// Andrew Wiles - Notable British mathematician who proved the enigmatic Fermat's Last Theorem - https://en.wikipedia.org/wiki/Andrew_Wiles
"wiles",
// Roberta Williams, did pioneering work in graphical adventure games for personal computers, particularly the King's Quest series. https://en.wikipedia.org/wiki/Roberta_Williams
"williams",
// Malcolm John Williamson - British mathematician and cryptographer employed by the GCHQ. Developed in 1974 what is now known as Diffie-Hellman key exchange (Diffie and Hellman first published the scheme in 1976). https://en.wikipedia.org/wiki/Malcolm_J._Williamson
"williamson",
// Sophie Wilson designed the first Acorn Micro-Computer and the instruction set for ARM processors. https://en.wikipedia.org/wiki/Sophie_Wilson
"wilson",
// Jeannette Wing - co-developed the Liskov substitution principle. - https://en.wikipedia.org/wiki/Jeannette_Wing
"wing",
// Steve Wozniak invented the Apple I and Apple II. https://en.wikipedia.org/wiki/Steve_Wozniak
"wozniak",
// The Wright brothers, Orville and Wilbur - credited with inventing and building the world's first successful airplane and making the first controlled, powered and sustained heavier-than-air human flight - https://en.wikipedia.org/wiki/Wright_brothers
"wright",
// Chien-Shiung Wu - Chinese-American experimental physicist who made significant contributions to nuclear physics. https://en.wikipedia.org/wiki/Chien-Shiung_Wu
"wu",
// Rosalyn Sussman Yalow - Rosalyn Sussman Yalow was an American medical physicist, and a co-winner of the 1977 Nobel Prize in Physiology or Medicine for development of the radioimmunoassay technique. https://en.wikipedia.org/wiki/Rosalyn_Sussman_Yalow
"yalow",
// Ada Yonath - an Israeli crystallographer, the first woman from the Middle East to win a Nobel prize in the sciences. https://en.wikipedia.org/wiki/Ada_Yonath
"yonath",
// Nikolay Yegorovich Zhukovsky (Russian: Никола́й Его́рович Жуко́вский, January 17 1847 – March 17, 1921) was a Russian scientist, mathematician and engineer, and a founding father of modern aero- and hydrodynamics. Whereas contemporary scientists scoffed at the idea of human flight, Zhukovsky was the first to undertake the study of airflow. He is often called the Father of Russian Aviation. https://en.wikipedia.org/wiki/Nikolay_Yegorovich_Zhukovsky
"zhukovsky",
}
)
// GetRandomName generates a random name from the list of adjectives and surnames in this package
// formatted as "scw-adjective-surname". For example 'scw-focused-turing'.
func GetRandomName(prefixes ...string) string {
begin:
parts := append(prefixes, left[r.Intn(len(left))], right[r.Intn(len(right))])
name := strings.Join(parts, "-")
if strings.Contains(name, "boring-wozniak") /* Steve Wozniak is not boring */ {
goto begin
}
return name
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/namegenerator/name_generator_test.go 0000664 0000000 0000000 00000002163 14563666056 0031463 0 ustar 00root root 0000000 0000000 // Source: github.com/docker/docker/pkg/namesgenerator
package namegenerator
import (
"strings"
"testing"
)
func TestNameFormat(t *testing.T) {
name := GetRandomName()
if strings.Count(name, "-") != 1 {
t.Fatalf("Generated name does not contain exactly 1 hyphen")
}
if strings.ContainsAny(name, "0123456789") {
t.Fatalf("Generated name contains numbers!")
}
}
func TestNameFormatWithPrefix(t *testing.T) {
name := GetRandomName("scw")
if strings.Count(name, "-") != 2 {
t.Fatalf("Generated name does not contain exactly 2 hyphens")
}
if !strings.HasPrefix(name, "scw-") {
t.Fatalf("Generated name must begin with \"tf-scw-\"")
}
if strings.ContainsAny(name, "0123456789") {
t.Fatalf("Generated name contains numbers!")
}
}
func TestNameFormatWithPrefixes(t *testing.T) {
name := GetRandomName("tf", "scw")
if strings.Count(name, "-") != 3 {
t.Fatalf("Generated name does not contain exactly 3 hyphens")
}
if !strings.HasPrefix(name, "tf-scw-") {
t.Fatalf("Generated name must begin with \"tf-scw-\"")
}
if strings.ContainsAny(name, "0123456789") {
t.Fatalf("Generated name contains numbers!")
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scripts/ 0000775 0000000 0000000 00000000000 14563666056 0023745 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scripts/README.md 0000664 0000000 0000000 00000000635 14563666056 0025230 0 ustar 00root root 0000000 0000000 # Scaleway GO SDK - Scripts
This directory contains useful scripts to work on scaleway-go-sdk.
### check_for_tokens.sh \*\*
Checks that no token are present in cassette file
```
Usage: ./script/check_for_tokens.sh
```
### release.sh \*\*
This script will trigger the release process.
For more information on the release process you can refer to ./release/release.js file
```
Usage: ./script/release.sh
```
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scripts/check_for_tokens.sh 0000775 0000000 0000000 00000000371 14563666056 0027613 0 ustar 00root root 0000000 0000000 #!/bin/bash
files=$(find . -type f -print | grep testdata);
for file in $files
do
echo "checking $file";
if grep -i --quiet "x-auth-token" $file
then
echo "found x-auth-token in file $file";
exit 1;
fi
done
exit 0;
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scripts/lint.sh 0000775 0000000 0000000 00000003031 14563666056 0025247 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
##
# Colorize output
##
function color() {
case $1 in
yellow) echo -e -n "\033[33m" ;;
green) echo -e -n "\033[32m" ;;
red) echo -e -n "\033[0;31m" ;;
esac
echo "$2"
echo -e -n "\033[0m"
}
##
# Print Usage
##
function usage() {
color yellow "Usage:"
echo " $SCRIPT_DIR [OPTIONS]"
echo ""
color yellow "Options:"
color green " -w, --write"
echo -e "\tFix found issues (if it's supported by the linter)."
color green " --list"
echo -e "\tList current linters configuration."
color green " -h, --help"
echo -e "\tDisplay this help."
echo ""
exit "$1";
}
OPT_CMD="run"
OPT_FLAGS=""
OPT_DIRS="$ROOT_DIR/..."
##
# Parse arguments
##
while [[ $# -gt 0 ]]
do
case "$1" in
-h|--help)
usage 0 ;;
-w|--write)
OPT_CMD="run"
OPT_FLAGS+=" --fix" ;;
--list)
OPT_DIRS=""
OPT_CMD="linters" ;;
-v|--verbose)
OPT_FLAGS+=" -v" ;;
*)
color red "Unkown argument '$1'"
echo
usage 1 ;;
esac
shift
done
##
# Check golangci-lint command existence
##
if [ ! -x "$(command -v golangci-lint)" ];
then
echo "golangci-lint is not installed"
echo "On macOS, you can run: brew install golangci/tap/golangci-lint"
echo "On other systems, refer to installation instructions: https://github.com/golangci/golangci-lint#install"
exit 1
fi
##
# Execute golangci-lint command
##
golangci-lint $OPT_CMD $OPT_FLAGS $OPT_DIRS
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scripts/release.sh 0000775 0000000 0000000 00000000216 14563666056 0025723 0 ustar 00root root 0000000 0000000 #!/bin/bash
cd scripts/release || (echo "Please run this script from repo root" && exit 1)
yarn install --frozen-lock-file
yarn run release
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/ 0000775 0000000 0000000 00000000000 14563666056 0023052 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/README.md 0000664 0000000 0000000 00000010057 14563666056 0024334 0 ustar 00root root 0000000 0000000 # Scaleway config
## TL;DR
Recommended config file:
```yaml
# Get your credentials on https://console.scaleway.com/project/credentials
access_key: SCWXXXXXXXXXXXXXXXXX
secret_key: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
default_organization_id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
default_project_id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
default_region: fr-par
default_zone: fr-par-1
```
## Config file path
The function [`GetConfigPath`](https://godoc.org/github.com/scaleway/scaleway-sdk-go/scw#GetConfigPath) will try to locate the config file in the following ways:
1. Custom directory: `$SCW_CONFIG_PATH`
2. [XDG base directory](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html): `$XDG_CONFIG_HOME/scw/config.yaml`
3. Unix home directory: `$HOME/.config/scw/config.yaml`
4. Windows home directory: `%USERPROFILE%/.config/scw/config.yaml`
## Reading config order
[ClientOption](https://godoc.org/github.com/scaleway/scaleway-sdk-go/scw#ClientOption) ordering will decide the order in which the config should apply:
```go
p, _ := scw.MustLoadConfig().GetActiveProfile()
scw.NewClient(
scw.WithProfile(p), // active profile applies first
scw.WithEnv(), // existing env variables may overwrite active profile
scw.WithDefaultRegion(scw.RegionFrPar) // any prior region set will be discarded to usr the new one
)
```
## Environment variables
| Variable | Description | Legacy variables |
| :----------------------------- | :----------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------ |
| `$SCW_ACCESS_KEY` | Access key of a token ([get yours](https://console.scaleway.com/project/credentials)) | `$SCALEWAY_ACCESS_KEY` (used by terraform) |
| `$SCW_SECRET_KEY` | Secret key of a token ([get yours](https://console.scaleway.com/project/credentials)) | `$SCW_TOKEN` (used by cli), `$SCALEWAY_TOKEN` (used by terraform), `$SCALEWAY_ACCESS_KEY` (used by terraform) |
| `$SCW_DEFAULT_ORGANIZATION_ID` | Your default organization ID ([get yours](https://console.scaleway.com/project/credentials)) | `$SCW_ORGANIZATION` (used by cli),`$SCALEWAY_ORGANIZATION` (used by terraform) |
| `$SCW_DEFAULT_PROJECT_ID` | Your default project ID ([get yours](https://console.scaleway.com/project/credentials)) | |
| `$SCW_DEFAULT_REGION` | Your default [region](https://developers.scaleway.com/en/quickstart/#region-and-zone) | `$SCW_REGION` (used by cli),`$SCALEWAY_REGION` (used by terraform) |
| `$SCW_DEFAULT_ZONE` | Your default [availability zone](https://developers.scaleway.com/en/quickstart/#region-and-zone) | `$SCW_ZONE` (used by cli),`$SCALEWAY_ZONE` (used by terraform) |
| `$SCW_API_URL` | Url of the API | - |
| `$SCW_INSECURE` | Set this to `true` to enable the insecure mode | `$SCW_TLSVERIFY` (inverse flag used by the cli) |
| `$SCW_PROFILE` | Set the config profile to use | - |
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/client.go 0000664 0000000 0000000 00000040323 14563666056 0024661 0 ustar 00root root 0000000 0000000 package scw
import (
"crypto/tls"
"encoding/json"
"fmt"
"io"
"math"
"net/http"
"reflect"
"strconv"
"strings"
"sync"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/internal/generic"
"github.com/scaleway/scaleway-sdk-go/logger"
)
// Client is the Scaleway client which performs API requests.
//
// This client should be passed in the `NewApi` functions whenever an API instance is created.
// Creating a Client is done with the `NewClient` function.
type Client struct {
httpClient httpClient
auth auth.Auth
apiURL string
userAgent string
defaultOrganizationID *string
defaultProjectID *string
defaultRegion *Region
defaultZone *Zone
defaultPageSize *uint32
}
func defaultOptions() []ClientOption {
return []ClientOption{
WithoutAuth(),
WithAPIURL("https://api.scaleway.com"),
withDefaultUserAgent(userAgent),
}
}
// NewClient instantiate a new Client object.
//
// Zero or more ClientOption object can be passed as a parameter.
// These options will then be applied to the client.
func NewClient(opts ...ClientOption) (*Client, error) {
s := newSettings()
// apply options
s.apply(append(defaultOptions(), opts...))
// validate settings
err := s.validate()
if err != nil {
return nil, err
}
// dial the API
if s.httpClient == nil {
s.httpClient = newHTTPClient()
}
// insecure mode
if s.insecure {
logger.Debugf("client: using insecure mode")
setInsecureMode(s.httpClient)
}
if logger.ShouldLog(logger.LogLevelDebug) {
logger.Debugf("client: using request logger")
setRequestLogging(s.httpClient)
}
logger.Debugf("client: using sdk version " + version)
return &Client{
auth: s.token,
httpClient: s.httpClient,
apiURL: s.apiURL,
userAgent: s.userAgent,
defaultOrganizationID: s.defaultOrganizationID,
defaultProjectID: s.defaultProjectID,
defaultRegion: s.defaultRegion,
defaultZone: s.defaultZone,
defaultPageSize: s.defaultPageSize,
}, nil
}
// GetDefaultOrganizationID returns the default organization ID
// of the client. This value can be set in the client option
// WithDefaultOrganizationID(). Be aware this value can be empty.
func (c *Client) GetDefaultOrganizationID() (organizationID string, exists bool) {
if c.defaultOrganizationID != nil {
return *c.defaultOrganizationID, true
}
return "", false
}
// GetDefaultProjectID returns the default project ID
// of the client. This value can be set in the client option
// WithDefaultProjectID(). Be aware this value can be empty.
func (c *Client) GetDefaultProjectID() (projectID string, exists bool) {
if c.defaultProjectID != nil {
return *c.defaultProjectID, true
}
return "", false
}
// GetDefaultRegion returns the default region of the client.
// This value can be set in the client option
// WithDefaultRegion(). Be aware this value can be empty.
func (c *Client) GetDefaultRegion() (region Region, exists bool) {
if c.defaultRegion != nil {
return *c.defaultRegion, true
}
return Region(""), false
}
// GetDefaultZone returns the default zone of the client.
// This value can be set in the client option
// WithDefaultZone(). Be aware this value can be empty.
func (c *Client) GetDefaultZone() (zone Zone, exists bool) {
if c.defaultZone != nil {
return *c.defaultZone, true
}
return Zone(""), false
}
func (c *Client) GetSecretKey() (secretKey string, exists bool) {
if token, isToken := c.auth.(*auth.Token); isToken {
return token.SecretKey, isToken
}
return "", false
}
func (c *Client) GetAccessKey() (accessKey string, exists bool) {
if token, isToken := c.auth.(*auth.Token); isToken {
return token.AccessKey, isToken
} else if token, isAccessKey := c.auth.(*auth.AccessKeyOnly); isAccessKey {
return token.AccessKey, isAccessKey
}
return "", false
}
// GetDefaultPageSize returns the default page size of the client.
// This value can be set in the client option
// WithDefaultPageSize(). Be aware this value can be empty.
func (c *Client) GetDefaultPageSize() (pageSize uint32, exists bool) {
if c.defaultPageSize != nil {
return *c.defaultPageSize, true
}
return 0, false
}
// Do performs HTTP request(s) based on the ScalewayRequest object.
// RequestOptions are applied prior to doing the request.
func (c *Client) Do(req *ScalewayRequest, res interface{}, opts ...RequestOption) (err error) {
// apply request options
req.apply(opts)
// validate request options
err = req.validate()
if err != nil {
return err
}
if req.auth == nil {
req.auth = c.auth
}
if req.zones != nil {
return c.doListZones(req, res, req.zones)
}
if req.regions != nil {
return c.doListRegions(req, res, req.regions)
}
if req.allPages {
return c.doListAll(req, res)
}
return c.do(req, res)
}
// do performs a single HTTP request based on the ScalewayRequest object.
func (c *Client) do(req *ScalewayRequest, res interface{}) (sdkErr error) {
if req == nil {
return errors.New("request must be non-nil")
}
// build url
url, sdkErr := req.getURL(c.apiURL)
if sdkErr != nil {
return sdkErr
}
logger.Debugf("creating %s request on %s", req.Method, url.String())
// build request
httpRequest, err := http.NewRequest(req.Method, url.String(), req.Body)
if err != nil {
return errors.Wrap(err, "could not create request")
}
httpRequest.Header = req.getAllHeaders(req.auth, c.userAgent, false)
if req.ctx != nil {
httpRequest = httpRequest.WithContext(req.ctx)
}
// execute request
httpResponse, err := c.httpClient.Do(httpRequest)
if err != nil {
return errors.Wrap(err, "error executing request")
}
defer func() {
closeErr := httpResponse.Body.Close()
if sdkErr == nil && closeErr != nil {
sdkErr = errors.Wrap(closeErr, "could not close http response")
}
}()
sdkErr = hasResponseError(httpResponse)
if sdkErr != nil {
return sdkErr
}
if res != nil {
contentType := httpResponse.Header.Get("Content-Type")
if strings.HasPrefix(contentType, "application/json") {
err = json.NewDecoder(httpResponse.Body).Decode(&res)
if err != nil {
return errors.Wrap(err, "could not parse %s response body", contentType)
}
} else {
buffer, isBuffer := res.(io.Writer)
if !isBuffer {
return errors.Wrap(err, "could not handle %s response body with %T result type", contentType, buffer)
}
_, err := io.Copy(buffer, httpResponse.Body)
if err != nil {
return errors.Wrap(err, "could not copy %s response body", contentType)
}
}
// Handle instance API X-Total-Count header
xTotalCountStr := httpResponse.Header.Get("X-Total-Count")
if legacyLister, isLegacyLister := res.(legacyLister); isLegacyLister && xTotalCountStr != "" {
xTotalCount, err := strconv.ParseInt(xTotalCountStr, 10, 32)
if err != nil {
return errors.Wrap(err, "could not parse X-Total-Count header")
}
legacyLister.UnsafeSetTotalCount(int(xTotalCount))
}
}
return nil
}
type lister interface {
UnsafeGetTotalCount() uint64
UnsafeAppend(interface{}) (uint64, error)
}
// Old lister for uint32
// Used for retro-compatibility with response that use uint32
type lister32 interface {
UnsafeGetTotalCount() uint32
UnsafeAppend(interface{}) (uint32, error)
}
type legacyLister interface {
UnsafeSetTotalCount(totalCount int)
}
func listerGetTotalCount(i interface{}) uint64 {
if l, isLister := i.(lister); isLister {
return l.UnsafeGetTotalCount()
}
if l32, isLister32 := i.(lister32); isLister32 {
return uint64(l32.UnsafeGetTotalCount())
}
panic(fmt.Errorf("%T does not support pagination but checks failed, should not happen", i))
}
func listerAppend(recv interface{}, elems interface{}) (uint64, error) {
if l, isLister := recv.(lister); isLister {
return l.UnsafeAppend(elems)
} else if l32, isLister32 := recv.(lister32); isLister32 {
total, err := l32.UnsafeAppend(elems)
return uint64(total), err
}
panic(fmt.Errorf("%T does not support pagination but checks failed, should not happen", recv))
}
func isLister(i interface{}) bool {
switch i.(type) {
case lister:
return true
case lister32:
return true
default:
return false
}
}
const maxPageCount uint64 = math.MaxUint32
// doListAll collects all pages of a List request and aggregate all results on a single response.
func (c *Client) doListAll(req *ScalewayRequest, res interface{}) (err error) {
// check for lister interface
if isLister(res) {
pageCount := maxPageCount
for page := uint64(1); page <= pageCount; page++ {
// set current page
req.Query.Set("page", strconv.FormatUint(page, 10))
// request the next page
nextPage := newVariableFromType(res)
err := c.do(req, nextPage)
if err != nil {
return err
}
// append results
pageSize, err := listerAppend(res, nextPage)
if err != nil {
return err
}
if pageSize == 0 {
return nil
}
// set total count on first request
if pageCount == maxPageCount {
totalCount := listerGetTotalCount(nextPage)
pageCount = (totalCount + pageSize - 1) / pageSize
}
}
return nil
}
return errors.New("%T does not support pagination", res)
}
// doListLocalities collects all localities using mutliple list requests and aggregate all results on a lister response
// results is sorted by locality
func (c *Client) doListLocalities(req *ScalewayRequest, res interface{}, localities []string) (err error) {
path := req.Path
if !strings.Contains(path, "%locality%") {
return fmt.Errorf("request is not a valid locality request")
}
// Requests are parallelized
responseMutex := sync.Mutex{}
requestGroup := sync.WaitGroup{}
errChan := make(chan error, len(localities))
requestGroup.Add(len(localities))
for _, locality := range localities {
go func(locality string) {
defer requestGroup.Done()
// Request is cloned as doListAll will change header
// We remove zones as it would recurse in the same function
req := req.clone()
req.zones = []Zone(nil)
req.Path = strings.ReplaceAll(path, "%locality%", locality)
// We create a new response that we append to main response
zoneResponse := newVariableFromType(res)
err := c.Do(req, zoneResponse)
if err != nil {
errChan <- err
}
responseMutex.Lock()
_, err = listerAppend(res, zoneResponse)
responseMutex.Unlock()
if err != nil {
errChan <- err
}
}(locality)
}
requestGroup.Wait()
L: // We gather potential errors and return them all together
for {
select {
case newErr := <-errChan:
err = errors.Wrap(err, newErr.Error())
default:
break L
}
}
close(errChan)
if err != nil {
return err
}
return nil
}
// doListZones collects all zones using multiple list requests and aggregate all results on a single response.
// result is sorted by zone
func (c *Client) doListZones(req *ScalewayRequest, res interface{}, zones []Zone) (err error) {
if isLister(res) {
// Prepare request with %zone% that can be replaced with actual zone
for _, zone := range AllZones {
if strings.Contains(req.Path, string(zone)) {
req.Path = strings.ReplaceAll(req.Path, string(zone), "%locality%")
break
}
}
if !strings.Contains(req.Path, "%locality%") {
return fmt.Errorf("request is not a valid zoned request")
}
localities := make([]string, 0, len(zones))
for _, zone := range zones {
localities = append(localities, string(zone))
}
err := c.doListLocalities(req, res, localities)
if err != nil {
return fmt.Errorf("failed to list localities: %w", err)
}
sortResponseByZones(res, zones)
return nil
}
return errors.New("%T does not support pagination", res)
}
// doListRegions collects all regions using multiple list requests and aggregate all results on a single response.
// result is sorted by region
func (c *Client) doListRegions(req *ScalewayRequest, res interface{}, regions []Region) (err error) {
if isLister(res) {
// Prepare request with %locality% that can be replaced with actual region
for _, region := range AllRegions {
if strings.Contains(req.Path, string(region)) {
req.Path = strings.ReplaceAll(req.Path, string(region), "%locality%")
break
}
}
if !strings.Contains(req.Path, "%locality%") {
return fmt.Errorf("request is not a valid zoned request")
}
localities := make([]string, 0, len(regions))
for _, region := range regions {
localities = append(localities, string(region))
}
err := c.doListLocalities(req, res, localities)
if err != nil {
return fmt.Errorf("failed to list localities: %w", err)
}
sortResponseByRegions(res, regions)
return nil
}
return errors.New("%T does not support pagination", res)
}
// sortSliceByZones sorts a slice of struct using a Zone field that should exist
func sortSliceByZones(list interface{}, zones []Zone) {
if !generic.HasField(list, "Zone") {
return
}
zoneMap := map[Zone]int{}
for i, zone := range zones {
zoneMap[zone] = i
}
generic.SortSliceByField(list, "Zone", func(i interface{}, i2 interface{}) bool {
return zoneMap[i.(Zone)] < zoneMap[i2.(Zone)]
})
}
// sortSliceByRegions sorts a slice of struct using a Region field that should exist
func sortSliceByRegions(list interface{}, regions []Region) {
if !generic.HasField(list, "Region") {
return
}
regionMap := map[Region]int{}
for i, region := range regions {
regionMap[region] = i
}
generic.SortSliceByField(list, "Region", func(i interface{}, i2 interface{}) bool {
return regionMap[i.(Region)] < regionMap[i2.(Region)]
})
}
// sortResponseByZones find first field that is a slice in a struct and sort it by zone
func sortResponseByZones(res interface{}, zones []Zone) {
// res may be ListServersResponse
//
// type ListServersResponse struct {
// TotalCount uint32 `json:"total_count"`
// Servers []*Server `json:"servers"`
// }
// We iterate over fields searching for the slice one to sort it
resType := reflect.TypeOf(res).Elem()
fields := reflect.VisibleFields(resType)
for _, field := range fields {
if field.Type.Kind() == reflect.Slice {
sortSliceByZones(reflect.ValueOf(res).Elem().FieldByName(field.Name).Interface(), zones)
return
}
}
}
// sortResponseByRegions find first field that is a slice in a struct and sort it by region
func sortResponseByRegions(res interface{}, regions []Region) {
// res may be ListServersResponse
//
// type ListServersResponse struct {
// TotalCount uint32 `json:"total_count"`
// Servers []*Server `json:"servers"`
// }
// We iterate over fields searching for the slice one to sort it
resType := reflect.TypeOf(res).Elem()
fields := reflect.VisibleFields(resType)
for _, field := range fields {
if field.Type.Kind() == reflect.Slice {
sortSliceByRegions(reflect.ValueOf(res).Elem().FieldByName(field.Name).Interface(), regions)
return
}
}
}
// newVariableFromType returns a variable set to the zero value of the given type
func newVariableFromType(t interface{}) interface{} {
// reflect.New always create a pointer, that's why we use reflect.Indirect before
return reflect.New(reflect.Indirect(reflect.ValueOf(t)).Type()).Interface()
}
func newHTTPClient() *http.Client {
return &http.Client{
Timeout: 30 * time.Second,
Transport: http.DefaultTransport.(*http.Transport).Clone(),
}
}
func setInsecureMode(c httpClient) {
standardHTTPClient, ok := c.(*http.Client)
if !ok {
logger.Warningf("client: cannot use insecure mode with HTTP client of type %T", c)
return
}
transportClient, ok := standardHTTPClient.Transport.(*http.Transport)
if !ok {
logger.Warningf("client: cannot use insecure mode with Transport client of type %T", standardHTTPClient.Transport)
return
}
if transportClient.TLSClientConfig == nil {
transportClient.TLSClientConfig = &tls.Config{}
}
transportClient.TLSClientConfig.InsecureSkipVerify = true
}
func setRequestLogging(c httpClient) {
standardHTTPClient, ok := c.(*http.Client)
if !ok {
logger.Warningf("client: cannot use request logger with HTTP client of type %T", c)
return
}
// Do not wrap transport if it is already a logger
// As client is a pointer, changing transport will change given client
// If the same httpClient is used in multiple scwClient, it would add multiple logger transports
_, isLogger := standardHTTPClient.Transport.(*requestLoggerTransport)
if !isLogger {
standardHTTPClient.Transport = &requestLoggerTransport{rt: standardHTTPClient.Transport}
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/client_option.go 0000664 0000000 0000000 00000017437 14563666056 0026263 0 ustar 00root root 0000000 0000000 package scw
import (
"net/http"
"strings"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/validation"
)
// ClientOption is a function which applies options to a settings object.
type ClientOption func(*settings)
// httpClient wraps the net/http Client Do method
type httpClient interface {
Do(*http.Request) (*http.Response, error)
}
// WithHTTPClient client option allows passing a custom http.Client which will be used for all requests.
func WithHTTPClient(httpClient httpClient) ClientOption {
return func(s *settings) {
s.httpClient = httpClient
}
}
// WithoutAuth client option sets the client token to an empty token.
func WithoutAuth() ClientOption {
return func(s *settings) {
s.token = auth.NewNoAuth()
}
}
// WithAuth client option sets the client access key and secret key.
func WithAuth(accessKey, secretKey string) ClientOption {
return func(s *settings) {
s.token = auth.NewToken(accessKey, secretKey)
}
}
// WithJWT client option sets the client session token.
func WithJWT(token string) ClientOption {
return func(s *settings) {
s.token = auth.NewJWT(token)
}
}
// WithAPIURL client option overrides the API URL of the Scaleway API to the given URL.
func WithAPIURL(apiURL string) ClientOption {
return func(s *settings) {
s.apiURL = apiURL
}
}
// WithInsecure client option enables insecure transport on the client.
func WithInsecure() ClientOption {
return func(s *settings) {
s.insecure = true
}
}
// WithUserAgent client option append a user agent to the default user agent of the SDK.
func WithUserAgent(ua string) ClientOption {
return func(s *settings) {
if s.userAgent != "" && ua != "" {
s.userAgent += " "
}
s.userAgent += ua
}
}
// withDefaultUserAgent client option overrides the default user agent of the SDK.
func withDefaultUserAgent(ua string) ClientOption {
return func(s *settings) {
s.userAgent = ua
}
}
// WithProfile client option configures a client from the given profile.
func WithProfile(p *Profile) ClientOption {
return func(s *settings) {
accessKey := ""
if p.AccessKey != nil {
accessKey = *p.AccessKey
s.token = auth.NewAccessKeyOnly(accessKey)
}
if p.SecretKey != nil {
s.token = auth.NewToken(accessKey, *p.SecretKey)
}
if p.APIURL != nil {
s.apiURL = *p.APIURL
}
if p.Insecure != nil {
s.insecure = *p.Insecure
}
if p.DefaultOrganizationID != nil {
organizationID := *p.DefaultOrganizationID
s.defaultOrganizationID = &organizationID
}
if p.DefaultProjectID != nil {
projectID := *p.DefaultProjectID
s.defaultProjectID = &projectID
}
if p.DefaultRegion != nil {
defaultRegion := Region(*p.DefaultRegion)
s.defaultRegion = &defaultRegion
}
if p.DefaultZone != nil {
defaultZone := Zone(*p.DefaultZone)
s.defaultZone = &defaultZone
}
}
}
// WithEnv client option configures a client from the environment variables.
func WithEnv() ClientOption {
return WithProfile(LoadEnvProfile())
}
// WithDefaultOrganizationID client option sets the client default organization ID.
//
// It will be used as the default value of the organization_id field in all requests made with this client.
func WithDefaultOrganizationID(organizationID string) ClientOption {
return func(s *settings) {
s.defaultOrganizationID = &organizationID
}
}
// WithDefaultProjectID client option sets the client default project ID.
//
// It will be used as the default value of the projectID field in all requests made with this client.
func WithDefaultProjectID(projectID string) ClientOption {
return func(s *settings) {
s.defaultProjectID = &projectID
}
}
// WithDefaultRegion client option sets the client default region.
//
// It will be used as the default value of the region field in all requests made with this client.
func WithDefaultRegion(region Region) ClientOption {
return func(s *settings) {
s.defaultRegion = ®ion
}
}
// WithDefaultZone client option sets the client default zone.
//
// It will be used as the default value of the zone field in all requests made with this client.
func WithDefaultZone(zone Zone) ClientOption {
return func(s *settings) {
s.defaultZone = &zone
}
}
// WithDefaultPageSize client option overrides the default page size of the SDK.
//
// It will be used as the default value of the page_size field in all requests made with this client.
func WithDefaultPageSize(pageSize uint32) ClientOption {
return func(s *settings) {
s.defaultPageSize = &pageSize
}
}
// settings hold the values of all client options
type settings struct {
apiURL string
token auth.Auth
userAgent string
httpClient httpClient
insecure bool
defaultOrganizationID *string
defaultProjectID *string
defaultRegion *Region
defaultZone *Zone
defaultPageSize *uint32
}
func newSettings() *settings {
return &settings{}
}
func (s *settings) apply(opts []ClientOption) {
for _, opt := range opts {
opt(s)
}
}
func (s *settings) validate() error {
// Auth.
if s.token == nil {
// It should not happen, WithoutAuth option is used by default.
panic(errors.New("no credential option provided"))
}
if token, isToken := s.token.(*auth.Token); isToken {
if token.AccessKey == "" {
return NewInvalidClientOptionError("access key cannot be empty")
}
if !validation.IsAccessKey(token.AccessKey) {
return NewInvalidClientOptionError("invalid access key format '%s', expected SCWXXXXXXXXXXXXXXXXX format", token.AccessKey)
}
if token.SecretKey == "" {
return NewInvalidClientOptionError("secret key cannot be empty")
}
if !validation.IsSecretKey(token.SecretKey) {
return NewInvalidClientOptionError("invalid secret key format '%s', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", token.SecretKey)
}
}
// Default Organization ID.
if s.defaultOrganizationID != nil {
if *s.defaultOrganizationID == "" {
return NewInvalidClientOptionError("default organization ID cannot be empty")
}
if !validation.IsOrganizationID(*s.defaultOrganizationID) {
return NewInvalidClientOptionError("invalid organization ID format '%s', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", *s.defaultOrganizationID)
}
}
// Default Project ID.
if s.defaultProjectID != nil {
if *s.defaultProjectID == "" {
return NewInvalidClientOptionError("default project ID cannot be empty")
}
if !validation.IsProjectID(*s.defaultProjectID) {
return NewInvalidClientOptionError("invalid project ID format '%s', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", *s.defaultProjectID)
}
}
// Default Region.
if s.defaultRegion != nil {
if *s.defaultRegion == "" {
return NewInvalidClientOptionError("default region cannot be empty")
}
if !validation.IsRegion(string(*s.defaultRegion)) {
regions := []string(nil)
for _, r := range AllRegions {
regions = append(regions, string(r))
}
return NewInvalidClientOptionError("invalid default region format '%s', available regions are: %s", *s.defaultRegion, strings.Join(regions, ", "))
}
}
// Default Zone.
if s.defaultZone != nil {
if *s.defaultZone == "" {
return NewInvalidClientOptionError("default zone cannot be empty")
}
if !validation.IsZone(string(*s.defaultZone)) {
zones := []string(nil)
for _, z := range AllZones {
zones = append(zones, string(z))
}
return NewInvalidClientOptionError("invalid default zone format '%s', available zones are: %s", *s.defaultZone, strings.Join(zones, ", "))
}
}
// API URL.
if !validation.IsURL(s.apiURL) {
return NewInvalidClientOptionError("invalid url %s", s.apiURL)
}
if s.apiURL[len(s.apiURL)-1:] == "/" {
return NewInvalidClientOptionError("invalid url %s it should not have a trailing slash", s.apiURL)
}
// TODO: check for max s.defaultPageSize
return nil
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/client_option_test.go 0000664 0000000 0000000 00000021451 14563666056 0027311 0 ustar 00root root 0000000 0000000 package scw
import (
"os"
"strings"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
var (
defaultOrganizationID = "6170692e-7363-616c-6577-61792e636f6d" // hint: | xxd -ps -r
defaultProjectID = "6170692e-7363-616c-6577-61792e636f6d" // hint: | xxd -ps -r
defaultRegion = RegionNlAms
defaultZone = ZoneNlAms1
)
func TestClientOptions(t *testing.T) {
testCases := []struct {
name string
clientOption ClientOption
errStr string
}{
{
name: "Create a valid client option",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2ValidAccessKey, v2ValidSecretKey)
s.apiURL = v2ValidAPIURL
s.defaultOrganizationID = &defaultOrganizationID
s.defaultProjectID = &defaultProjectID
s.defaultRegion = &defaultRegion
s.defaultZone = &defaultZone
},
},
{
name: "Should throw an empty access key error",
clientOption: func(s *settings) {
s.token = auth.NewToken("", v2ValidSecretKey)
},
errStr: "scaleway-sdk-go: access key cannot be empty",
},
{
name: "Should throw a bad access key error",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2InvalidAccessKey, v2ValidSecretKey)
},
errStr: "scaleway-sdk-go: invalid access key format 'invalid', expected SCWXXXXXXXXXXXXXXXXX format",
},
{
name: "Should throw an empty secret key error",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2ValidAccessKey, "")
},
errStr: "scaleway-sdk-go: secret key cannot be empty",
},
{
name: "Should throw a bad secret key error",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2ValidAccessKey, v2InvalidSecretKey)
},
errStr: "scaleway-sdk-go: invalid secret key format 'invalid', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
},
{
name: "Should throw an url error",
clientOption: func(s *settings) {
s.apiURL = ":test"
s.token = auth.NewToken(v2ValidAccessKey, v2ValidSecretKey)
},
errStr: "scaleway-sdk-go: invalid url :test",
},
{
name: "Should throw an empty organization ID error",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2ValidAccessKey, v2ValidSecretKey)
s.defaultOrganizationID = StringPtr("")
},
errStr: "scaleway-sdk-go: default organization ID cannot be empty",
},
{
name: "Should throw a bad organization ID error",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2ValidAccessKey, v2ValidSecretKey)
s.defaultOrganizationID = StringPtr(v2InvalidDefaultOrganizationID)
},
errStr: "scaleway-sdk-go: invalid organization ID format 'invalid', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
},
{
name: "Should throw an empty project ID error",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2ValidAccessKey, v2ValidSecretKey)
s.defaultProjectID = StringPtr("")
},
errStr: "scaleway-sdk-go: default project ID cannot be empty",
},
{
name: "Should throw a bad project ID error",
clientOption: func(s *settings) {
s.token = auth.NewToken(v2ValidAccessKey, v2ValidSecretKey)
s.defaultProjectID = StringPtr(v2InvalidDefaultProjectID)
},
errStr: "scaleway-sdk-go: invalid project ID format 'invalid', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
},
{
name: "Should throw a region error",
clientOption: func(s *settings) {
v := Region("")
s.token = auth.NewToken(testAccessKey, testSecretKey)
s.defaultRegion = &v
},
errStr: "scaleway-sdk-go: default region cannot be empty",
},
{
name: "Should throw a bad region error",
clientOption: func(s *settings) {
v := Region(v2InvalidDefaultRegion)
s.token = auth.NewToken(testAccessKey, testSecretKey)
s.defaultRegion = &v
},
errStr: "scaleway-sdk-go: invalid default region format 'invalid', available regions are: fr-par, nl-ams, pl-waw",
},
{
name: "Should throw a zone error",
clientOption: func(s *settings) {
v := Zone("")
s.token = auth.NewToken(testAccessKey, testSecretKey)
s.defaultZone = &v
},
errStr: "scaleway-sdk-go: default zone cannot be empty",
},
{
name: "Should throw a bad zone error",
clientOption: func(s *settings) {
v := Zone(v2InvalidDefaultZone)
s.token = auth.NewToken(testAccessKey, testSecretKey)
s.defaultZone = &v
},
errStr: "scaleway-sdk-go: invalid default zone format 'invalid', available zones are: fr-par-1, fr-par-2, fr-par-3, nl-ams-1, nl-ams-2, nl-ams-3, pl-waw-1, pl-waw-2, pl-waw-3",
},
}
for _, c := range testCases {
t.Run(c.name, func(t *testing.T) {
// New
s := newSettings()
// Apply
s.apply([]ClientOption{c.clientOption})
// Validate
err := s.validate()
if c.errStr != "" {
testhelpers.Assert(t, err != nil, "Should have error")
testhelpers.Equals(t, c.errStr, err.Error())
} else {
testhelpers.AssertNoError(t, err)
}
})
}
}
func TestCombinedClientOptions(t *testing.T) {
tests := []struct {
name string
env map[string]string
files map[string]string
expectedError string
expectedAccessKey string
expectedSecretKey string
expectedAPIURL string
expectedDefaultOrganizationID *string
expectedDefaultProjectID *string
expectedDefaultRegion *Region
expectedDefaultZone *Zone
}{
{
name: "Complete config file with env variables",
env: map[string]string{
"HOME": "{HOME}",
ScwAccessKeyEnv: v2ValidAccessKey2,
ScwSecretKeyEnv: v2ValidSecretKey2,
ScwAPIURLEnv: v2ValidAPIURL2,
ScwDefaultOrganizationIDEnv: v2ValidDefaultOrganizationID2,
ScwDefaultProjectIDEnv: v2ValidDefaultProjectID2,
ScwDefaultRegionEnv: v2ValidDefaultRegion2,
ScwDefaultZoneEnv: v2ValidDefaultZone2,
},
files: map[string]string{
".config/scw/config.yaml": v2CompleteValidConfigFile,
},
expectedAccessKey: v2ValidAccessKey2,
expectedSecretKey: v2ValidSecretKey2,
expectedAPIURL: v2ValidAPIURL2,
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID2),
expectedDefaultProjectID: s(v2ValidDefaultProjectID2),
expectedDefaultRegion: r(Region(v2ValidDefaultRegion2)),
expectedDefaultZone: z(Zone(v2ValidDefaultZone2)),
},
{
name: "Complete config with active profile env variable and all env variables",
env: map[string]string{
"HOME": "{HOME}",
ScwActiveProfileEnv: v2ValidProfile,
ScwAccessKeyEnv: v2ValidAccessKey,
ScwSecretKeyEnv: v2ValidSecretKey,
ScwAPIURLEnv: v2ValidAPIURL,
ScwDefaultOrganizationIDEnv: v2ValidDefaultOrganizationID,
ScwDefaultProjectIDEnv: v2ValidDefaultProjectID,
ScwDefaultRegionEnv: v2ValidDefaultRegion,
ScwDefaultZoneEnv: v2ValidDefaultZone,
},
files: map[string]string{
".config/scw/config.yaml": v2CompleteValidConfigFile,
},
expectedAccessKey: v2ValidAccessKey,
expectedSecretKey: v2ValidSecretKey,
expectedAPIURL: v2ValidAPIURL,
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: r(Region(v2ValidDefaultRegion)),
expectedDefaultZone: z(Zone(v2ValidDefaultZone)),
},
}
// create home dir
dir := initEnv(t)
// delete home dir and reset env variables
defer resetEnv(t, os.Environ(), dir)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
// set up env and config file(s)
setEnv(t, test.env, test.files, dir)
test.expectedError = strings.Replace(test.expectedError, "{HOME}", dir, -1)
// remove config file(s)
defer cleanEnv(t, test.files, dir)
config, err := LoadConfig()
testhelpers.AssertNoError(t, err)
p, err := config.GetActiveProfile()
testhelpers.AssertNoError(t, err)
client, err := NewClient(WithProfile(p), WithEnv())
if test.expectedError == "" {
testhelpers.AssertNoError(t, err)
// assert getters
testhelpers.Equals(t, test.expectedAccessKey, client.auth.(*auth.Token).AccessKey)
testhelpers.Equals(t, test.expectedSecretKey, client.auth.(*auth.Token).SecretKey)
testhelpers.Equals(t, test.expectedAPIURL, client.apiURL)
testhelpers.Equals(t, test.expectedDefaultOrganizationID, client.defaultOrganizationID)
testhelpers.Equals(t, test.expectedDefaultProjectID, client.defaultProjectID)
testhelpers.Equals(t, test.expectedDefaultRegion, client.defaultRegion)
testhelpers.Equals(t, test.expectedDefaultZone, client.defaultZone)
// skip insecure tests
} else {
testhelpers.Equals(t, test.expectedError, err.Error())
}
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/client_test.go 0000664 0000000 0000000 00000020006 14563666056 0025714 0 ustar 00root root 0000000 0000000 package scw
import (
"bytes"
"net/http"
"os"
"strings"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
"github.com/scaleway/scaleway-sdk-go/logger"
)
const (
testAPIURL = "https://api.example.com"
defaultAPIURL = "https://api.scaleway.com"
testAccessKey = "SCW1234567890ABCDEFG"
testSecretKey = "7363616c-6577-6573-6862-6f7579616161" // hint: | xxd -ps -r
testDefaultOrganizationID = "6170692e-7363-616c-6577-61792e636f6d" // hint: | xxd -ps -r
testDefaultProjectID = "6170692e-7363-616c-6577-61792e636f6e"
testDefaultRegion = RegionFrPar
testDefaultZone = ZoneFrPar1
testDefaultPageSize = uint32(5)
testInsecure = true
)
func TestNewClientWithNoAuth(t *testing.T) {
t.Run("Basic", func(t *testing.T) {
client, err := NewClient()
testhelpers.AssertNoError(t, err)
secretKey, exist := client.GetSecretKey()
testhelpers.Equals(t, "", secretKey)
testhelpers.Assert(t, !exist, "secretKey must not exist")
accessKey, exist := client.GetAccessKey()
testhelpers.Equals(t, "", accessKey)
testhelpers.Assert(t, !exist, "accessKey must not exist")
})
t.Run("Only access key", func(t *testing.T) {
client, err := NewClient(WithProfile(&Profile{
AccessKey: StringPtr(testAccessKey),
}))
testhelpers.AssertNoError(t, err)
secretKey, exist := client.GetSecretKey()
testhelpers.Equals(t, "", secretKey)
testhelpers.Assert(t, !exist, "secretKey must not exist")
accessKey, exist := client.GetAccessKey()
testhelpers.Assert(t, exist, "accessKey must exist")
testhelpers.Equals(t, accessKey, testAccessKey)
})
}
func TestNewClientMultipleClients(t *testing.T) {
t.Run("Basic", func(t *testing.T) {
logger.EnableDebugMode()
httpClient := &http.Client{}
_, err := NewClient(WithHTTPClient(httpClient))
testhelpers.AssertNoError(t, err)
_, isLogger := httpClient.Transport.(*requestLoggerTransport)
testhelpers.Assert(t, isLogger, "transport should be a request logger")
_, err = NewClient(WithHTTPClient(httpClient))
testhelpers.AssertNoError(t, err)
transport, isLogger := httpClient.Transport.(*requestLoggerTransport)
testhelpers.Assert(t, isLogger, "transport should be a request logger")
_, isLogger = transport.rt.(*requestLoggerTransport)
testhelpers.Assert(t, !isLogger, "nested transport should not be a request logger")
})
}
func TestNewClientWithDefaults(t *testing.T) {
options := []ClientOption{
WithInsecure(),
}
client, err := NewClient(options...)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, defaultAPIURL, client.apiURL)
testhelpers.Equals(t, auth.NewNoAuth(), client.auth)
}
func TestNewClientWithOptions(t *testing.T) {
t.Run("Basic", func(t *testing.T) {
someHTTPClient := &http.Client{}
options := []ClientOption{
WithAPIURL(testAPIURL),
WithAuth(testAccessKey, testSecretKey),
WithHTTPClient(someHTTPClient),
WithDefaultOrganizationID(testDefaultOrganizationID),
WithDefaultProjectID(testDefaultProjectID),
WithDefaultRegion(testDefaultRegion),
WithDefaultZone(testDefaultZone),
WithDefaultPageSize(testDefaultPageSize),
}
client, err := NewClient(options...)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, testAPIURL, client.apiURL)
testhelpers.Equals(t, auth.NewToken(testAccessKey, testSecretKey), client.auth)
testhelpers.Equals(t, someHTTPClient, client.httpClient)
defaultOrganizationID, exist := client.GetDefaultOrganizationID()
testhelpers.Equals(t, testDefaultOrganizationID, defaultOrganizationID)
testhelpers.Assert(t, exist, "defaultOrganizationID must exist")
defaultProjectID, exist := client.GetDefaultProjectID()
testhelpers.Equals(t, testDefaultProjectID, defaultProjectID)
testhelpers.Assert(t, exist, "defaultProjectID must exist")
defaultRegion, exist := client.GetDefaultRegion()
testhelpers.Equals(t, testDefaultRegion, defaultRegion)
testhelpers.Assert(t, exist, "defaultRegion must exist")
defaultZone, exist := client.GetDefaultZone()
testhelpers.Equals(t, testDefaultZone, defaultZone)
testhelpers.Assert(t, exist, "defaultZone must exist")
defaultPageSize, exist := client.GetDefaultPageSize()
testhelpers.Equals(t, testDefaultPageSize, defaultPageSize)
testhelpers.Assert(t, exist, "defaultPageSize must exist")
secretKey, exist := client.GetSecretKey()
testhelpers.Equals(t, testSecretKey, secretKey)
testhelpers.Assert(t, exist, "secretKey must exist")
accessKey, exist := client.GetAccessKey()
testhelpers.Equals(t, testAccessKey, accessKey)
testhelpers.Assert(t, exist, "accessKey must exist")
})
t.Run("With custom profile", func(t *testing.T) {
profile := &Profile{
s(testAccessKey),
s(testSecretKey),
s(testAPIURL),
b(testInsecure),
s(testDefaultOrganizationID),
s(testDefaultProjectID),
s(string(testDefaultRegion)),
s(string(testDefaultZone)),
b(true),
}
client, err := NewClient(WithProfile(profile))
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, auth.NewToken(testAccessKey, testSecretKey), client.auth)
testhelpers.Equals(t, testAPIURL, client.apiURL)
clientTransport, ok := client.httpClient.(*http.Client).Transport.(*http.Transport)
if loggerTransport, isLogger := client.httpClient.(*http.Client).Transport.(*requestLoggerTransport); !ok && isLogger {
clientTransport, ok = loggerTransport.rt.(*http.Transport)
}
testhelpers.Assert(t, ok, "clientTransport must be not nil")
testhelpers.Assert(t, clientTransport.TLSClientConfig != nil, "TLSClientConfig must be not nil")
testhelpers.Equals(t, testInsecure, clientTransport.TLSClientConfig.InsecureSkipVerify)
defaultOrganizationID, exist := client.GetDefaultOrganizationID()
testhelpers.Equals(t, testDefaultOrganizationID, defaultOrganizationID)
testhelpers.Assert(t, exist, "defaultOrganizationID must exist")
defaultProjectID, exist := client.GetDefaultProjectID()
testhelpers.Equals(t, testDefaultProjectID, defaultProjectID)
testhelpers.Assert(t, exist, "defaultProjectID must exist")
defaultRegion, exist := client.GetDefaultRegion()
testhelpers.Equals(t, testDefaultRegion, defaultRegion)
testhelpers.Assert(t, exist, "defaultRegion must exist")
defaultZone, exist := client.GetDefaultZone()
testhelpers.Equals(t, testDefaultZone, defaultZone)
testhelpers.Assert(t, exist, "defaultZone must exist")
_, exist = client.GetDefaultPageSize()
testhelpers.Assert(t, !exist, "defaultPageSize must not exist")
secretKey, exist := client.GetSecretKey()
testhelpers.Equals(t, testSecretKey, secretKey)
testhelpers.Assert(t, exist, "secretKey must exist")
accessKey, exist := client.GetAccessKey()
testhelpers.Equals(t, testAccessKey, accessKey)
testhelpers.Assert(t, exist, "accessKey must exist")
})
}
type fakeHTTPClient struct{}
func (fakeHTTPClient) Do(*http.Request) (*http.Response, error) {
return nil, nil
}
func (fakeHTTPClient) RoundTrip(*http.Request) (*http.Response, error) {
return nil, nil
}
// TestSetInsecureMode test if setInsecureMode panic when given custom HTTP client
func TestSetInsecureMode(t *testing.T) {
var buf bytes.Buffer
logger.DefaultLogger.Init(&buf, logger.LogLevelWarning)
// custom Transport client
clientWithFakeTransport := newHTTPClient()
clientWithFakeTransport.Transport = fakeHTTPClient{}
setInsecureMode(clientWithFakeTransport)
// custom HTTP client
setInsecureMode(fakeHTTPClient{})
// check log messages
lines := strings.Split(buf.String(), "\n")
getLogMessage := func(s string) string {
return strings.Join(strings.Split(s, " ")[3:], " ")
}
testhelpers.Equals(t, "client: cannot use insecure mode with Transport client of type scw.fakeHTTPClient", getLogMessage(lines[0]))
testhelpers.Equals(t, "client: cannot use insecure mode with HTTP client of type scw.fakeHTTPClient", getLogMessage(lines[1]))
logger.DefaultLogger.Init(os.Stderr, logger.LogLevelWarning)
}
func TestNewVariableFromType(t *testing.T) {
type fakeType struct {
plop int
}
testhelpers.Equals(t, &fakeType{}, newVariableFromType(&fakeType{3}))
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/config.go 0000664 0000000 0000000 00000031106 14563666056 0024647 0 ustar 00root root 0000000 0000000 package scw
import (
"bytes"
goerrors "errors"
"io/ioutil"
"os"
"path/filepath"
"strings"
"text/template"
"gopkg.in/yaml.v2"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/logger"
)
const (
documentationLink = "https://github.com/scaleway/scaleway-sdk-go/blob/master/scw/README.md"
defaultConfigPermission = 0600
// Reserved name for the default profile.
DefaultProfileName = "default"
)
const configFileTemplate = `# Scaleway configuration file
# https://github.com/scaleway/scaleway-sdk-go/tree/master/scw#scaleway-config
# This configuration file can be used with:
# - Scaleway SDK Go (https://github.com/scaleway/scaleway-sdk-go)
# - Scaleway CLI (>2.0.0) (https://github.com/scaleway/scaleway-cli)
# - Scaleway Terraform Provider (https://www.terraform.io/docs/providers/scaleway/index.html)
# You need an access key and a secret key to connect to Scaleway API.
# Generate your token at the following address: https://console.scaleway.com/iam/api-keys
# An access key is a secret key identifier.
{{ if .AccessKey }}access_key: {{.AccessKey}}{{ else }}# access_key: SCW11111111111111111{{ end }}
# The secret key is the value that can be used to authenticate against the API (the value used in X-Auth-Token HTTP-header).
# The secret key MUST remain secret and not given to anyone or published online.
{{ if .SecretKey }}secret_key: {{ .SecretKey }}{{ else }}# secret_key: 11111111-1111-1111-1111-111111111111{{ end }}
# Your organization ID is the identifier of your account inside Scaleway infrastructure.
{{ if .DefaultOrganizationID }}default_organization_id: {{ .DefaultOrganizationID }}{{ else }}# default_organization_id: 11111111-1111-1111-1111-111111111111{{ end }}
# Your project ID is the identifier of the project your resources are attached to (beta).
{{ if .DefaultProjectID }}default_project_id: {{ .DefaultProjectID }}{{ else }}# default_project_id: 11111111-1111-1111-1111-111111111111{{ end }}
# A region is represented as a geographical area such as France (Paris) or the Netherlands (Amsterdam).
# It can contain multiple availability zones.
# Example of region: fr-par, nl-ams
{{ if .DefaultRegion }}default_region: {{ .DefaultRegion }}{{ else }}# default_region: fr-par{{ end }}
# A region can be split into many availability zones (AZ).
# Latency between multiple AZ of the same region are low as they have a common network layer.
# Example of zones: fr-par-1, nl-ams-1
{{ if .DefaultZone }}default_zone: {{.DefaultZone}}{{ else }}# default_zone: fr-par-1{{ end }}
# APIURL overrides the API URL of the Scaleway API to the given URL.
# Change that if you want to direct requests to a different endpoint.
{{ if .APIURL }}apiurl: {{ .APIURL }}{{ else }}# api_url: https://api.scaleway.com{{ end }}
# Insecure enables insecure transport on the client.
# Default to false
{{ if .Insecure }}insecure: {{ .Insecure }}{{ else }}# insecure: false{{ end }}
# A configuration is a named set of Scaleway properties.
# Starting off with a Scaleway SDK or Scaleway CLI, you’ll work with a single configuration named default.
# You can set properties of the default profile by running either scw init or scw config set.
# This single default configuration is suitable for most use cases.
{{ if .ActiveProfile }}active_profile: {{ .ActiveProfile }}{{ else }}# active_profile: myProfile{{ end }}
# To improve the Scaleway CLI we rely on diagnostic and usage data.
# Sending such data is optional and can be disable at any time by setting send_telemetry variable to false.
{{ if .SendTelemetry }}send_telemetry: {{ .SendTelemetry }}{{ else }}# send_telemetry: false{{ end }}
# To work with multiple projects or authorization accounts, you can set up multiple configurations with scw config configurations create and switch among them accordingly.
# You can use a profile by either:
# - Define the profile you want to use as the SCW_PROFILE environment variable
# - Use the GetActiveProfile() function in the SDK
# - Use the --profile flag with the CLI
# You can define a profile using the following syntax:
{{ if gt (len .Profiles) 0 }}
profiles:
{{- range $k,$v := .Profiles }}
{{ $k }}:
{{ if $v.AccessKey }}access_key: {{ $v.AccessKey }}{{ else }}# access_key: SCW11111111111111111{{ end }}
{{ if $v.SecretKey }}secret_key: {{ $v.SecretKey }}{{ else }}# secret_key: 11111111-1111-1111-1111-111111111111{{ end }}
{{ if $v.DefaultOrganizationID }}default_organization_id: {{ $v.DefaultOrganizationID }}{{ else }}# default_organization_id: 11111111-1111-1111-1111-111111111111{{ end }}
{{ if $v.DefaultProjectID }}default_project_id: {{ $v.DefaultProjectID }}{{ else }}# default_project_id: 11111111-1111-1111-1111-111111111111{{ end }}
{{ if $v.DefaultZone }}default_zone: {{ $v.DefaultZone }}{{ else }}# default_zone: fr-par-1{{ end }}
{{ if $v.DefaultRegion }}default_region: {{ $v.DefaultRegion }}{{ else }}# default_region: fr-par{{ end }}
{{ if $v.APIURL }}api_url: {{ $v.APIURL }}{{ else }}# api_url: https://api.scaleway.com{{ end }}
{{ if $v.Insecure }}insecure: {{ $v.Insecure }}{{ else }}# insecure: false{{ end }}
{{ end }}
{{- else }}
# profiles:
# myProfile:
# access_key: 11111111-1111-1111-1111-111111111111
# secret_key: 11111111-1111-1111-1111-111111111111
# default_organization_id: 11111111-1111-1111-1111-111111111111
# default_project_id: 11111111-1111-1111-1111-111111111111
# default_zone: fr-par-1
# default_region: fr-par
# api_url: https://api.scaleway.com
# insecure: false
{{ end -}}
`
type Config struct {
Profile `yaml:",inline"`
ActiveProfile *string `yaml:"active_profile,omitempty" json:"active_profile,omitempty"`
Profiles map[string]*Profile `yaml:"profiles,omitempty" json:"profiles,omitempty"`
}
type Profile struct {
AccessKey *string `yaml:"access_key,omitempty" json:"access_key,omitempty"`
SecretKey *string `yaml:"secret_key,omitempty" json:"secret_key,omitempty"`
APIURL *string `yaml:"api_url,omitempty" json:"api_url,omitempty"`
Insecure *bool `yaml:"insecure,omitempty" json:"insecure,omitempty"`
DefaultOrganizationID *string `yaml:"default_organization_id,omitempty" json:"default_organization_id,omitempty"`
DefaultProjectID *string `yaml:"default_project_id,omitempty" json:"default_project_id,omitempty"`
DefaultRegion *string `yaml:"default_region,omitempty" json:"default_region,omitempty"`
DefaultZone *string `yaml:"default_zone,omitempty" json:"default_zone,omitempty"`
SendTelemetry *bool `yaml:"send_telemetry,omitempty" json:"send_telemetry,omitempty"`
}
func (p *Profile) String() string {
p2 := *p
p2.SecretKey = hideSecretKey(p2.SecretKey)
configRaw, _ := yaml.Marshal(p2)
return string(configRaw)
}
// clone deep copy config object
func (c *Config) clone() *Config {
c2 := &Config{}
configRaw, _ := yaml.Marshal(c)
_ = yaml.Unmarshal(configRaw, c2)
return c2
}
func (c *Config) String() string {
c2 := c.clone()
c2.SecretKey = hideSecretKey(c2.SecretKey)
for _, p := range c2.Profiles {
p.SecretKey = hideSecretKey(p.SecretKey)
}
configRaw, _ := yaml.Marshal(c2)
return string(configRaw)
}
func (c *Config) IsEmpty() bool {
return c.String() == "{}\n"
}
func hideSecretKey(key *string) *string {
if key == nil {
return nil
}
newKey := auth.HideSecretKey(*key)
return &newKey
}
func unmarshalConfV2(content []byte) (*Config, error) {
var config Config
err := yaml.Unmarshal(content, &config)
if err != nil {
return nil, err
}
return &config, nil
}
// MustLoadConfig is like LoadConfig but panic instead of returning an error.
func MustLoadConfig() *Config {
c, err := LoadConfigFromPath(GetConfigPath())
if err != nil {
panic(err)
}
return c
}
// LoadConfig read the config from the default path.
func LoadConfig() (*Config, error) {
configPath := GetConfigPath()
cfg, err := LoadConfigFromPath(configPath)
// Special case if using default config path
// if config.yaml does not exist, we should try to read config.yml
if os.Getenv(ScwConfigPathEnv) == "" {
var configNotFoundError *ConfigFileNotFoundError
if err != nil && goerrors.As(err, &configNotFoundError) && strings.HasSuffix(configPath, ".yaml") {
configPath = strings.TrimSuffix(configPath, ".yaml") + ".yml"
cfgYml, errYml := LoadConfigFromPath(configPath)
// If .yml config is not found, return first error when reading .yaml
if errYml == nil || (errYml != nil && !goerrors.As(errYml, &configNotFoundError)) {
return cfgYml, errYml
}
}
}
return cfg, err
}
// LoadConfigFromPath read the config from the given path.
func LoadConfigFromPath(path string) (*Config, error) {
_, err := os.Stat(path)
if os.IsNotExist(err) {
return nil, configFileNotFound(path)
}
if err != nil {
return nil, err
}
file, err := ioutil.ReadFile(path)
if err != nil {
return nil, errors.Wrap(err, "cannot read config file")
}
confV2, err := unmarshalConfV2(file)
if err != nil {
return nil, errors.Wrap(err, "content of config file %s is invalid", path)
}
return confV2, nil
}
// GetProfile returns the profile corresponding to the given profile name.
func (c *Config) GetProfile(profileName string) (*Profile, error) {
if profileName == "" {
return nil, errors.New("profileName cannot be empty")
}
if profileName == DefaultProfileName {
return &c.Profile, nil
}
p, exist := c.Profiles[profileName]
if !exist {
return nil, errors.New("given profile %s does not exist", profileName)
}
// Merge selected profile on top of default profile
return MergeProfiles(&c.Profile, p), nil
}
// GetActiveProfile returns the active profile of the config based on the following order:
// env SCW_PROFILE > config active_profile > config root profile
func (c *Config) GetActiveProfile() (*Profile, error) {
switch {
case os.Getenv(ScwActiveProfileEnv) != "":
logger.Debugf("using active profile from env: %s=%s", ScwActiveProfileEnv, os.Getenv(ScwActiveProfileEnv))
return c.GetProfile(os.Getenv(ScwActiveProfileEnv))
case c.ActiveProfile != nil:
logger.Debugf("using active profile from config: active_profile=%s", ScwActiveProfileEnv, *c.ActiveProfile)
return c.GetProfile(*c.ActiveProfile)
default:
return &c.Profile, nil
}
}
// SaveTo will save the config to the default config path. This
// action will overwrite the previous file when it exists.
func (c *Config) Save() error {
return c.SaveTo(GetConfigPath())
}
// HumanConfig will generate a config file with documented arguments.
func (c *Config) HumanConfig() (string, error) {
tmpl, err := template.New("configuration").Parse(configFileTemplate)
if err != nil {
return "", err
}
var buf bytes.Buffer
err = tmpl.Execute(&buf, c)
if err != nil {
return "", err
}
return buf.String(), nil
}
// SaveTo will save the config to the given path. This action will
// overwrite the previous file when it exists.
func (c *Config) SaveTo(path string) error {
path = filepath.Clean(path)
// STEP 1: Render the configuration file as a file
file, err := c.HumanConfig()
if err != nil {
return err
}
// STEP 2: create config path dir in cases it didn't exist before
err = os.MkdirAll(filepath.Dir(path), 0700)
if err != nil {
return err
}
// STEP 3: write new config file
err = ioutil.WriteFile(path, []byte(file), defaultConfigPermission)
if err != nil {
return err
}
return nil
}
// MergeProfiles merges profiles in a new one. The last profile has priority.
func MergeProfiles(original *Profile, others ...*Profile) *Profile {
np := &Profile{
AccessKey: original.AccessKey,
SecretKey: original.SecretKey,
APIURL: original.APIURL,
Insecure: original.Insecure,
DefaultOrganizationID: original.DefaultOrganizationID,
DefaultProjectID: original.DefaultProjectID,
DefaultRegion: original.DefaultRegion,
DefaultZone: original.DefaultZone,
SendTelemetry: original.SendTelemetry,
}
for _, other := range others {
if other.AccessKey != nil {
np.AccessKey = other.AccessKey
}
if other.SecretKey != nil {
np.SecretKey = other.SecretKey
}
if other.APIURL != nil {
np.APIURL = other.APIURL
}
if other.Insecure != nil {
np.Insecure = other.Insecure
}
if other.DefaultOrganizationID != nil {
np.DefaultOrganizationID = other.DefaultOrganizationID
}
if other.DefaultProjectID != nil {
np.DefaultProjectID = other.DefaultProjectID
}
if other.DefaultRegion != nil {
np.DefaultRegion = other.DefaultRegion
}
if other.DefaultZone != nil {
np.DefaultZone = other.DefaultZone
}
if other.SendTelemetry != nil {
np.SendTelemetry = other.SendTelemetry
}
}
return np
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/config_test.go 0000664 0000000 0000000 00000071716 14563666056 0025721 0 ustar 00root root 0000000 0000000 package scw
import (
"io/ioutil"
"os"
"path/filepath"
"strings"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
"github.com/scaleway/scaleway-sdk-go/logger"
)
const emptyFile = ""
// v2 config
var (
v2ValidAccessKey2 = "SCW234567890ABCDEFGH"
v2ValidSecretKey2 = "6f6e6574-6f72-756c-6c74-68656d616c6c" // hint: | xxd -ps -r
v2ValidAPIURL2 = "api-fr-par.scaleway.com"
v2ValidInsecure2 = "true"
v2ValidSendTelemetry2 = "true"
v2ValidDefaultOrganizationID2 = "6d6f7264-6f72-6772-6561-74616761696e" // hint: | xxd -ps -r
v2ValidDefaultProjectID2 = "6d6f7264-6f72-6772-6561-74616761696f"
v2ValidDefaultRegion2 = string(RegionFrPar)
v2ValidDefaultZone2 = string(ZoneFrPar2)
v2ValidAccessKey = "SCW1234567890ABCDEFG"
v2ValidSecretKey = "7363616c-6577-6573-6862-6f7579616161" // hint: | xxd -ps -r
v2ValidAPIURL = "api.scaleway.com"
v2ValidInsecure = "false"
v2ValidSendTelemetry = "true"
v2ValidDefaultOrganizationID = "6170692e-7363-616c-6577-61792e636f6d" // hint: | xxd -ps -r
v2ValidDefaultProjectID = "6170692e-7363-616c-6577-61792e636f6e"
v2ValidDefaultRegion = string(RegionNlAms)
v2ValidDefaultZone = string(ZoneNlAms1)
v2ValidProfile = "flantier"
v2InvalidAccessKey = "invalid"
v2InvalidSecretKey = "invalid"
v2InvalidDefaultOrganizationID = "invalid"
v2InvalidDefaultProjectID = "invalid"
v2InvalidDefaultRegion = "invalid"
v2InvalidDefaultZone = "invalid"
v2SimpleValidConfig = &Config{
Profile: Profile{
AccessKey: &v2ValidAccessKey,
SecretKey: &v2ValidSecretKey,
DefaultOrganizationID: &v2ValidDefaultOrganizationID,
DefaultProjectID: &v2ValidDefaultProjectID,
DefaultRegion: &v2ValidDefaultRegion,
},
}
v2PartialValidConfigFile = `
access_key: ` + v2ValidAccessKey + `
secret_key: ` + v2ValidSecretKey + `
api_url: ` + v2ValidAPIURL + `
insecure: ` + v2ValidInsecure + `
default_organization_id: ` + v2ValidDefaultOrganizationID + `
default_project_id: ` + v2ValidDefaultProjectID + `
default_region: ` + v2ValidDefaultRegion + `
default_zone: ` + v2ValidDefaultZone
v2CompleteValidConfigFile = v2PartialValidConfigFile + `
profiles:
` + v2ValidProfile + `:
access_key: ` + v2ValidAccessKey2 + `
secret_key: ` + v2ValidSecretKey2 + `
api_url: ` + v2ValidAPIURL2 + `
insecure: ` + v2ValidInsecure2 + `
send_telemetry: ` + v2ValidSendTelemetry2 + `
default_organization_id: ` + v2ValidDefaultOrganizationID2 + `
default_project_id: ` + v2ValidDefaultProjectID2 + `
default_region: ` + v2ValidDefaultRegion2 + `
default_zone: ` + v2ValidDefaultZone2 + `
`
v2CompleteValidConfigWithActiveProfileFile = `
access_key: ` + v2ValidAccessKey + `
secret_key: ` + v2ValidSecretKey + `
api_url: ` + v2ValidAPIURL + `
insecure: ` + v2ValidInsecure + `
send_telemetry: ` + v2ValidSendTelemetry2 + `
default_organization_id: ` + v2ValidDefaultOrganizationID + `
default_project_id: ` + v2ValidDefaultProjectID + `
default_region: ` + v2ValidDefaultRegion + `
default_zone: ` + v2ValidDefaultZone + `
active_profile: ` + v2ValidProfile + `
profiles:
` + v2ValidProfile + `:
access_key: ` + v2ValidAccessKey2 + `
secret_key: ` + v2ValidSecretKey2 + `
api_url: ` + v2ValidAPIURL2 + `
insecure: ` + v2ValidInsecure2 + `
default_organization_id: ` + v2ValidDefaultOrganizationID2 + `
default_project_id: ` + v2ValidDefaultProjectID2 + `
default_region: ` + v2ValidDefaultRegion2 + `
default_zone: ` + v2ValidDefaultZone2 + `
`
v2MixedValidConfigWithActiveProfileFile = `
access_key: ` + v2ValidAccessKey + `
secret_key: ` + v2ValidSecretKey + `
api_url: ` + v2ValidAPIURL + `
insecure: ` + v2ValidInsecure + `
send_telemetry: ` + v2ValidSendTelemetry + `
default_organization_id: ` + v2ValidDefaultOrganizationID + `
default_project_id: ` + v2ValidDefaultProjectID + `
default_region: ` + v2ValidDefaultRegion + `
default_zone: ` + v2ValidDefaultZone + `
active_profile: ` + v2ValidProfile + `
profiles:
` + v2ValidProfile + `:
access_key: ` + v2ValidAccessKey2 + `
secret_key: ` + v2ValidSecretKey2 + `
`
v2SimpleValidConfigFile = `
access_key: ` + v2ValidAccessKey + `
secret_key: ` + v2ValidSecretKey + `
default_organization_id: ` + v2ValidDefaultOrganizationID + `
default_project_id: ` + v2ValidDefaultProjectID + `
default_region: ` + v2ValidDefaultRegion + `
`
v2SimpleInvalidConfigFile = `insecure: "bool""`
v2SimpleConfigFileWithInvalidProfile = `active_profile: flantier`
)
// TestSaveConfig tests config write the correct values in the config file
func TestSaveConfig(t *testing.T) {
tests := []struct {
name string
env map[string]string
files map[string]string
config *Config
funcUpdateConfig func(*Config)
expectedFiles map[string]string
}{
{
name: "Custom-path config",
env: map[string]string{
ScwConfigPathEnv: "{HOME}/valid1/test.conf",
},
files: map[string]string{
"valid1/test.conf": emptyFile,
},
config: &Config{
Profile: Profile{
AccessKey: s(v2ValidAccessKey),
SecretKey: s(v2ValidSecretKey),
DefaultOrganizationID: s(v2ValidDefaultOrganizationID),
DefaultProjectID: s(v2ValidDefaultProjectID),
DefaultRegion: s(v2ValidDefaultRegion),
},
},
expectedFiles: map[string]string{
"valid1/test.conf": v2SimpleValidConfigFile,
},
},
{
name: "Default config path",
env: map[string]string{
"HOME": "{HOME}",
},
config: &Config{
Profile: Profile{
AccessKey: s(v2ValidAccessKey),
SecretKey: s(v2ValidSecretKey),
DefaultOrganizationID: s(v2ValidDefaultOrganizationID),
DefaultProjectID: s(v2ValidDefaultProjectID),
DefaultRegion: s(v2ValidDefaultRegion),
},
},
expectedFiles: map[string]string{
".config/scw/config.yaml": v2SimpleValidConfigFile,
},
},
{
name: "Add zone only",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2SimpleValidConfigFile,
},
config: &Config{},
funcUpdateConfig: func(c *Config) {
*c = *MustLoadConfig()
c.DefaultZone = s(v2ValidDefaultZone)
},
expectedFiles: map[string]string{
".config/scw/config.yaml": v2SimpleValidConfigFile + "default_zone: " + v2ValidDefaultZone + "\n",
},
},
{
name: "Add new profile",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2PartialValidConfigFile,
},
config: &Config{},
funcUpdateConfig: func(c *Config) {
*c = *MustLoadConfig()
c.Profiles = map[string]*Profile{v2ValidProfile: {
AccessKey: s(v2ValidAccessKey2),
SecretKey: s(v2ValidSecretKey2),
APIURL: s(v2ValidAPIURL2),
Insecure: b(true),
DefaultOrganizationID: s(v2ValidDefaultOrganizationID2),
DefaultProjectID: s(v2ValidDefaultProjectID2),
DefaultRegion: s(v2ValidDefaultRegion2),
DefaultZone: s(v2ValidDefaultZone2),
}}
},
expectedFiles: map[string]string{
".config/scw/config.yaml": v2CompleteValidConfigFile,
},
},
}
// create home dir
dir := initEnv(t)
// delete home dir and reset env variables
defer resetEnv(t, os.Environ(), dir)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
// set up env and config file(s)
setEnv(t, test.env, test.files, dir)
// remove config file(s)
defer cleanEnv(t, test.files, dir)
defer cleanEnv(t, test.expectedFiles, dir)
if test.funcUpdateConfig != nil {
test.funcUpdateConfig(test.config)
}
testhelpers.AssertNoError(t, test.config.Save())
// test expected files
for fileName := range test.expectedFiles {
expectedContent, err := test.config.HumanConfig()
testhelpers.AssertNoError(t, err)
content, err := ioutil.ReadFile(filepath.Join(dir, fileName))
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, expectedContent, string(content))
}
})
}
}
// TestLoadConfig tests config getters return correct values
func TestLoadProfileAndActiveProfile(t *testing.T) {
tests := []struct {
name string
env map[string]string
files map[string]string
expectedError string
expectedAccessKey *string
expectedSecretKey *string
expectedAPIURL *string
expectedInsecure *bool
expectedSendTelemetry *bool
expectedDefaultOrganizationID *string
expectedDefaultProjectID *string
expectedDefaultRegion *string
expectedDefaultZone *string
}{
// no env variables
{
name: "No config without home dir",
expectedError: "scaleway-sdk-go: cannot read config file: read .: is a directory",
},
{
name: "No config",
expectedError: "scaleway-sdk-go: cannot read config file {HOME}/.config/scw/config.yaml: no such file or directory",
env: map[string]string{
"HOME": "{HOME}",
},
},
{
name: "Custom-path config is empty", // custom config path
env: map[string]string{
ScwConfigPathEnv: "{HOME}/valid1/test.conf",
},
files: map[string]string{
"valid1/test.conf": emptyFile,
},
},
{
name: "Custom-path config with valid V2",
env: map[string]string{
ScwConfigPathEnv: "{HOME}/valid3/test.conf",
},
files: map[string]string{
"valid3/test.conf": v2SimpleValidConfigFile,
},
expectedAccessKey: s(v2ValidAccessKey),
expectedSecretKey: s(v2ValidSecretKey),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: s(v2ValidDefaultRegion),
},
{
name: "Simple config with valid V2", // default config path
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2SimpleValidConfigFile,
},
expectedAccessKey: s(v2ValidAccessKey),
expectedSecretKey: s(v2ValidSecretKey),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: s(v2ValidDefaultRegion),
},
{
name: "Complete config",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2CompleteValidConfigFile,
},
expectedAccessKey: s(v2ValidAccessKey),
expectedSecretKey: s(v2ValidSecretKey),
expectedAPIURL: s(v2ValidAPIURL),
expectedInsecure: b(false),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: s(v2ValidDefaultRegion),
expectedDefaultZone: s(v2ValidDefaultZone),
},
{
name: "Complete config with active profile",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2CompleteValidConfigWithActiveProfileFile,
},
expectedAccessKey: s(v2ValidAccessKey2),
expectedSecretKey: s(v2ValidSecretKey2),
expectedAPIURL: s(v2ValidAPIURL2),
expectedInsecure: b(true),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID2),
expectedDefaultProjectID: s(v2ValidDefaultProjectID2),
expectedDefaultRegion: s(v2ValidDefaultRegion2),
expectedDefaultZone: s(v2ValidDefaultZone2),
expectedSendTelemetry: b(true),
},
{
name: "Mixed config with active profile",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2MixedValidConfigWithActiveProfileFile,
},
expectedAccessKey: s(v2ValidAccessKey2),
expectedSecretKey: s(v2ValidSecretKey2),
expectedAPIURL: s(v2ValidAPIURL),
expectedInsecure: b(false),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: s(v2ValidDefaultRegion),
expectedDefaultZone: s(v2ValidDefaultZone),
expectedSendTelemetry: b(true),
},
{
name: "Complete config with active profile env variable",
env: map[string]string{
"HOME": "{HOME}",
ScwActiveProfileEnv: v2ValidProfile,
},
files: map[string]string{
".config/scw/config.yaml": v2CompleteValidConfigFile,
},
expectedAccessKey: s(v2ValidAccessKey2),
expectedSecretKey: s(v2ValidSecretKey2),
expectedAPIURL: s(v2ValidAPIURL2),
expectedInsecure: b(true),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID2),
expectedDefaultProjectID: s(v2ValidDefaultProjectID2),
expectedDefaultRegion: s(v2ValidDefaultRegion2),
expectedDefaultZone: s(v2ValidDefaultZone2),
},
// Config file config.yaml and config.yml
{
name: "Read config.yml",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yml": v2SimpleValidConfigFile,
},
expectedAccessKey: s(v2ValidAccessKey),
expectedSecretKey: s(v2ValidSecretKey),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: s(v2ValidDefaultRegion),
},
}
// create home dir
dir := initEnv(t)
// delete home dir and reset env variables
defer resetEnv(t, os.Environ(), dir)
logger.EnableDebugMode()
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
// set up env and config file(s)
setEnv(t, test.env, test.files, dir)
test.expectedError = strings.Replace(test.expectedError, "{HOME}", dir, -1)
// remove config file(s)
defer cleanEnv(t, test.files, dir)
config, err := LoadConfig()
if test.expectedError == "" {
testhelpers.AssertNoError(t, err)
p, err := config.GetActiveProfile()
testhelpers.AssertNoError(t, err)
// assert getters
testhelpers.Equals(t, test.expectedAccessKey, p.AccessKey)
testhelpers.Equals(t, test.expectedSecretKey, p.SecretKey)
testhelpers.Equals(t, test.expectedAPIURL, p.APIURL)
testhelpers.Equals(t, test.expectedDefaultOrganizationID, p.DefaultOrganizationID)
testhelpers.Equals(t, test.expectedDefaultProjectID, p.DefaultProjectID)
testhelpers.Equals(t, test.expectedDefaultRegion, p.DefaultRegion)
testhelpers.Equals(t, test.expectedDefaultZone, p.DefaultZone)
testhelpers.Equals(t, test.expectedInsecure, p.Insecure)
testhelpers.Equals(t, test.expectedSendTelemetry, config.SendTelemetry)
} else {
testhelpers.Equals(t, test.expectedError, err.Error())
}
})
}
}
func TestConfigString(t *testing.T) {
var c = &Config{
Profile: Profile{
AccessKey: s(v2ValidAccessKey),
SecretKey: s(v2ValidSecretKey),
SendTelemetry: b(true),
},
ActiveProfile: s(v2ValidProfile),
Profiles: map[string]*Profile{
v2ValidProfile: {
AccessKey: s(v2ValidAccessKey2),
SecretKey: s(v2ValidSecretKey2),
},
},
}
testhelpers.Equals(t, `access_key: SCW1234567890ABCDEFG
secret_key: 7363616c-xxxx-xxxx-xxxx-xxxxxxxxxxxx
send_telemetry: true
active_profile: flantier
profiles:
flantier:
access_key: SCW234567890ABCDEFGH
secret_key: 6f6e6574-xxxx-xxxx-xxxx-xxxxxxxxxxxx
`, c.String())
testhelpers.Equals(t, v2ValidSecretKey, *c.SecretKey)
p, err := c.GetActiveProfile()
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, `access_key: SCW234567890ABCDEFGH
secret_key: 6f6e6574-xxxx-xxxx-xxxx-xxxxxxxxxxxx
send_telemetry: true
`, p.String())
testhelpers.Equals(t, v2ValidSecretKey2, *p.SecretKey)
}
func TestMergeProfiles(t *testing.T) {
p1 := &Profile{
AccessKey: StringPtr("1"),
SecretKey: StringPtr("1"),
}
p2 := &Profile{
AccessKey: StringPtr("2"),
Insecure: BoolPtr(true),
}
p3 := &Profile{
Insecure: BoolPtr(false),
DefaultZone: StringPtr(string(ZoneFrPar1)),
}
act := MergeProfiles(p1, p2, p3)
exp := &Profile{
AccessKey: StringPtr("2"),
SecretKey: StringPtr("1"),
Insecure: BoolPtr(false),
DefaultZone: StringPtr(string(ZoneFrPar1)),
}
testhelpers.Equals(t, exp, act)
}
func initEnv(t *testing.T) string {
dir, err := ioutil.TempDir("", "home")
if err != nil {
t.Fatal(err)
}
return dir
}
func cleanEnv(t *testing.T, files map[string]string, homeDir string) {
for path := range files {
testhelpers.AssertNoError(t, os.RemoveAll(filepath.Join(homeDir, path)))
}
}
func setEnv(t *testing.T, env, files map[string]string, homeDir string) {
os.Clearenv()
for key, value := range env {
value = strings.Replace(value, "{HOME}", homeDir, -1)
testhelpers.AssertNoError(t, os.Setenv(key, value))
}
for path, content := range files {
targetPath := filepath.Join(homeDir, path)
testhelpers.AssertNoError(t, os.MkdirAll(filepath.Dir(targetPath), 0700))
testhelpers.AssertNoError(t, ioutil.WriteFile(targetPath, []byte(content), defaultConfigPermission))
}
}
// function taken from https://golang.org/src/os/env_test.go
func resetEnv(t *testing.T, origEnv []string, homeDir string) {
testhelpers.AssertNoError(t, os.RemoveAll(homeDir))
for _, pair := range origEnv {
// Environment variables on Windows can begin with =
// https://blogs.msdn.com/b/oldnewthing/archive/2010/05/06/10008132.aspx
i := strings.Index(pair[1:], "=") + 1
if err := os.Setenv(pair[:i], pair[i+1:]); err != nil {
t.Errorf("Setenv(%q, %q) failed during reset: %v", pair[:i], pair[i+1:], err)
}
}
}
func s(value string) *string {
return &value
}
func r(value Region) *Region {
return &value
}
func z(value Zone) *Zone {
return &value
}
func b(value bool) *bool {
return &value
}
func TestConfig_ConfigFile(t *testing.T) {
type testCase struct {
config *Config
result string
}
run := func(c *testCase) func(t *testing.T) {
return func(t *testing.T) {
config, err := c.config.HumanConfig()
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, c.result, config)
loaded, err2 := unmarshalConfV2([]byte(config))
testhelpers.AssertNoError(t, err2)
testhelpers.Equals(t, c.config, loaded)
}
}
t.Run("empty", run(&testCase{
config: &Config{},
result: `# Scaleway configuration file
# https://github.com/scaleway/scaleway-sdk-go/tree/master/scw#scaleway-config
# This configuration file can be used with:
# - Scaleway SDK Go (https://github.com/scaleway/scaleway-sdk-go)
# - Scaleway CLI (>2.0.0) (https://github.com/scaleway/scaleway-cli)
# - Scaleway Terraform Provider (https://www.terraform.io/docs/providers/scaleway/index.html)
# You need an access key and a secret key to connect to Scaleway API.
# Generate your token at the following address: https://console.scaleway.com/iam/api-keys
# An access key is a secret key identifier.
# access_key: SCW11111111111111111
# The secret key is the value that can be used to authenticate against the API (the value used in X-Auth-Token HTTP-header).
# The secret key MUST remain secret and not given to anyone or published online.
# secret_key: 11111111-1111-1111-1111-111111111111
# Your organization ID is the identifier of your account inside Scaleway infrastructure.
# default_organization_id: 11111111-1111-1111-1111-111111111111
# Your project ID is the identifier of the project your resources are attached to (beta).
# default_project_id: 11111111-1111-1111-1111-111111111111
# A region is represented as a geographical area such as France (Paris) or the Netherlands (Amsterdam).
# It can contain multiple availability zones.
# Example of region: fr-par, nl-ams
# default_region: fr-par
# A region can be split into many availability zones (AZ).
# Latency between multiple AZ of the same region are low as they have a common network layer.
# Example of zones: fr-par-1, nl-ams-1
# default_zone: fr-par-1
# APIURL overrides the API URL of the Scaleway API to the given URL.
# Change that if you want to direct requests to a different endpoint.
# api_url: https://api.scaleway.com
# Insecure enables insecure transport on the client.
# Default to false
# insecure: false
# A configuration is a named set of Scaleway properties.
# Starting off with a Scaleway SDK or Scaleway CLI, you’ll work with a single configuration named default.
# You can set properties of the default profile by running either scw init or scw config set.
# This single default configuration is suitable for most use cases.
# active_profile: myProfile
# To improve the Scaleway CLI we rely on diagnostic and usage data.
# Sending such data is optional and can be disable at any time by setting send_telemetry variable to false.
# send_telemetry: false
# To work with multiple projects or authorization accounts, you can set up multiple configurations with scw config configurations create and switch among them accordingly.
# You can use a profile by either:
# - Define the profile you want to use as the SCW_PROFILE environment variable
# - Use the GetActiveProfile() function in the SDK
# - Use the --profile flag with the CLI
# You can define a profile using the following syntax:
# profiles:
# myProfile:
# access_key: 11111111-1111-1111-1111-111111111111
# secret_key: 11111111-1111-1111-1111-111111111111
# default_organization_id: 11111111-1111-1111-1111-111111111111
# default_project_id: 11111111-1111-1111-1111-111111111111
# default_zone: fr-par-1
# default_region: fr-par
# api_url: https://api.scaleway.com
# insecure: false
`,
}))
t.Run("partial", run(&testCase{
config: &Config{
Profile: Profile{
AccessKey: s(v2ValidAccessKey),
}},
result: `# Scaleway configuration file
# https://github.com/scaleway/scaleway-sdk-go/tree/master/scw#scaleway-config
# This configuration file can be used with:
# - Scaleway SDK Go (https://github.com/scaleway/scaleway-sdk-go)
# - Scaleway CLI (>2.0.0) (https://github.com/scaleway/scaleway-cli)
# - Scaleway Terraform Provider (https://www.terraform.io/docs/providers/scaleway/index.html)
# You need an access key and a secret key to connect to Scaleway API.
# Generate your token at the following address: https://console.scaleway.com/iam/api-keys
# An access key is a secret key identifier.
access_key: SCW1234567890ABCDEFG
# The secret key is the value that can be used to authenticate against the API (the value used in X-Auth-Token HTTP-header).
# The secret key MUST remain secret and not given to anyone or published online.
# secret_key: 11111111-1111-1111-1111-111111111111
# Your organization ID is the identifier of your account inside Scaleway infrastructure.
# default_organization_id: 11111111-1111-1111-1111-111111111111
# Your project ID is the identifier of the project your resources are attached to (beta).
# default_project_id: 11111111-1111-1111-1111-111111111111
# A region is represented as a geographical area such as France (Paris) or the Netherlands (Amsterdam).
# It can contain multiple availability zones.
# Example of region: fr-par, nl-ams
# default_region: fr-par
# A region can be split into many availability zones (AZ).
# Latency between multiple AZ of the same region are low as they have a common network layer.
# Example of zones: fr-par-1, nl-ams-1
# default_zone: fr-par-1
# APIURL overrides the API URL of the Scaleway API to the given URL.
# Change that if you want to direct requests to a different endpoint.
# api_url: https://api.scaleway.com
# Insecure enables insecure transport on the client.
# Default to false
# insecure: false
# A configuration is a named set of Scaleway properties.
# Starting off with a Scaleway SDK or Scaleway CLI, you’ll work with a single configuration named default.
# You can set properties of the default profile by running either scw init or scw config set.
# This single default configuration is suitable for most use cases.
# active_profile: myProfile
# To improve the Scaleway CLI we rely on diagnostic and usage data.
# Sending such data is optional and can be disable at any time by setting send_telemetry variable to false.
# send_telemetry: false
# To work with multiple projects or authorization accounts, you can set up multiple configurations with scw config configurations create and switch among them accordingly.
# You can use a profile by either:
# - Define the profile you want to use as the SCW_PROFILE environment variable
# - Use the GetActiveProfile() function in the SDK
# - Use the --profile flag with the CLI
# You can define a profile using the following syntax:
# profiles:
# myProfile:
# access_key: 11111111-1111-1111-1111-111111111111
# secret_key: 11111111-1111-1111-1111-111111111111
# default_organization_id: 11111111-1111-1111-1111-111111111111
# default_project_id: 11111111-1111-1111-1111-111111111111
# default_zone: fr-par-1
# default_region: fr-par
# api_url: https://api.scaleway.com
# insecure: false
`,
}))
t.Run("full", run(&testCase{
config: &Config{
Profile: Profile{
AccessKey: s(v2ValidAccessKey),
SecretKey: s(v2ValidSecretKey),
SendTelemetry: b(true),
},
ActiveProfile: s(v2ValidProfile),
Profiles: map[string]*Profile{
"profile1": {
AccessKey: s(v2ValidAccessKey2),
SecretKey: s(v2ValidSecretKey2),
},
"profile2": {
AccessKey: s(v2ValidAccessKey2),
SecretKey: s(v2ValidSecretKey2),
},
},
},
result: `# Scaleway configuration file
# https://github.com/scaleway/scaleway-sdk-go/tree/master/scw#scaleway-config
# This configuration file can be used with:
# - Scaleway SDK Go (https://github.com/scaleway/scaleway-sdk-go)
# - Scaleway CLI (>2.0.0) (https://github.com/scaleway/scaleway-cli)
# - Scaleway Terraform Provider (https://www.terraform.io/docs/providers/scaleway/index.html)
# You need an access key and a secret key to connect to Scaleway API.
# Generate your token at the following address: https://console.scaleway.com/iam/api-keys
# An access key is a secret key identifier.
access_key: SCW1234567890ABCDEFG
# The secret key is the value that can be used to authenticate against the API (the value used in X-Auth-Token HTTP-header).
# The secret key MUST remain secret and not given to anyone or published online.
secret_key: 7363616c-6577-6573-6862-6f7579616161
# Your organization ID is the identifier of your account inside Scaleway infrastructure.
# default_organization_id: 11111111-1111-1111-1111-111111111111
# Your project ID is the identifier of the project your resources are attached to (beta).
# default_project_id: 11111111-1111-1111-1111-111111111111
# A region is represented as a geographical area such as France (Paris) or the Netherlands (Amsterdam).
# It can contain multiple availability zones.
# Example of region: fr-par, nl-ams
# default_region: fr-par
# A region can be split into many availability zones (AZ).
# Latency between multiple AZ of the same region are low as they have a common network layer.
# Example of zones: fr-par-1, nl-ams-1
# default_zone: fr-par-1
# APIURL overrides the API URL of the Scaleway API to the given URL.
# Change that if you want to direct requests to a different endpoint.
# api_url: https://api.scaleway.com
# Insecure enables insecure transport on the client.
# Default to false
# insecure: false
# A configuration is a named set of Scaleway properties.
# Starting off with a Scaleway SDK or Scaleway CLI, you’ll work with a single configuration named default.
# You can set properties of the default profile by running either scw init or scw config set.
# This single default configuration is suitable for most use cases.
active_profile: flantier
# To improve the Scaleway CLI we rely on diagnostic and usage data.
# Sending such data is optional and can be disable at any time by setting send_telemetry variable to false.
send_telemetry: true
# To work with multiple projects or authorization accounts, you can set up multiple configurations with scw config configurations create and switch among them accordingly.
# You can use a profile by either:
# - Define the profile you want to use as the SCW_PROFILE environment variable
# - Use the GetActiveProfile() function in the SDK
# - Use the --profile flag with the CLI
# You can define a profile using the following syntax:
profiles:
profile1:
access_key: SCW234567890ABCDEFGH
secret_key: 6f6e6574-6f72-756c-6c74-68656d616c6c
# default_organization_id: 11111111-1111-1111-1111-111111111111
# default_project_id: 11111111-1111-1111-1111-111111111111
# default_zone: fr-par-1
# default_region: fr-par
# api_url: https://api.scaleway.com
# insecure: false
profile2:
access_key: SCW234567890ABCDEFGH
secret_key: 6f6e6574-6f72-756c-6c74-68656d616c6c
# default_organization_id: 11111111-1111-1111-1111-111111111111
# default_project_id: 11111111-1111-1111-1111-111111111111
# default_zone: fr-par-1
# default_region: fr-par
# api_url: https://api.scaleway.com
# insecure: false
`,
}))
}
func TestEmptyConfig(t *testing.T) {
testhelpers.Assert(t, (&Config{}).IsEmpty(), "Config must be empty")
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/convert.go 0000664 0000000 0000000 00000007621 14563666056 0025067 0 ustar 00root root 0000000 0000000 package scw
import (
"net"
"time"
)
// StringPtr returns a pointer to the string value passed in.
func StringPtr(v string) *string {
return &v
}
// StringSlicePtr converts a slice of string values into a slice of
// string pointers
func StringSlicePtr(src []string) []*string {
dst := make([]*string, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// StringsPtr returns a pointer to the []string value passed in.
func StringsPtr(v []string) *[]string {
return &v
}
// StringsSlicePtr converts a slice of []string values into a slice of
// []string pointers
func StringsSlicePtr(src [][]string) []*[]string {
dst := make([]*[]string, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// BytesPtr returns a pointer to the []byte value passed in.
func BytesPtr(v []byte) *[]byte {
return &v
}
// BytesSlicePtr converts a slice of []byte values into a slice of
// []byte pointers
func BytesSlicePtr(src [][]byte) []*[]byte {
dst := make([]*[]byte, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// BoolPtr returns a pointer to the bool value passed in.
func BoolPtr(v bool) *bool {
return &v
}
// BoolSlicePtr converts a slice of bool values into a slice of
// bool pointers
func BoolSlicePtr(src []bool) []*bool {
dst := make([]*bool, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// Int32Ptr returns a pointer to the int32 value passed in.
func Int32Ptr(v int32) *int32 {
return &v
}
// Int32SlicePtr converts a slice of int32 values into a slice of
// int32 pointers
func Int32SlicePtr(src []int32) []*int32 {
dst := make([]*int32, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// Int64Ptr returns a pointer to the int64 value passed in.
func Int64Ptr(v int64) *int64 {
return &v
}
// Int64SlicePtr converts a slice of int64 values into a slice of
// int64 pointers
func Int64SlicePtr(src []int64) []*int64 {
dst := make([]*int64, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// Uint32Ptr returns a pointer to the uint32 value passed in.
func Uint32Ptr(v uint32) *uint32 {
return &v
}
// Uint32SlicePtr converts a slice of uint32 values into a slice of
// uint32 pointers
func Uint32SlicePtr(src []uint32) []*uint32 {
dst := make([]*uint32, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// Uint64Ptr returns a pointer to the uint64 value passed in.
func Uint64Ptr(v uint64) *uint64 {
return &v
}
// Uint64SlicePtr converts a slice of uint64 values into a slice of
// uint64 pointers
func Uint64SlicePtr(src []uint64) []*uint64 {
dst := make([]*uint64, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// Float32Ptr returns a pointer to the float32 value passed in.
func Float32Ptr(v float32) *float32 {
return &v
}
// Float32SlicePtr converts a slice of float32 values into a slice of
// float32 pointers
func Float32SlicePtr(src []float32) []*float32 {
dst := make([]*float32, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// Float64Ptr returns a pointer to the float64 value passed in.
func Float64Ptr(v float64) *float64 {
return &v
}
// Float64SlicePtr converts a slice of float64 values into a slice of
// float64 pointers
func Float64SlicePtr(src []float64) []*float64 {
dst := make([]*float64, len(src))
for i := 0; i < len(src); i++ {
dst[i] = &(src[i])
}
return dst
}
// TimeDurationPtr returns a pointer to the Duration value passed in.
func TimeDurationPtr(v time.Duration) *time.Duration {
return &v
}
// TimePtr returns a pointer to the Time value passed in.
func TimePtr(v time.Time) *time.Time {
return &v
}
// SizePtr returns a pointer to the Size value passed in.
func SizePtr(v Size) *Size {
return &v
}
// IPPtr returns a pointer to the net.IP value passed in.
func IPPtr(v net.IP) *net.IP {
return &v
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/convert_test.go 0000664 0000000 0000000 00000013704 14563666056 0026125 0 ustar 00root root 0000000 0000000 package scw
import (
"testing"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
var (
testString = "some string"
testBytes = []byte{0, 1, 2}
testBool = true
testInt32 int32 = 42
testInt64 int64 = 43
testUInt32 uint32 = 44
testUInt64 uint64 = 45
testFloat32 float32 = 46
testFloat64 float64 = 47
testDuration time.Duration = 48
testTime time.Time = time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
testSize Size = 3 * GB
)
func TestStringPtr(t *testing.T) {
pointer := StringPtr(testString)
slice := []string{testString}
sliceOfPointers := StringSlicePtr(slice)
pointerToSlice := StringsPtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testString, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testString, *sliceOfPointers[0])
// slice of value to pointer to slice of values
testhelpers.Assert(t, pointerToSlice != nil, "Pointer should have value")
testhelpers.Equals(t, slice, *pointerToSlice)
}
func TestBytesPtr(t *testing.T) {
pointer := BytesPtr(testBytes)
slice := [][]byte{testBytes}
sliceOfPointers := BytesSlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testBytes, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testBytes, *sliceOfPointers[0])
}
func TestBoolPtr(t *testing.T) {
pointer := BoolPtr(testBool)
slice := []bool{testBool}
sliceOfPointers := BoolSlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testBool, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testBool, *sliceOfPointers[0])
}
func TestInt32Ptr(t *testing.T) {
pointer := Int32Ptr(testInt32)
slice := []int32{testInt32}
sliceOfPointers := Int32SlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testInt32, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testInt32, *sliceOfPointers[0])
}
func TestInt64Ptr(t *testing.T) {
pointer := Int64Ptr(testInt64)
slice := []int64{testInt64}
sliceOfPointers := Int64SlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testInt64, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testInt64, *sliceOfPointers[0])
}
func TestUint32Ptr(t *testing.T) {
pointer := Uint32Ptr(testUInt32)
slice := []uint32{testUInt32}
sliceOfPointers := Uint32SlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testUInt32, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testUInt32, *sliceOfPointers[0])
}
func TestUint64Ptr(t *testing.T) {
pointer := Uint64Ptr(testUInt64)
slice := []uint64{testUInt64}
sliceOfPointers := Uint64SlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testUInt64, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testUInt64, *sliceOfPointers[0])
}
func TestFloat32Ptr(t *testing.T) {
pointer := Float32Ptr(testFloat32)
slice := []float32{testFloat32}
sliceOfPointers := Float32SlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testFloat32, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testFloat32, *sliceOfPointers[0])
}
func TestFloat64Ptr(t *testing.T) {
pointer := Float64Ptr(testFloat64)
slice := []float64{testFloat64}
sliceOfPointers := Float64SlicePtr(slice)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testFloat64, *pointer)
// slice of values to slice of pointers to value
testhelpers.Equals(t, 1, len(sliceOfPointers))
testhelpers.Assert(t, sliceOfPointers[0] != nil, "Pointer should have value")
testhelpers.Equals(t, testFloat64, *sliceOfPointers[0])
}
func TestDurationPtr(t *testing.T) {
pointer := TimeDurationPtr(testDuration)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testDuration, *pointer)
}
func TestTimePtr(t *testing.T) {
pointer := TimePtr(testTime)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testTime, *pointer)
}
func TestSizePtr(t *testing.T) {
pointer := SizePtr(testSize)
// value to pointer value
testhelpers.Assert(t, pointer != nil, "Pointer should have value")
testhelpers.Equals(t, testSize, *pointer)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/custom_types.go 0000664 0000000 0000000 00000025041 14563666056 0026141 0 ustar 00root root 0000000 0000000 package scw
import (
"bytes"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"net"
"strconv"
"strings"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/logger"
)
// ServiceInfo contains API metadata
// These metadata are only here for debugging. Do not rely on these values
type ServiceInfo struct {
// Name is the name of the API
Name string `json:"name"`
// Description is a human readable description for the API
Description string `json:"description"`
// Version is the version of the API
Version string `json:"version"`
// DocumentationURL is the a web url where the documentation of the API can be found
DocumentationURL *string `json:"documentation_url"`
}
// File is the structure used to receive / send a file from / to the API
type File struct {
// Name of the file
Name string `json:"name"`
// ContentType used in the HTTP header `Content-Type`
ContentType string `json:"content_type"`
// Content of the file
Content io.Reader `json:"content"`
}
func (f *File) MarshalJSON() ([]byte, error) {
buf := new(bytes.Buffer)
if f.Content != nil {
_, err := io.Copy(buf, f.Content)
if err != nil {
return nil, err
}
}
tmpFile := struct {
Name string `json:"name"`
ContentType string `json:"content_type"`
Content string `json:"content"`
}{
Name: f.Name,
ContentType: f.ContentType,
Content: buf.String(),
}
return json.Marshal(tmpFile)
}
func (f *File) UnmarshalJSON(b []byte) error {
type file File
var tmpFile struct {
file
Content []byte `json:"content"`
}
err := json.Unmarshal(b, &tmpFile)
if err != nil {
return err
}
tmpFile.file.Content = bytes.NewReader(tmpFile.Content)
*f = File(tmpFile.file)
return nil
}
// Money represents an amount of money with its currency type.
type Money struct {
// CurrencyCode is the 3-letter currency code defined in ISO 4217.
CurrencyCode string `json:"currency_code"`
// Units is the whole units of the amount.
// For example if `currencyCode` is `"USD"`, then 1 unit is one US dollar.
Units int64 `json:"units"`
// Nanos is the number of nano (10^-9) units of the amount.
// The value must be between -999,999,999 and +999,999,999 inclusive.
// If `units` is positive, `nanos` must be positive or zero.
// If `units` is zero, `nanos` can be positive, zero, or negative.
// If `units` is negative, `nanos` must be negative or zero.
// For example $-1.75 is represented as `units`=-1 and `nanos`=-750,000,000.
Nanos int32 `json:"nanos"`
}
// NewMoneyFromFloat converts a float with currency to a Money.
//
// value: The float value.
// currencyCode: The 3-letter currency code defined in ISO 4217.
// precision: The number of digits after the decimal point used to parse the nanos part of the value.
//
// Examples:
// - (value = 1.3333, precision = 2) => Money{Units = 1, Nanos = 330000000}
// - (value = 1.123456789, precision = 9) => Money{Units = 1, Nanos = 123456789}
func NewMoneyFromFloat(value float64, currencyCode string, precision int) *Money {
if precision > 9 {
panic(fmt.Errorf("max precision is 9"))
}
strValue := strconv.FormatFloat(value, 'f', precision, 64)
units, nanos, err := splitFloatString(strValue)
if err != nil {
panic(err)
}
return &Money{
CurrencyCode: currencyCode,
Units: units,
Nanos: nanos,
}
}
// String returns the string representation of Money.
func (m Money) String() string {
currencySignsByCodes := map[string]string{
"EUR": "€",
"USD": "$",
}
currencySign, currencySignFound := currencySignsByCodes[m.CurrencyCode]
if !currencySignFound {
logger.Debugf("%s currency code is not supported", m.CurrencyCode)
currencySign = m.CurrencyCode
}
cents := fmt.Sprintf("%09d", m.Nanos)
cents = cents[:2] + strings.TrimRight(cents[2:], "0")
return fmt.Sprintf("%s %d.%s", currencySign, m.Units, cents)
}
// ToFloat converts a Money object to a float.
func (m Money) ToFloat() float64 {
return float64(m.Units) + float64(m.Nanos)/1e9
}
// Size represents a size in bytes.
type Size uint64
const (
B Size = 1
KB = 1000 * B
MB = 1000 * KB
GB = 1000 * MB
TB = 1000 * GB
PB = 1000 * TB
)
// String returns the string representation of a Size.
func (s Size) String() string {
return fmt.Sprintf("%d", s)
}
// TimeSeries represents a time series that could be used for graph purposes.
type TimeSeries struct {
// Name of the metric.
Name string `json:"name"`
// Points contains all the points that composed the series.
Points []*TimeSeriesPoint `json:"points"`
// Metadata contains some string metadata related to a metric.
Metadata map[string]string `json:"metadata"`
}
// TimeSeriesPoint represents a point of a time series.
type TimeSeriesPoint struct {
Timestamp time.Time
Value float32
}
func (tsp TimeSeriesPoint) MarshalJSON() ([]byte, error) {
timestamp := tsp.Timestamp.Format(time.RFC3339)
value, err := json.Marshal(tsp.Value)
if err != nil {
return nil, err
}
return []byte(`["` + timestamp + `",` + string(value) + "]"), nil
}
func (tsp *TimeSeriesPoint) UnmarshalJSON(b []byte) error {
point := [2]interface{}{}
err := json.Unmarshal(b, &point)
if err != nil {
return err
}
if len(point) != 2 {
return fmt.Errorf("invalid point array")
}
strTimestamp, isStrTimestamp := point[0].(string)
if !isStrTimestamp {
return fmt.Errorf("%s timestamp is not a string in RFC 3339 format", point[0])
}
timestamp, err := time.Parse(time.RFC3339, strTimestamp)
if err != nil {
return fmt.Errorf("%s timestamp is not in RFC 3339 format", point[0])
}
tsp.Timestamp = timestamp
// By default, JSON unmarshal a float in float64 but the TimeSeriesPoint is a float32 value.
value, isValue := point[1].(float64)
if !isValue {
return fmt.Errorf("%s is not a valid float32 value", point[1])
}
tsp.Value = float32(value)
return nil
}
// IPNet inherits net.IPNet and represents an IP network.
type IPNet struct {
net.IPNet
}
func (n IPNet) MarshalJSON() ([]byte, error) {
value := n.String()
if value == "" {
value = ""
}
return []byte(`"` + value + `"`), nil
}
func (n *IPNet) UnmarshalJSON(b []byte) error {
var str string
err := json.Unmarshal(b, &str)
if err != nil {
return err
}
if str == "" {
*n = IPNet{}
return nil
}
switch ip := net.ParseIP(str); {
case ip.To4() != nil:
str += "/32"
case ip.To16() != nil:
str += "/128"
}
ip, value, err := net.ParseCIDR(str)
if err != nil {
return err
}
value.IP = ip
n.IPNet = *value
return nil
}
// Duration represents a signed, fixed-length span of time represented as a
// count of seconds and fractions of seconds at nanosecond resolution. It is
// independent of any calendar and concepts like "day" or "month". It is related
// to Timestamp in that the difference between two Timestamp values is a Duration
// and it can be added or subtracted from a Timestamp.
// Range is approximately +-10,000 years.
type Duration struct {
Seconds int64
Nanos int32
}
func (d *Duration) ToTimeDuration() *time.Duration {
if d == nil {
return nil
}
timeDuration := time.Duration(d.Nanos) + time.Duration(d.Seconds)*time.Second
return &timeDuration
}
func (d Duration) MarshalJSON() ([]byte, error) {
nanos := d.Nanos
if nanos < 0 {
nanos = -nanos
}
return []byte(`"` + fmt.Sprintf("%d.%09d", d.Seconds, nanos) + `s"`), nil
}
func (d *Duration) UnmarshalJSON(b []byte) error {
if string(b) == "null" {
return nil
}
var str string
err := json.Unmarshal(b, &str)
if err != nil {
return err
}
if str == "" {
*d = Duration{}
return nil
}
seconds, nanos, err := splitFloatString(strings.TrimRight(str, "s"))
if err != nil {
return err
}
*d = Duration{
Seconds: seconds,
Nanos: nanos,
}
return nil
}
func NewDurationFromTimeDuration(t time.Duration) *Duration {
duration := Duration{
Seconds: int64(t.Seconds()),
}
duration.Nanos = int32(t.Nanoseconds() - (time.Duration(duration.Seconds) * time.Second).Nanoseconds())
return &duration
}
// splitFloatString splits a float represented in a string, and returns its units (left-coma part) and nanos (right-coma part).
// E.g.:
// "3" ==> units = 3 | nanos = 0
// "3.14" ==> units = 3 | nanos = 14*1e7
// "-3.14" ==> units = -3 | nanos = -14*1e7
func splitFloatString(input string) (units int64, nanos int32, err error) {
parts := strings.SplitN(input, ".", 2)
// parse units as int64
units, err = strconv.ParseInt(parts[0], 10, 64)
if err != nil {
return 0, 0, errors.Wrap(err, "invalid units")
}
// handle nanos
if len(parts) == 2 {
// add leading zeros
strNanos := parts[1] + "000000000"[len(parts[1]):]
// parse nanos as int32
n, err := strconv.ParseUint(strNanos, 10, 32)
if err != nil {
return 0, 0, errors.Wrap(err, "invalid nanos")
}
nanos = int32(n)
}
if units < 0 {
nanos = -nanos
}
return units, nanos, nil
}
// JSONObject represent any JSON object. See struct.proto.
// It will be marshaled into a json string.
// This type can be used just like any other map.
//
// Example:
//
// values := scw.JSONValue{
// "Foo": "Bar",
// }
// values["Baz"] = "Qux"
type JSONObject map[string]interface{}
// EscapeMode is the mode that should be use for escaping a value
type EscapeMode uint
// The modes for escaping a value before it is marshaled, and unmarshalled.
const (
NoEscape EscapeMode = iota
Base64Escape
QuotedEscape
)
// DecodeJSONObject will attempt to decode the string input as a JSONValue.
// Optionally decoding base64 the value first before JSON unmarshalling.
//
// Will panic if the escape mode is unknown.
func DecodeJSONObject(v string, escape EscapeMode) (JSONObject, error) {
var b []byte
var err error
switch escape {
case NoEscape:
b = []byte(v)
case Base64Escape:
b, err = base64.StdEncoding.DecodeString(v)
case QuotedEscape:
var u string
u, err = strconv.Unquote(v)
b = []byte(u)
default:
panic(fmt.Sprintf("DecodeJSONObject called with unknown EscapeMode, %v", escape))
}
if err != nil {
return nil, err
}
m := JSONObject{}
err = json.Unmarshal(b, &m)
if err != nil {
return nil, err
}
return m, nil
}
// EncodeJSONObject marshals the value into a JSON string, and optionally base64
// encodes the string before returning it.
//
// Will panic if the escape mode is unknown.
func EncodeJSONObject(v JSONObject, escape EscapeMode) (string, error) {
b, err := json.Marshal(v)
if err != nil {
return "", err
}
switch escape {
case NoEscape:
return string(b), nil
case Base64Escape:
return base64.StdEncoding.EncodeToString(b), nil
case QuotedEscape:
return strconv.Quote(string(b)), nil
}
panic(fmt.Sprintf("EncodeJSONObject called with unknown EscapeMode, %v", escape))
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/custom_types_test.go 0000664 0000000 0000000 00000042631 14563666056 0027204 0 ustar 00root root 0000000 0000000 package scw
import (
"encoding/json"
"fmt"
"io"
"net"
"strings"
"testing"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
func TestMoney_NewMoneyFromFloat(t *testing.T) {
cases := []struct {
value float64
currency string
precision int
want *Money
}{
{
value: 0.0,
currency: "EUR",
precision: 0,
want: &Money{
CurrencyCode: "EUR",
Units: 0,
Nanos: 0,
},
},
{
value: 1.0,
currency: "EUR",
precision: 3,
want: &Money{
CurrencyCode: "EUR",
Units: 1,
Nanos: 0,
},
},
{
value: 1.3,
currency: "EUR",
precision: 3,
want: &Money{
CurrencyCode: "EUR",
Units: 1,
Nanos: 300000000,
},
},
{
value: 1.333,
currency: "EUR",
precision: 2,
want: &Money{
CurrencyCode: "EUR",
Units: 1,
Nanos: 330000000,
},
},
{
value: 1.04,
currency: "EUR",
precision: 1,
want: &Money{
CurrencyCode: "EUR",
Units: 1,
Nanos: 0,
},
},
{
value: 1.05,
currency: "EUR",
precision: 1,
want: &Money{
CurrencyCode: "EUR",
Units: 1,
Nanos: 100000000,
},
},
{
value: 1.123456789,
currency: "EUR",
precision: 9,
want: &Money{
CurrencyCode: "EUR",
Units: 1,
Nanos: 123456789,
},
},
{
value: 1.999999999,
currency: "EUR",
precision: 9,
want: &Money{
CurrencyCode: "EUR",
Units: 1,
Nanos: 999999999,
},
},
}
for _, c := range cases {
t.Run(c.want.String(), func(t *testing.T) {
testhelpers.Equals(t, c.want, NewMoneyFromFloat(c.value, c.currency, c.precision))
})
}
}
func TestMoney_String(t *testing.T) {
cases := []struct {
money *Money
want string
}{
{
money: &Money{
CurrencyCode: "EUR",
Units: 10,
},
want: "€ 10.00",
},
{
money: &Money{
CurrencyCode: "USD",
Units: 10,
Nanos: 1,
},
want: "$ 10.000000001",
},
{
money: &Money{
CurrencyCode: "EUR",
Nanos: 100000000,
},
want: "€ 0.10",
},
{
money: &Money{
CurrencyCode: "EUR",
Nanos: 500000,
},
want: "€ 0.0005",
},
{
money: &Money{
CurrencyCode: "EUR",
Nanos: 333000000,
},
want: "€ 0.333",
},
{
money: &Money{
CurrencyCode: "EUR",
Nanos: 123456789,
},
want: "€ 0.123456789",
},
{
money: &Money{
CurrencyCode: "?",
},
want: "? 0.00",
},
}
for _, c := range cases {
t.Run(c.want, func(t *testing.T) {
testhelpers.Equals(t, c.want, c.money.String())
})
}
}
func TestSize_String(t *testing.T) {
cases := []struct {
size Size
want string
}{
{size: 42 * MB, want: "42000000"},
{size: 42 * B, want: "42"},
}
for _, c := range cases {
t.Run(c.want, func(t *testing.T) {
testhelpers.Equals(t, c.want, c.size.String())
})
}
}
func TestTimeSeries_MarshallJSON(t *testing.T) {
cases := []struct {
name string
ts *TimeSeries
want string
err error
}{
{
name: "basic",
ts: &TimeSeries{
Name: "cpu_usage",
Points: []*TimeSeriesPoint{
{
Timestamp: time.Date(2019, time.August, 8, 15, 00, 00, 0, time.UTC),
Value: 0.2,
},
{
Timestamp: time.Date(2019, time.August, 8, 15, 01, 00, 0, time.UTC),
Value: 10.6,
},
},
Metadata: map[string]string{
"node": "a77e0ce3",
},
},
want: `{"name":"cpu_usage","points":[["2019-08-08T15:00:00Z",0.2],["2019-08-08T15:01:00Z",10.6]],"metadata":{"node":"a77e0ce3"}}`,
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, err := json.Marshal(c.ts)
testhelpers.Equals(t, c.err, err)
if c.err == nil {
testhelpers.Equals(t, c.want, string(got))
}
})
}
}
func TestTimeSeries_UnmarshalJSON(t *testing.T) {
cases := []struct {
name string
json string
want *TimeSeries
err error
}{
{
name: "basic",
json: `
{
"name": "cpu_usage",
"points": [
["2019-08-08T15:00:00Z", 0.2],
["2019-08-08T15:01:00Z", 10.6]
],
"metadata": {
"node": "a77e0ce3"
}
}
`,
want: &TimeSeries{
Name: "cpu_usage",
Points: []*TimeSeriesPoint{
{
Timestamp: time.Date(2019, time.August, 8, 15, 00, 00, 0, time.UTC),
Value: 0.2,
},
{
Timestamp: time.Date(2019, time.August, 8, 15, 01, 00, 0, time.UTC),
Value: 10.6,
},
},
Metadata: map[string]string{
"node": "a77e0ce3",
},
},
},
{
name: "with timestamp error",
json: `{"name":"cpu_usage","points":[["2019/08/08T15-00-00Z",0.2]]}`,
err: fmt.Errorf("2019/08/08T15-00-00Z timestamp is not in RFC 3339 format"),
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
ts := &TimeSeries{}
err := json.Unmarshal([]byte(c.json), ts)
testhelpers.Equals(t, c.err, err)
if c.err == nil {
testhelpers.Equals(t, c.want, ts)
}
})
}
}
func TestFile_MarshalJSON(t *testing.T) {
cases := []struct {
name string
file *File
want string
err error
}{
{
name: "basic",
file: &File{
Name: "example.txt",
ContentType: "text/plain",
Content: strings.NewReader("Hello, world!"),
},
want: `{"name":"example.txt","content_type":"text/plain","content":"Hello, world!"}`,
},
{
name: "empty",
file: &File{},
want: `{"name":"","content_type":"","content":""}`,
},
{
name: "nil content",
file: &File{
Name: "example.txt",
ContentType: "text/plain",
Content: nil,
},
want: `{"name":"example.txt","content_type":"text/plain","content":""}`,
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, err := json.Marshal(c.file)
testhelpers.Equals(t, c.err, err)
if c.err == nil {
testhelpers.Equals(t, c.want, string(got))
}
})
}
}
func TestFile_UnmarshalJSON(t *testing.T) {
type testCase struct {
json string
name string
contentType string
content []byte
}
run := func(c *testCase) func(t *testing.T) {
return func(t *testing.T) {
f := File{}
err := json.Unmarshal([]byte(c.json), &f)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, c.name, f.Name)
testhelpers.Equals(t, c.contentType, f.ContentType)
s, err := io.ReadAll(f.Content)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, c.content, s)
}
}
t.Run("empty", run(&testCase{
json: `{}`,
content: []byte{},
}))
t.Run("strint_content", run(&testCase{
json: `{"name": "test", "content_type":"text/plain", "content": "dGVzdDQyCg=="}`,
name: "test",
contentType: "text/plain",
content: []byte("test42\n"),
}))
t.Run("binary_content", run(&testCase{
json: `{"name": "test", "content_type":"text/plain", "content": "AAAACg=="}`,
name: "test",
contentType: "text/plain",
content: []byte("\x00\x00\x00\n"),
}))
}
func TestIPNet_MarshallJSON(t *testing.T) {
cases := []struct {
name string
ipRange IPNet
want string
err error
}{
{
name: "ip",
ipRange: IPNet{IPNet: net.IPNet{IP: net.IPv4(42, 42, 42, 42), Mask: net.CIDRMask(32, 32)}},
want: `"42.42.42.42/32"`,
},
{
name: "network",
ipRange: IPNet{IPNet: net.IPNet{IP: net.IPv4(42, 42, 42, 42), Mask: net.CIDRMask(16, 32)}},
want: `"42.42.42.42/16"`,
},
{
name: "network with ip",
ipRange: IPNet{IPNet: net.IPNet{IP: net.IPv4(192, 168, 1, 42), Mask: net.CIDRMask(24, 32)}},
want: `"192.168.1.42/24"`,
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, err := json.Marshal(c.ipRange)
testhelpers.Equals(t, c.err, err)
if c.err == nil {
testhelpers.Equals(t, c.want, string(got))
}
})
}
}
func TestIPNet_UnmarshalJSON(t *testing.T) {
cases := []struct {
name string
json string
want IPNet
err string
}{
{
name: "IPv4 with CIDR",
json: `"42.42.42.42/32"`,
want: IPNet{IPNet: net.IPNet{IP: net.IPv4(42, 42, 42, 42), Mask: net.CIDRMask(32, 32)}},
},
{
name: "IPv4 with network",
json: `"192.0.2.1/24"`,
want: IPNet{IPNet: net.IPNet{IP: net.IPv4(192, 0, 2, 1), Mask: net.CIDRMask(24, 32)}},
},
{
name: "IPv4 with network 2",
json: `"192.168.1.42/24"`,
want: IPNet{IPNet: net.IPNet{IP: net.IPv4(192, 168, 1, 42), Mask: net.CIDRMask(24, 32)}},
},
{
name: "IPv6 with network",
json: `"2001:db8:abcd:8000::/50"`,
want: IPNet{IPNet: net.IPNet{IP: net.ParseIP("2001:db8:abcd:8000::"), Mask: net.CIDRMask(50, 128)}},
},
{
name: "IPv4 alone",
json: `"42.42.42.42"`,
want: IPNet{IPNet: net.IPNet{IP: net.IPv4(42, 42, 42, 42), Mask: net.CIDRMask(32, 32)}},
},
{
name: "IPv6 alone",
json: `"2001:db8:abcd:8000::"`,
want: IPNet{IPNet: net.IPNet{IP: net.ParseIP("2001:db8:abcd:8000::"), Mask: net.CIDRMask(128, 128)}},
},
{
name: "invalid CIDR error",
json: `"invalidvalue"`,
err: "invalid CIDR address: invalidvalue",
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
ipNet := &IPNet{}
err := json.Unmarshal([]byte(c.json), ipNet)
if err != nil {
testhelpers.Equals(t, c.err, err.Error())
}
testhelpers.Equals(t, c.want.String(), ipNet.String())
})
}
}
func TestDuration_MarshallJSON(t *testing.T) {
cases := []struct {
name string
duration *Duration
want string
err error
}{
{
name: "small seconds",
duration: &Duration{Seconds: 3, Nanos: 0},
want: `"3.000000000s"`,
},
{
name: "small seconds, small nanos",
duration: &Duration{Seconds: 3, Nanos: 12e7},
want: `"3.120000000s"`,
},
{
name: "small seconds, big nanos",
duration: &Duration{Seconds: 3, Nanos: 123456789},
want: `"3.123456789s"`,
},
{
name: "big seconds, big nanos",
duration: &Duration{Seconds: 345679384, Nanos: 123456789},
want: `"345679384.123456789s"`,
},
{
name: "negative small seconds",
duration: &Duration{Seconds: -3, Nanos: 0},
want: `"-3.000000000s"`,
},
{
name: "negative small seconds, small nanos",
duration: &Duration{Seconds: -3, Nanos: -12e7},
want: `"-3.120000000s"`,
},
{
name: "negative small seconds, big nanos",
duration: &Duration{Seconds: -3, Nanos: -123456789},
want: `"-3.123456789s"`,
},
{
name: "negative big seconds, big nanos",
duration: &Duration{Seconds: -345679384, Nanos: -123456789},
want: `"-345679384.123456789s"`,
},
{
name: "negative big seconds, big nanos",
duration: &Duration{},
want: `"0.000000000s"`,
},
{
name: "null duration",
duration: nil,
want: `null`,
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, err := json.Marshal(c.duration)
testhelpers.Equals(t, c.err, err)
if c.err == nil {
testhelpers.Equals(t, c.want, string(got))
}
})
}
}
func TestDuration_UnmarshalJSON(t *testing.T) {
cases := []struct {
name string
json string
want *Duration
err string
}{
{
name: "error negative nanos",
json: `{"duration":"a.12s"}`,
want: nil,
err: "scaleway-sdk-go: invalid units: strconv.ParseInt: parsing \"a\": invalid syntax",
},
{
name: "error negative nanos",
json: `{"duration":"3.-12s"}`,
want: nil,
err: "scaleway-sdk-go: invalid nanos: strconv.ParseUint: parsing \"-12000000\": invalid syntax",
},
{
name: "null",
json: `{"duration":null}`,
want: nil,
},
{
name: "small seconds",
json: `{"duration":"3.00s"}`,
want: &Duration{Seconds: 3, Nanos: 0},
},
{
name: "small seconds, small nanos",
json: `{"duration":"3.12s"}`,
want: &Duration{Seconds: 3, Nanos: 12e7},
},
{
name: "bug seconds",
json: `{"duration":"987654321.00s"}`,
want: &Duration{Seconds: 987654321, Nanos: 0},
},
{
name: "big seconds, big nanos",
json: `{"duration":"987654321.123456789s"}`,
want: &Duration{Seconds: 987654321, Nanos: 123456789},
},
{
name: "negative small seconds",
json: `{"duration":"-3.00s"}`,
want: &Duration{Seconds: -3, Nanos: 0},
},
{
name: "negative small seconds, small nanos",
json: `{"duration":"-3.12s"}`,
want: &Duration{Seconds: -3, Nanos: -12e7},
},
{
name: "negative bug seconds",
json: `{"duration":"-987654321.00s"}`,
want: &Duration{Seconds: -987654321, Nanos: 0},
},
{
name: "negative big seconds, big nanos",
json: `{"duration":"-987654321.123456789s"}`,
want: &Duration{Seconds: -987654321, Nanos: -123456789},
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
var testType struct {
Duration *Duration
}
err := json.Unmarshal([]byte(c.json), &testType)
if err != nil {
testhelpers.Equals(t, c.err, err.Error())
} else {
testhelpers.Equals(t, c.want, testType.Duration)
}
})
}
}
func TestDuration_ToTimeDuration(t *testing.T) {
cases := []struct {
name string
duration *Duration
want time.Duration
}{
{
name: "nil duration",
duration: nil,
want: time.Duration(0),
},
{
name: "zero duration",
duration: &Duration{Seconds: 0, Nanos: 0},
want: time.Duration(0),
},
{
name: "seconds only",
duration: &Duration{Seconds: 10, Nanos: 0},
want: time.Duration(10) * time.Second,
},
{
name: "nanoseconds only",
duration: &Duration{Seconds: 0, Nanos: 500},
want: time.Duration(500),
},
{
name: "seconds and nanoseconds",
duration: &Duration{Seconds: 10, Nanos: 500},
want: time.Duration(10)*time.Second + time.Duration(500),
},
{
name: "negative seconds",
duration: &Duration{Seconds: -10, Nanos: 0},
want: time.Duration(-10) * time.Second,
},
{
name: "negative nanoseconds",
duration: &Duration{Seconds: 0, Nanos: -500},
want: time.Duration(-500),
},
{
name: "negative seconds and nanoseconds",
duration: &Duration{Seconds: -10, Nanos: -500},
want: time.Duration(-10)*time.Second + time.Duration(-500),
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got := c.duration.ToTimeDuration()
if got == nil {
if c.want != 0 {
t.Errorf("got nil, want %s", c.want)
}
} else if *got != c.want {
t.Errorf("got %s, want %s", *got, c.want)
}
})
}
}
func TestDuration_FromTimeDuration(t *testing.T) {
cases := []struct {
name string
duration time.Duration
want *Duration
}{
{
name: "zero duration",
want: &Duration{Seconds: 0, Nanos: 0},
duration: time.Duration(0),
},
{
name: "seconds only",
want: &Duration{Seconds: 10, Nanos: 0},
duration: time.Duration(10) * time.Second,
},
{
name: "nanoseconds only",
want: &Duration{Seconds: 0, Nanos: 500},
duration: time.Duration(500),
},
{
name: "seconds and nanoseconds",
want: &Duration{Seconds: 10, Nanos: 500},
duration: time.Duration(10)*time.Second + time.Duration(500),
},
{
name: "negative seconds",
want: &Duration{Seconds: -10, Nanos: 0},
duration: time.Duration(-10) * time.Second,
},
{
name: "negative nanoseconds",
want: &Duration{Seconds: 0, Nanos: -500},
duration: time.Duration(-500),
},
{
name: "negative seconds and nanoseconds",
want: &Duration{Seconds: -10, Nanos: -500},
duration: time.Duration(-10)*time.Second + time.Duration(-500),
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got := NewDurationFromTimeDuration(c.duration)
if got == nil {
t.Errorf("got nil, want %v", c.want)
} else if got.Seconds != c.want.Seconds && got.Nanos != c.want.Nanos {
t.Errorf("got %v, want %v", *got, c.want)
}
})
}
}
func TestJSONObject_UnmarshalJSON(t *testing.T) {
cases := []struct {
name string
json string
want *JSONObject
err error
}{
{
name: "basic",
json: `
{
"test": "scw"
}
`,
want: &JSONObject{
"test": "scw",
},
},
{
name: "multi-types",
json: `
{
"firstName": "John",
"lastName": "Smith",
"isAlive": true,
"age": 23,
"address": {
"city": "Paris",
"country": "FR"
}
}
`,
want: &JSONObject{
"firstName": "John",
"lastName": "Smith",
"isAlive": true,
"age": float64(23),
"address": map[string]interface{}{
"city": "Paris",
"country": "FR",
},
},
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
ts, err := DecodeJSONObject(c.json, NoEscape)
testhelpers.Equals(t, c.err, err)
if c.err == nil {
testhelpers.Equals(t, *c.want, ts)
}
})
}
}
func TestJSONObject_MarshalJSON(t *testing.T) {
cases := []struct {
name string
jsonValue *JSONObject
want string
err error
}{
{
name: "basic",
jsonValue: &JSONObject{
"test": "scw",
},
want: `{"test":"scw"}`,
},
{
name: "multi-types",
want: `{"address":{"city":"Paris","country":"FR"},"age":23,"firstName":"John","isAlive":true,"lastName":"Smith"}`,
jsonValue: &JSONObject{
"firstName": "John",
"lastName": "Smith",
"isAlive": true,
"age": float64(23),
"address": map[string]interface{}{
"city": "Paris",
"country": "FR",
},
},
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, err := EncodeJSONObject(*c.jsonValue, NoEscape)
testhelpers.Equals(t, c.err, err)
if c.err == nil {
testhelpers.Equals(t, c.want, string(got))
}
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/env.go 0000664 0000000 0000000 00000010063 14563666056 0024171 0 ustar 00root root 0000000 0000000 package scw
import (
"os"
"strconv"
"github.com/scaleway/scaleway-sdk-go/logger"
)
// Environment variables
const (
// Up-to-date
ScwCacheDirEnv = "SCW_CACHE_DIR"
ScwConfigPathEnv = "SCW_CONFIG_PATH"
ScwAccessKeyEnv = "SCW_ACCESS_KEY"
ScwSecretKeyEnv = "SCW_SECRET_KEY" // #nosec G101
ScwActiveProfileEnv = "SCW_PROFILE"
ScwAPIURLEnv = "SCW_API_URL"
ScwInsecureEnv = "SCW_INSECURE"
ScwDefaultOrganizationIDEnv = "SCW_DEFAULT_ORGANIZATION_ID"
ScwDefaultProjectIDEnv = "SCW_DEFAULT_PROJECT_ID"
ScwDefaultRegionEnv = "SCW_DEFAULT_REGION"
ScwDefaultZoneEnv = "SCW_DEFAULT_ZONE"
ScwEnableBeta = "SCW_ENABLE_BETA"
DebugEnv = logger.DebugEnv
// All deprecated (cli&terraform)
terraformAccessKeyEnv = "SCALEWAY_ACCESS_KEY" // used both as access key and secret key
terraformSecretKeyEnv = "SCALEWAY_TOKEN"
terraformOrganizationEnv = "SCALEWAY_ORGANIZATION"
terraformRegionEnv = "SCALEWAY_REGION"
cliTLSVerifyEnv = "SCW_TLSVERIFY"
cliOrganizationEnv = "SCW_ORGANIZATION"
cliRegionEnv = "SCW_REGION"
cliSecretKeyEnv = "SCW_TOKEN"
// TBD
//cliVerboseEnv = "SCW_VERBOSE_API"
//cliDebugEnv = "DEBUG"
//cliNoCheckVersionEnv = "SCW_NOCHECKVERSION"
//cliTestWithRealAPIEnv = "TEST_WITH_REAL_API"
//cliSecureExecEnv = "SCW_SECURE_EXEC"
//cliGatewayEnv = "SCW_GATEWAY"
//cliSensitiveEnv = "SCW_SENSITIVE"
//cliAccountAPIEnv = "SCW_ACCOUNT_API"
//cliMetadataAPIEnv = "SCW_METADATA_API"
//cliMarketPlaceAPIEnv = "SCW_MARKETPLACE_API"
//cliComputePar1APIEnv = "SCW_COMPUTE_PAR1_API"
//cliComputeAms1APIEnv = "SCW_COMPUTE_AMS1_API"
//cliCommercialTypeEnv = "SCW_COMMERCIAL_TYPE"
//cliTargetArchEnv = "SCW_TARGET_ARCH"
)
const (
v1RegionFrPar = "par1"
v1RegionNlAms = "ams1"
)
func LoadEnvProfile() *Profile {
p := &Profile{}
accessKey, _, envExist := getEnv(ScwAccessKeyEnv, terraformAccessKeyEnv)
if envExist {
p.AccessKey = &accessKey
}
secretKey, _, envExist := getEnv(ScwSecretKeyEnv, cliSecretKeyEnv, terraformSecretKeyEnv, terraformAccessKeyEnv)
if envExist {
p.SecretKey = &secretKey
}
apiURL, _, envExist := getEnv(ScwAPIURLEnv)
if envExist {
p.APIURL = &apiURL
}
insecureValue, envKey, envExist := getEnv(ScwInsecureEnv, cliTLSVerifyEnv)
if envExist {
insecure, err := strconv.ParseBool(insecureValue)
if err != nil {
logger.Warningf("env variable %s cannot be parsed: %s is invalid boolean", envKey, insecureValue)
}
if envKey == cliTLSVerifyEnv {
insecure = !insecure // TLSVerify is the inverse of Insecure
}
p.Insecure = &insecure
}
organizationID, _, envExist := getEnv(ScwDefaultOrganizationIDEnv, cliOrganizationEnv, terraformOrganizationEnv)
if envExist {
p.DefaultOrganizationID = &organizationID
}
projectID, _, envExist := getEnv(ScwDefaultProjectIDEnv)
if envExist {
p.DefaultProjectID = &projectID
}
region, _, envExist := getEnv(ScwDefaultRegionEnv, cliRegionEnv, terraformRegionEnv)
if envExist {
region = v1RegionToV2(region)
p.DefaultRegion = ®ion
}
zone, _, envExist := getEnv(ScwDefaultZoneEnv)
if envExist {
p.DefaultZone = &zone
}
return p
}
func getEnv(upToDateKey string, deprecatedKeys ...string) (string, string, bool) {
value, exist := os.LookupEnv(upToDateKey)
if exist {
logger.Debugf("reading value from %s", upToDateKey)
return value, upToDateKey, true
}
for _, key := range deprecatedKeys {
value, exist := os.LookupEnv(key)
if exist {
logger.Debugf("reading value from %s", key)
logger.Warningf("%s is deprecated, please use %s instead", key, upToDateKey)
return value, key, true
}
}
return "", "", false
}
func v1RegionToV2(region string) string {
switch region {
case v1RegionFrPar:
logger.Warningf("par1 is a deprecated name for region, use fr-par instead")
return "fr-par"
case v1RegionNlAms:
logger.Warningf("ams1 is a deprecated name for region, use nl-ams instead")
return "nl-ams"
default:
return region
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/env_test.go 0000664 0000000 0000000 00000007023 14563666056 0025232 0 ustar 00root root 0000000 0000000 package scw
import (
"os"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
// TestLoadConfig tests config getters return correct values
func TestLoadEnvProfile(t *testing.T) {
tests := []struct {
name string
env map[string]string
expectedAccessKey *string
expectedSecretKey *string
expectedAPIURL *string
expectedInsecure *bool
expectedDefaultOrganizationID *string
expectedDefaultProjectID *string
expectedDefaultRegion *string
expectedDefaultZone *string
}{
// up-to-date env variables
{
name: "No config with env variables",
env: map[string]string{
ScwAccessKeyEnv: v2ValidAccessKey,
ScwSecretKeyEnv: v2ValidSecretKey,
ScwAPIURLEnv: v2ValidAPIURL,
ScwInsecureEnv: "false",
ScwDefaultOrganizationIDEnv: v2ValidDefaultOrganizationID,
ScwDefaultProjectIDEnv: v2ValidDefaultProjectID,
ScwDefaultRegionEnv: v2ValidDefaultRegion,
ScwDefaultZoneEnv: v2ValidDefaultZone,
},
expectedAccessKey: s(v2ValidAccessKey),
expectedSecretKey: s(v2ValidSecretKey),
expectedAPIURL: s(v2ValidAPIURL),
expectedInsecure: b(false),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: s(v2ValidDefaultRegion),
expectedDefaultZone: s(v2ValidDefaultZone),
},
{
name: "No config with terraform legacy env variables",
env: map[string]string{
terraformAccessKeyEnv: v2ValidAccessKey,
terraformSecretKeyEnv: v2ValidSecretKey,
terraformOrganizationEnv: v2ValidDefaultOrganizationID,
terraformRegionEnv: v2ValidDefaultRegion,
},
expectedAccessKey: s(v2ValidAccessKey),
expectedSecretKey: s(v2ValidSecretKey),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID),
expectedDefaultProjectID: s(v2ValidDefaultProjectID),
expectedDefaultRegion: s(v2ValidDefaultRegion),
},
{
name: "No config with CLI legacy env variables",
env: map[string]string{
cliSecretKeyEnv: v2ValidSecretKey2,
cliOrganizationEnv: v2ValidDefaultOrganizationID2,
cliRegionEnv: v2ValidDefaultRegion2,
cliTLSVerifyEnv: "false",
},
expectedSecretKey: s(v2ValidSecretKey2),
expectedInsecure: b(true),
expectedDefaultOrganizationID: s(v2ValidDefaultOrganizationID2),
expectedDefaultProjectID: s(v2ValidDefaultProjectID2),
expectedDefaultRegion: s(v2ValidDefaultRegion2),
},
}
// create home dir
dir := initEnv(t)
// delete home dir and reset env variables
defer resetEnv(t, os.Environ(), dir)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
// set up env and config file(s)
setEnv(t, test.env, nil, dir)
// remove config file(s)
defer cleanEnv(t, nil, dir)
// load config
p := LoadEnvProfile()
// assert getters
testhelpers.Equals(t, test.expectedAccessKey, p.AccessKey)
testhelpers.Equals(t, test.expectedSecretKey, p.SecretKey)
testhelpers.Equals(t, test.expectedAPIURL, p.APIURL)
testhelpers.Equals(t, test.expectedDefaultOrganizationID, p.DefaultOrganizationID)
testhelpers.Equals(t, test.expectedDefaultRegion, p.DefaultRegion)
testhelpers.Equals(t, test.expectedDefaultZone, p.DefaultZone)
testhelpers.Equals(t, test.expectedInsecure, p.Insecure)
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/errors.go 0000664 0000000 0000000 00000035435 14563666056 0024727 0 ustar 00root root 0000000 0000000 package scw
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"sort"
"strings"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/validation"
)
// SdkError is a base interface for all Scaleway SDK errors.
type SdkError interface {
Error() string
IsScwSdkError()
}
// ResponseError is an error type for the Scaleway API
type ResponseError struct {
// Message is a human-friendly error message
Message string `json:"message"`
// Type is a string code that defines the kind of error. This field is only used by instance API
Type string `json:"type,omitempty"`
// Resource is a string code that defines the resource concerned by the error. This field is only used by instance API
Resource string `json:"resource,omitempty"`
// Fields contains detail about validation error. This field is only used by instance API
Fields map[string][]string `json:"fields,omitempty"`
// StatusCode is the HTTP status code received
StatusCode int `json:"-"`
// Status is the HTTP status received
Status string `json:"-"`
RawBody json.RawMessage `json:"-"`
}
func (e *ResponseError) UnmarshalJSON(b []byte) error {
type tmpResponseError ResponseError
tmp := tmpResponseError(*e)
err := json.Unmarshal(b, &tmp)
if err != nil {
return err
}
tmp.Message = strings.ToLower(tmp.Message)
*e = ResponseError(tmp)
return nil
}
// IsScwSdkError implement SdkError interface
func (e *ResponseError) IsScwSdkError() {}
func (e *ResponseError) Error() string {
s := fmt.Sprintf("scaleway-sdk-go: http error %s", e.Status)
if e.Resource != "" {
s = fmt.Sprintf("%s: resource %s", s, e.Resource)
}
if e.Message != "" {
s = fmt.Sprintf("%s: %s", s, e.Message)
}
if len(e.Fields) > 0 {
s = fmt.Sprintf("%s: %v", s, e.Fields)
}
return s
}
func (e *ResponseError) GetRawBody() json.RawMessage {
return e.RawBody
}
// hasResponseError returns an SdkError when the HTTP status is not OK.
func hasResponseError(res *http.Response) error {
if res.StatusCode >= 200 && res.StatusCode <= 299 {
return nil
}
newErr := &ResponseError{
StatusCode: res.StatusCode,
Status: res.Status,
}
if res.Body == nil {
return newErr
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return errors.Wrap(err, "cannot read error response body")
}
newErr.RawBody = body
// The error content is not encoded in JSON, only returns HTTP data.
contentType := res.Header.Get("Content-Type")
if !strings.HasPrefix(contentType, "application/json") {
newErr.Message = res.Status
return newErr
}
err = json.Unmarshal(body, newErr)
if err != nil {
return errors.Wrap(err, "could not parse error response body")
}
err = unmarshalStandardError(newErr.Type, body)
if err != nil {
return err
}
err = unmarshalNonStandardError(newErr.Type, body)
if err != nil {
return err
}
return newErr
}
func unmarshalStandardError(errorType string, body []byte) error {
var stdErr SdkError
switch errorType {
case "invalid_arguments":
stdErr = &InvalidArgumentsError{RawBody: body}
case "quotas_exceeded":
stdErr = &QuotasExceededError{RawBody: body}
case "transient_state":
stdErr = &TransientStateError{RawBody: body}
case "not_found":
stdErr = &ResourceNotFoundError{RawBody: body}
case "locked":
stdErr = &ResourceLockedError{RawBody: body}
case "permissions_denied":
stdErr = &PermissionsDeniedError{RawBody: body}
case "out_of_stock":
stdErr = &OutOfStockError{RawBody: body}
case "resource_expired":
stdErr = &ResourceExpiredError{RawBody: body}
case "denied_authentication":
stdErr = &DeniedAuthenticationError{RawBody: body}
case "precondition_failed":
stdErr = &PreconditionFailedError{RawBody: body}
default:
return nil
}
err := json.Unmarshal(body, stdErr)
if err != nil {
return errors.Wrap(err, "could not parse error %s response body", errorType)
}
return stdErr
}
func unmarshalNonStandardError(errorType string, body []byte) error {
switch errorType {
// Only in instance API.
case "unknown_resource":
unknownResourceError := &UnknownResource{RawBody: body}
err := json.Unmarshal(body, unknownResourceError)
if err != nil {
return errors.Wrap(err, "could not parse error %s response body", errorType)
}
return unknownResourceError.ToResourceNotFoundError()
case "invalid_request_error":
invalidRequestError := &InvalidRequestError{RawBody: body}
err := json.Unmarshal(body, invalidRequestError)
if err != nil {
return errors.Wrap(err, "could not parse error %s response body", errorType)
}
invalidArgumentsError := invalidRequestError.ToInvalidArgumentsError()
if invalidArgumentsError != nil {
return invalidArgumentsError
}
quotasExceededError := invalidRequestError.ToQuotasExceededError()
if quotasExceededError != nil {
return quotasExceededError
}
// At this point, the invalid_request_error is not an InvalidArgumentsError and
// the default marshalling will be used.
return nil
default:
return nil
}
}
type InvalidArgumentsErrorDetail struct {
ArgumentName string `json:"argument_name"`
Reason string `json:"reason"`
HelpMessage string `json:"help_message"`
}
type InvalidArgumentsError struct {
Details []InvalidArgumentsErrorDetail `json:"details"`
RawBody json.RawMessage `json:"-"`
}
// IsScwSdkError implements the SdkError interface
func (e *InvalidArgumentsError) IsScwSdkError() {}
func (e *InvalidArgumentsError) Error() string {
invalidArgs := make([]string, len(e.Details))
for i, d := range e.Details {
invalidArgs[i] = d.ArgumentName
switch d.Reason {
case "unknown":
invalidArgs[i] += " is invalid for unexpected reason"
case "required":
invalidArgs[i] += " is required"
case "format":
invalidArgs[i] += " is wrongly formatted"
case "constraint":
invalidArgs[i] += " does not respect constraint"
}
if d.HelpMessage != "" {
invalidArgs[i] += ", " + d.HelpMessage
}
}
return "scaleway-sdk-go: invalid argument(s): " + strings.Join(invalidArgs, "; ")
}
func (e *InvalidArgumentsError) GetRawBody() json.RawMessage {
return e.RawBody
}
// UnknownResource is only returned by the instance API.
// Warning: this is not a standard error.
type UnknownResource struct {
Message string `json:"message"`
RawBody json.RawMessage `json:"-"`
}
// ToSdkError returns a standard error InvalidArgumentsError or nil Fields is nil.
func (e *UnknownResource) ToResourceNotFoundError() SdkError {
resourceNotFound := &ResourceNotFoundError{
RawBody: e.RawBody,
}
messageParts := strings.Split(e.Message, `"`)
// Some errors uses ' and not "
if len(messageParts) == 1 {
messageParts = strings.Split(e.Message, "'")
}
switch len(messageParts) {
case 2: // message like: `"111..." not found`
resourceNotFound.ResourceID = messageParts[0]
case 3: // message like: `Security Group "111..." not found`
resourceNotFound.ResourceID = messageParts[1]
// transform `Security group ` to `security_group`
resourceNotFound.Resource = strings.ReplaceAll(strings.ToLower(strings.TrimSpace(messageParts[0])), " ", "_")
default:
return nil
}
if !validation.IsUUID(resourceNotFound.ResourceID) {
return nil
}
return resourceNotFound
}
// InvalidRequestError is only returned by the instance API.
// Warning: this is not a standard error.
type InvalidRequestError struct {
Message string `json:"message"`
Fields map[string][]string `json:"fields"`
Resource string `json:"resource"`
RawBody json.RawMessage `json:"-"`
}
// ToSdkError returns a standard error InvalidArgumentsError or nil Fields is nil.
func (e *InvalidRequestError) ToInvalidArgumentsError() SdkError {
// If error has no fields, it is not an InvalidArgumentsError.
if e.Fields == nil || len(e.Fields) == 0 {
return nil
}
invalidArguments := &InvalidArgumentsError{
RawBody: e.RawBody,
}
fieldNames := []string(nil)
for fieldName := range e.Fields {
fieldNames = append(fieldNames, fieldName)
}
sort.Strings(fieldNames)
for _, fieldName := range fieldNames {
for _, message := range e.Fields[fieldName] {
invalidArguments.Details = append(invalidArguments.Details, InvalidArgumentsErrorDetail{
ArgumentName: fieldName,
Reason: "constraint",
HelpMessage: message,
})
}
}
return invalidArguments
}
func (e *InvalidRequestError) ToQuotasExceededError() SdkError {
if !strings.Contains(strings.ToLower(e.Message), "quota exceeded for this resource") {
return nil
}
return &QuotasExceededError{
Details: []QuotasExceededErrorDetail{
{
Resource: e.Resource,
Quota: 0,
Current: 0,
},
},
RawBody: e.RawBody,
}
}
type QuotasExceededErrorDetail struct {
Resource string `json:"resource"`
Quota uint32 `json:"quota"`
Current uint32 `json:"current"`
}
type QuotasExceededError struct {
Details []QuotasExceededErrorDetail `json:"details"`
RawBody json.RawMessage `json:"-"`
}
// IsScwSdkError implements the SdkError interface
func (e *QuotasExceededError) IsScwSdkError() {}
func (e *QuotasExceededError) Error() string {
invalidArgs := make([]string, len(e.Details))
for i, d := range e.Details {
invalidArgs[i] = fmt.Sprintf("%s has reached its quota (%d/%d)", d.Resource, d.Current, d.Quota)
}
return "scaleway-sdk-go: quota exceeded(s): " + strings.Join(invalidArgs, "; ")
}
func (e *QuotasExceededError) GetRawBody() json.RawMessage {
return e.RawBody
}
type PermissionsDeniedError struct {
Details []struct {
Resource string `json:"resource"`
Action string `json:"action"`
} `json:"details"`
RawBody json.RawMessage `json:"-"`
}
// IsScwSdkError implements the SdkError interface
func (e *PermissionsDeniedError) IsScwSdkError() {}
func (e *PermissionsDeniedError) Error() string {
invalidArgs := make([]string, len(e.Details))
for i, d := range e.Details {
invalidArgs[i] = fmt.Sprintf("%s %s", d.Action, d.Resource)
}
return "scaleway-sdk-go: insufficient permissions: " + strings.Join(invalidArgs, "; ")
}
func (e *PermissionsDeniedError) GetRawBody() json.RawMessage {
return e.RawBody
}
type TransientStateError struct {
Resource string `json:"resource"`
ResourceID string `json:"resource_id"`
CurrentState string `json:"current_state"`
RawBody json.RawMessage `json:"-"`
}
// IsScwSdkError implements the SdkError interface
func (e *TransientStateError) IsScwSdkError() {}
func (e *TransientStateError) Error() string {
return fmt.Sprintf("scaleway-sdk-go: resource %s with ID %s is in a transient state: %s", e.Resource, e.ResourceID, e.CurrentState)
}
func (e *TransientStateError) GetRawBody() json.RawMessage {
return e.RawBody
}
type ResourceNotFoundError struct {
Resource string `json:"resource"`
ResourceID string `json:"resource_id"`
RawBody json.RawMessage `json:"-"`
}
// IsScwSdkError implements the SdkError interface
func (e *ResourceNotFoundError) IsScwSdkError() {}
func (e *ResourceNotFoundError) Error() string {
return fmt.Sprintf("scaleway-sdk-go: resource %s with ID %s is not found", e.Resource, e.ResourceID)
}
func (e *ResourceNotFoundError) GetRawBody() json.RawMessage {
return e.RawBody
}
type ResourceLockedError struct {
Resource string `json:"resource"`
ResourceID string `json:"resource_id"`
RawBody json.RawMessage `json:"-"`
}
// IsScwSdkError implements the SdkError interface
func (e *ResourceLockedError) IsScwSdkError() {}
func (e *ResourceLockedError) Error() string {
return fmt.Sprintf("scaleway-sdk-go: resource %s with ID %s is locked", e.Resource, e.ResourceID)
}
func (e *ResourceLockedError) GetRawBody() json.RawMessage {
return e.RawBody
}
type OutOfStockError struct {
Resource string `json:"resource"`
RawBody json.RawMessage `json:"-"`
}
// IsScwSdkError implements the SdkError interface
func (e *OutOfStockError) IsScwSdkError() {}
func (e *OutOfStockError) Error() string {
return fmt.Sprintf("scaleway-sdk-go: resource %s is out of stock", e.Resource)
}
func (e *OutOfStockError) GetRawBody() json.RawMessage {
return e.RawBody
}
// InvalidClientOptionError indicates that at least one of client data has been badly provided for the client creation.
type InvalidClientOptionError struct {
errorType string
}
func NewInvalidClientOptionError(format string, a ...interface{}) *InvalidClientOptionError {
return &InvalidClientOptionError{errorType: fmt.Sprintf(format, a...)}
}
// IsScwSdkError implements the SdkError interface
func (e InvalidClientOptionError) IsScwSdkError() {}
func (e InvalidClientOptionError) Error() string {
return fmt.Sprintf("scaleway-sdk-go: %s", e.errorType)
}
// ConfigFileNotFound indicates that the config file could not be found
type ConfigFileNotFoundError struct {
path string
}
func configFileNotFound(path string) *ConfigFileNotFoundError {
return &ConfigFileNotFoundError{path: path}
}
// ConfigFileNotFoundError implements the SdkError interface
func (e ConfigFileNotFoundError) IsScwSdkError() {}
func (e ConfigFileNotFoundError) Error() string {
return fmt.Sprintf("scaleway-sdk-go: cannot read config file %s: no such file or directory", e.path)
}
// ResourceExpiredError implements the SdkError interface
type ResourceExpiredError struct {
Resource string `json:"resource"`
ResourceID string `json:"resource_id"`
ExpiredSince time.Time `json:"expired_since"`
RawBody json.RawMessage `json:"-"`
}
func (r ResourceExpiredError) Error() string {
return fmt.Sprintf("scaleway-sdk-go: resource %s with ID %s expired since %s", r.Resource, r.ResourceID, r.ExpiredSince.String())
}
func (r ResourceExpiredError) IsScwSdkError() {}
// DeniedAuthenticationError implements the SdkError interface
type DeniedAuthenticationError struct {
Method string `json:"method"`
Reason string `json:"reason"`
RawBody json.RawMessage `json:"-"`
}
func (r DeniedAuthenticationError) Error() string {
var reason string
var method string
switch r.Method {
case "unknown_method":
method = "unknown method"
case "jwt":
method = "JWT"
case "api_key":
method = "API key"
}
switch r.Reason {
case "unknown_reason":
reason = "unknown reason"
case "invalid_argument":
reason = "invalid " + method + " format or empty value"
case "not_found":
reason = method + " does not exist"
case "expired":
reason = method + " is expired"
}
return fmt.Sprintf("scaleway-sdk-go: denied authentication: %s", reason)
}
func (r DeniedAuthenticationError) IsScwSdkError() {}
// PreconditionFailedError implements the SdkError interface
type PreconditionFailedError struct {
Precondition string `json:"precondition"`
HelpMessage string `json:"help_message"`
RawBody json.RawMessage `json:"-"`
}
func (r PreconditionFailedError) Error() string {
var msg string
switch r.Precondition {
case "unknown_precondition":
msg = "unknown precondition"
case "resource_still_in_use":
msg = "resource is still in use"
case "attribute_must_be_set":
msg = "attribute must be set"
}
if r.HelpMessage != "" {
msg += ", " + r.HelpMessage
}
return fmt.Sprintf("scaleway-sdk-go: precondition failed: %s", msg)
}
func (r PreconditionFailedError) IsScwSdkError() {}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/errors_test.go 0000664 0000000 0000000 00000015547 14563666056 0025770 0 ustar 00root root 0000000 0000000 package scw
import (
"bytes"
"encoding/json"
"io/ioutil"
"net/http"
"strings"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
func TestHasResponseErrorWithStatus200(t *testing.T) {
res := &http.Response{StatusCode: 200}
newErr := hasResponseError(res)
testhelpers.AssertNoError(t, newErr)
}
func TestHasResponseErrorWithoutBody(t *testing.T) {
res := &http.Response{StatusCode: 400}
newErr := hasResponseError(res)
testhelpers.Assert(t, newErr != nil, "Should have error")
}
func TestNonStandardError(t *testing.T) {
type testCase struct {
resStatus string
resStatusCode int
resBody string
contentType string
expectedError SdkError
}
run := func(c *testCase) func(t *testing.T) {
return func(t *testing.T) {
res := &http.Response{
Status: c.resStatus,
StatusCode: c.resStatusCode,
Body: ioutil.NopCloser(strings.NewReader(c.resBody)),
Header: http.Header{
"Content-Type": []string{c.contentType},
},
}
// Test that hasResponseError converts the response to the expected SdkError.
newErr := hasResponseError(res)
testhelpers.Assert(t, newErr != nil, "Should have error")
testhelpers.Equals(t, c.expectedError, newErr)
}
}
t.Run("invalid_request_error type with fields", run(&testCase{
resStatus: "400 Bad Request",
resStatusCode: http.StatusBadRequest,
contentType: "application/json",
resBody: `{"fields":{"volumes.5.id":["92 is not a valid UUID."],"volumes.5.name":["required key not provided"]},"message":"Validation Error","type":"invalid_request_error"}`,
expectedError: &InvalidArgumentsError{
Details: []InvalidArgumentsErrorDetail{
{
ArgumentName: "volumes.5.id",
Reason: "constraint",
HelpMessage: "92 is not a valid UUID.",
},
{
ArgumentName: "volumes.5.name",
Reason: "constraint",
HelpMessage: "required key not provided",
},
},
RawBody: []byte(`{"fields":{"volumes.5.id":["92 is not a valid UUID."],"volumes.5.name":["required key not provided"]},"message":"Validation Error","type":"invalid_request_error"}`),
},
}))
t.Run("invalid_request_error type with message", run(&testCase{
resStatus: "400 Bad Request",
resStatusCode: http.StatusBadRequest,
contentType: "application/json",
resBody: `{"message": "server should be running", "type": "invalid_request_error"}`,
expectedError: &ResponseError{
Status: "400 Bad Request",
StatusCode: http.StatusBadRequest,
Message: "server should be running",
Type: "invalid_request_error",
RawBody: []byte(`{"message": "server should be running", "type": "invalid_request_error"}`),
},
}))
t.Run("invalid_request_error quota exceeded", run(&testCase{
resStatus: "403 Forbidden",
resStatusCode: http.StatusForbidden,
contentType: "application/json",
resBody: `{"type": "invalid_request_error", "message": "Quota exceeded for this resource.", "resource": "compute_snapshots_type_b_ssd_available"}`,
expectedError: &QuotasExceededError{
Details: []QuotasExceededErrorDetail{
{
Resource: "compute_snapshots_type_b_ssd_available",
Current: 0,
Quota: 0,
},
},
RawBody: []byte(`{"type": "invalid_request_error", "message": "Quota exceeded for this resource.", "resource": "compute_snapshots_type_b_ssd_available"}`),
},
}))
t.Run("unknown_resource ", run(&testCase{
resStatus: "404 Not Found",
resStatusCode: http.StatusNotFound,
contentType: "application/json",
resBody: `{"type": "unknown_resource", "message": "\"11111111-1111-4111-8111-111111111111\" not found"}`,
expectedError: &ResourceNotFoundError{
ResourceID: "11111111-1111-4111-8111-111111111111",
RawBody: []byte(`{"type": "unknown_resource", "message": "\"11111111-1111-4111-8111-111111111111\" not found"}`),
},
}))
t.Run("unknown_resource bis", run(&testCase{
resStatus: "404 Not Found",
resStatusCode: http.StatusNotFound,
contentType: "application/json",
resBody: `{"type": "unknown_resource", "message": "Security group \"11111111-1111-4111-8111-111111111111\" not found"}`,
expectedError: &ResourceNotFoundError{
ResourceID: "11111111-1111-4111-8111-111111111111",
Resource: "security_group",
RawBody: []byte(`{"type": "unknown_resource", "message": "Security group \"11111111-1111-4111-8111-111111111111\" not found"}`),
},
}))
t.Run("unknown_resource single qupte", run(&testCase{
resStatus: "404 Not Found",
resStatusCode: http.StatusNotFound,
contentType: "application/json",
resBody: `{"type": "unknown_resource", "message": "Volume '11111111-1111-4111-8111-111111111111' not found"}`,
expectedError: &ResourceNotFoundError{
ResourceID: "11111111-1111-4111-8111-111111111111",
Resource: "volume",
RawBody: []byte(`{"type": "unknown_resource", "message": "Volume '11111111-1111-4111-8111-111111111111' not found"}`),
},
}))
t.Run("conflict type", run(&testCase{
resStatus: "409 Conflict",
resStatusCode: http.StatusConflict,
contentType: "application/json",
resBody: `{"message": "Group is in use. You cannot delete it.", "type": "conflict"}`,
expectedError: &ResponseError{
Status: "409 Conflict",
StatusCode: http.StatusConflict,
Message: "group is in use. you cannot delete it.",
Type: "conflict",
RawBody: []byte(`{"message": "Group is in use. You cannot delete it.", "type": "conflict"}`),
},
}))
t.Run("text/plain content type", run(&testCase{
resStatus: "404 Not Found",
resStatusCode: http.StatusNotFound,
contentType: "text/plain",
resBody: ``,
expectedError: &ResponseError{
Status: "404 Not Found",
StatusCode: http.StatusNotFound,
Message: "404 Not Found",
RawBody: []byte(""),
},
}))
}
func TestHasResponseErrorWithValidError(t *testing.T) {
var (
errorMessage = "some message"
errorType = "some type"
errorFields = map[string][]string{"some_field": {"some_value"}}
errorStatusCode = 400
errorStatus = "400 Bad Request"
)
// Create expected error response
testErrorReponse := &ResponseError{
Message: errorMessage,
Type: errorType,
Fields: errorFields,
StatusCode: errorStatusCode,
Status: errorStatus,
RawBody: []byte(`{"message":"some message","type":"some type","fields":{"some_field":["some_value"]}}`),
}
// Create response body with marshalled error response
bodyBytes, err := json.Marshal(testErrorReponse)
testhelpers.AssertNoError(t, err)
res := &http.Response{
Status: errorStatus,
StatusCode: errorStatusCode,
Header: map[string][]string{
"Content-Type": []string{"application/json"},
},
Body: ioutil.NopCloser(bytes.NewReader(bodyBytes)),
}
// Test hasResponseError()
newErr := hasResponseError(res)
testhelpers.Assert(t, newErr != nil, "Should have error")
testhelpers.Equals(t, testErrorReponse, newErr)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/load_config_test.go 0000664 0000000 0000000 00000010317 14563666056 0026706 0 ustar 00root root 0000000 0000000 package scw
import (
"io/ioutil"
"os"
"path/filepath"
"strings"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
// TestLoad tests all valid configuration files:
// - v2 config
// - custom-path with v2 config
// - XDG config path with v2 config
func TestLoad(t *testing.T) {
tests := []struct {
name string
env map[string]string
files map[string]string
expected *Config
expectedError string
expectedFiles map[string]string
}{
// valid config
{
name: "Custom-path config is empty", // custom config path
env: map[string]string{
ScwConfigPathEnv: "{HOME}/valid1/test.conf",
},
files: map[string]string{
"valid1/test.conf": emptyFile,
},
expected: &Config{},
},
{
name: "Custom-path config with valid V2",
env: map[string]string{
ScwConfigPathEnv: "{HOME}/valid3/test.conf",
},
files: map[string]string{
"valid3/test.conf": v2SimpleValidConfigFile,
},
expected: v2SimpleValidConfig,
},
{
name: "Default config with valid V2", // default config path
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2SimpleValidConfigFile,
},
expected: v2SimpleValidConfig,
expectedFiles: map[string]string{
".config/scw/config.yaml": v2SimpleValidConfigFile,
},
},
{
name: "XDG config with valid V2",
env: map[string]string{
"HOME": "{HOME}",
xdgConfigDirEnv: "{HOME}/plop",
},
files: map[string]string{
"plop/scw/config.yaml": v2SimpleValidConfigFile,
},
expected: v2SimpleValidConfig,
},
// errors
{
name: "Err: custom-path config does not exist",
env: map[string]string{
ScwConfigPathEnv: "{HOME}/fake/test.conf",
},
expectedError: "scaleway-sdk-go: cannot read config file {HOME}/fake/test.conf: no such file or directory",
},
{
name: "Err: custom-path config with invalid V2",
env: map[string]string{
ScwConfigPathEnv: "{HOME}/invalid1/test.conf",
},
files: map[string]string{
"invalid1/test.conf": v2SimpleInvalidConfigFile,
},
expectedError: "scaleway-sdk-go: content of config file {HOME}/invalid1/test.conf is invalid: yaml: found unexpected end of stream",
},
{
name: "Err: default config with invalid V2",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2SimpleInvalidConfigFile,
},
expectedError: "scaleway-sdk-go: content of config file {HOME}/.config/scw/config.yaml is invalid: yaml: found unexpected end of stream",
},
{
name: "Err: default config with invalid profile",
env: map[string]string{
"HOME": "{HOME}",
},
files: map[string]string{
".config/scw/config.yaml": v2SimpleConfigFileWithInvalidProfile,
},
expectedError: "scaleway-sdk-go: given profile flantier does not exist",
},
}
// create home dir
dir := initEnv(t)
// delete home dir and reset env variables
defer resetEnv(t, os.Environ(), dir)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
// set up env and config file(s)
setEnv(t, test.env, test.files, dir)
test.expectedError = strings.Replace(test.expectedError, "{HOME}", dir, -1)
// remove config file(s)
defer cleanEnv(t, test.files, dir)
// load config
config, err := LoadConfig()
// test expected outputs
if test.expectedError != "" {
if err == nil {
_, tmpErr := config.GetActiveProfile()
if tmpErr != nil {
testhelpers.Equals(t, test.expectedError, tmpErr.Error())
return
}
}
testhelpers.Assert(t, err != nil, "error should not be nil")
testhelpers.Equals(t, test.expectedError, err.Error())
} else {
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, test.expected, config)
_, err = config.GetActiveProfile()
testhelpers.AssertNoError(t, err)
}
// test expected files
for path, expectedContent := range test.expectedFiles {
targetPath := filepath.Join(dir, path)
content, err := ioutil.ReadFile(targetPath)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, expectedContent, string(content))
testhelpers.AssertNoError(t, os.RemoveAll(targetPath)) // delete at the end
}
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/locality.go 0000664 0000000 0000000 00000013061 14563666056 0025222 0 ustar 00root root 0000000 0000000 package scw
import (
"encoding/json"
"fmt"
"strings"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/logger"
"github.com/scaleway/scaleway-sdk-go/validation"
)
// localityPartsSeparator is the separator used in Zone and Region
const localityPartsSeparator = "-"
// Zone is an availability zone
type Zone string
const (
// ZoneFrPar1 represents the fr-par-1 zone
ZoneFrPar1 = Zone("fr-par-1")
// ZoneFrPar2 represents the fr-par-2 zone
ZoneFrPar2 = Zone("fr-par-2")
// ZoneFrPar3 represents the fr-par-3 zone
ZoneFrPar3 = Zone("fr-par-3")
// ZoneNlAms1 represents the nl-ams-1 zone
ZoneNlAms1 = Zone("nl-ams-1")
// ZoneNlAms2 represents the nl-ams-2 zone
ZoneNlAms2 = Zone("nl-ams-2")
// ZoneNlAms3 represents the nl-ams-3 zone
ZoneNlAms3 = Zone("nl-ams-3")
// ZonePlWaw1 represents the pl-waw-1 zone
ZonePlWaw1 = Zone("pl-waw-1")
// ZonePlWaw2 represents the pl-waw-2 zone
ZonePlWaw2 = Zone("pl-waw-2")
// ZonePlWaw3 represents the pl-waw-3 zone
ZonePlWaw3 = Zone("pl-waw-3")
)
var (
// AllZones is an array that list all zones
AllZones = []Zone{
ZoneFrPar1,
ZoneFrPar2,
ZoneFrPar3,
ZoneNlAms1,
ZoneNlAms2,
ZoneNlAms3,
ZonePlWaw1,
ZonePlWaw2,
ZonePlWaw3,
}
)
// Exists checks whether a zone exists
func (zone Zone) Exists() bool {
for _, z := range AllZones {
if z == zone {
return true
}
}
return false
}
// String returns a Zone as a string
func (zone Zone) String() string {
return string(zone)
}
// Region returns the parent Region for the Zone.
// Manipulates the string directly to allow unlisted zones formatted as xx-yyy-z.
func (zone Zone) Region() (Region, error) {
zoneStr := zone.String()
if !validation.IsZone(zoneStr) {
return "", fmt.Errorf("invalid zone '%v'", zoneStr)
}
zoneParts := strings.Split(zoneStr, localityPartsSeparator)
return Region(strings.Join(zoneParts[:2], localityPartsSeparator)), nil
}
// Region is a geographical location
type Region string
const (
// RegionFrPar represents the fr-par region
RegionFrPar = Region("fr-par")
// RegionNlAms represents the nl-ams region
RegionNlAms = Region("nl-ams")
// RegionPlWaw represents the pl-waw region
RegionPlWaw = Region("pl-waw")
)
var (
// AllRegions is an array that list all regions
AllRegions = []Region{
RegionFrPar,
RegionNlAms,
RegionPlWaw,
}
)
// Exists checks whether a region exists
func (region Region) Exists() bool {
for _, r := range AllRegions {
if r == region {
return true
}
}
return false
}
// GetZones is a function that returns the zones for the specified region
func (region Region) GetZones() []Zone {
switch region {
case RegionFrPar:
return []Zone{ZoneFrPar1, ZoneFrPar2, ZoneFrPar3}
case RegionNlAms:
return []Zone{ZoneNlAms1, ZoneNlAms2, ZoneNlAms3}
case RegionPlWaw:
return []Zone{ZonePlWaw1, ZonePlWaw2, ZonePlWaw3}
default:
return []Zone{}
}
}
// ParseZone parses a string value into a Zone and returns an error if it has a bad format.
func ParseZone(zone string) (Zone, error) {
switch zone {
case "par1":
// would be triggered by API market place
// logger.Warningf("par1 is a deprecated name for zone, use fr-par-1 instead")
return ZoneFrPar1, nil
case "ams1":
// would be triggered by API market place
// logger.Warningf("ams1 is a deprecated name for zone, use nl-ams-1 instead")
return ZoneNlAms1, nil
default:
if !validation.IsZone(zone) {
zones := []string(nil)
for _, z := range AllZones {
zones = append(zones, string(z))
}
return "", errors.New("bad zone format, available zones are: %s", strings.Join(zones, ", "))
}
newZone := Zone(zone)
if !newZone.Exists() {
logger.Infof("%s is an unknown zone\n", newZone)
}
return newZone, nil
}
}
// UnmarshalJSON implements the Unmarshaler interface for a Zone.
// this to call ParseZone on the string input and return the correct Zone object.
func (zone *Zone) UnmarshalJSON(input []byte) error {
// parse input value as string
var stringValue string
err := json.Unmarshal(input, &stringValue)
if err != nil {
return err
}
// parse string as Zone
*zone, err = ParseZone(stringValue)
if err != nil {
return err
}
return nil
}
// ParseRegion parses a string value into a Region and returns an error if it has a bad format.
func ParseRegion(region string) (Region, error) {
switch region {
case "par1":
// would be triggered by API market place
// logger.Warningf("par1 is a deprecated name for region, use fr-par instead")
return RegionFrPar, nil
case "ams1":
// would be triggered by API market place
// logger.Warningf("ams1 is a deprecated name for region, use nl-ams instead")
return RegionNlAms, nil
default:
if !validation.IsRegion(region) {
regions := []string(nil)
for _, r := range AllRegions {
regions = append(regions, string(r))
}
return "", errors.New("bad region format, available regions are: %s", strings.Join(regions, ", "))
}
newRegion := Region(region)
if !newRegion.Exists() {
logger.Infof("%s is an unknown region\n", newRegion)
}
return newRegion, nil
}
}
// UnmarshalJSON implements the Unmarshaler interface for a Region.
// this to call ParseRegion on the string input and return the correct Region object.
func (region *Region) UnmarshalJSON(input []byte) error {
// parse input value as string
var stringValue string
err := json.Unmarshal(input, &stringValue)
if err != nil {
return err
}
// parse string as Region
*region, err = ParseRegion(stringValue)
if err != nil {
return err
}
return nil
}
// String returns a Region as a string
func (region Region) String() string {
return string(region)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/locality_test.go 0000664 0000000 0000000 00000005761 14563666056 0026271 0 ustar 00root root 0000000 0000000 package scw
import (
"encoding/json"
"testing"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
func TestParseZone(t *testing.T) {
tests := []struct {
input string
err error
expected Zone
}{
{
input: "fr-par-1",
expected: ZoneFrPar1,
},
{
input: "pl-waw-1",
expected: ZonePlWaw1,
},
{
input: "pl-waw-2",
expected: ZonePlWaw2,
},
{
input: "pl-waw-3",
expected: ZonePlWaw3,
},
{
input: "nl-ams-2",
expected: ZoneNlAms2,
},
{
input: "nl-ams-3",
expected: ZoneNlAms3,
},
{
input: "par1",
expected: ZoneFrPar1,
},
{
input: "ams1",
expected: ZoneNlAms1,
},
{
input: "xx-xxx-1",
expected: "xx-xxx-1",
},
{
input: "fr-par",
expected: "",
err: errors.New("bad zone format, available zones are: fr-par-1, fr-par-2, fr-par-3, nl-ams-1, nl-ams-2, nl-ams-3, pl-waw-1, pl-waw-2, pl-waw-3"),
},
{
input: "fr-par-n",
expected: "",
err: errors.New("bad zone format, available zones are: fr-par-1, fr-par-2, fr-par-3, nl-ams-1, nl-ams-2, nl-ams-3, pl-waw-1, pl-waw-2, pl-waw-3"),
},
{
input: "fr-par-0",
expected: "",
err: errors.New("bad zone format, available zones are: fr-par-1, fr-par-2, fr-par-3, nl-ams-1, nl-ams-2, nl-ams-3, pl-waw-1, pl-waw-2, pl-waw-3"),
},
}
for _, test := range tests {
t.Run(test.input, func(t *testing.T) {
z, err := ParseZone(test.input)
testhelpers.Equals(t, test.err, err)
testhelpers.Equals(t, test.expected, z)
})
}
}
func TestZoneJSONUnmarshall(t *testing.T) {
t.Run("test with zone", func(t *testing.T) {
input := `{"Test": "par1"}`
value := struct{ Test Zone }{}
err := json.Unmarshal([]byte(input), &value)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, ZoneFrPar1, value.Test)
})
t.Run("test with region", func(t *testing.T) {
input := `{"Test": "par1"}`
value := struct{ Test Region }{}
err := json.Unmarshal([]byte(input), &value)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, RegionFrPar, value.Test)
})
}
func TestParseRegion(t *testing.T) {
tests := []struct {
input string
err error
expected Region
}{
{
input: "fr-par",
expected: RegionFrPar,
},
{
input: "par1",
expected: RegionFrPar,
},
{
input: "ams1",
expected: RegionNlAms,
},
{
input: "pl-waw",
expected: RegionPlWaw,
},
{
input: "xx-xxx",
expected: "xx-xxx",
},
{
input: "fr-par-1",
expected: "",
err: errors.New("bad region format, available regions are: fr-par, nl-ams, pl-waw"),
},
{
input: "fr-pa1",
expected: "",
err: errors.New("bad region format, available regions are: fr-par, nl-ams, pl-waw"),
},
}
for _, test := range tests {
t.Run(test.input, func(t *testing.T) {
r, err := ParseRegion(test.input)
testhelpers.Equals(t, test.err, err)
testhelpers.Equals(t, test.expected, r)
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/path.go 0000664 0000000 0000000 00000004470 14563666056 0024342 0 ustar 00root root 0000000 0000000 package scw
import (
"errors"
"os"
"path/filepath"
)
const (
// XDG wiki: https://wiki.archlinux.org/index.php/XDG_Base_Directory
xdgConfigDirEnv = "XDG_CONFIG_HOME"
xdgCacheDirEnv = "XDG_CACHE_HOME"
unixHomeDirEnv = "HOME"
windowsHomeDirEnv = "USERPROFILE"
defaultConfigFileName = "config.yaml"
)
var (
// ErrNoHomeDir errors when no user directory is found
ErrNoHomeDir = errors.New("user home directory not found")
)
// GetCacheDirectory returns the default cache directory.
// Cache directory is based on the following priority order:
// - $SCW_CACHE_DIR
// - $XDG_CACHE_HOME/scw
// - $HOME/.cache/scw
// - $USERPROFILE/.cache/scw
func GetCacheDirectory() string {
cacheDir := ""
switch {
case os.Getenv(ScwCacheDirEnv) != "":
cacheDir = os.Getenv(ScwCacheDirEnv)
case os.Getenv(xdgCacheDirEnv) != "":
cacheDir = filepath.Join(os.Getenv(xdgCacheDirEnv), "scw")
case os.Getenv(unixHomeDirEnv) != "":
cacheDir = filepath.Join(os.Getenv(unixHomeDirEnv), ".cache", "scw")
case os.Getenv(windowsHomeDirEnv) != "":
cacheDir = filepath.Join(os.Getenv(windowsHomeDirEnv), ".cache", "scw")
default:
// TODO: fallback on local folder?
}
// Clean the cache directory path when exiting the function
return filepath.Clean(cacheDir)
}
// GetConfigPath returns the default path.
// Default path is based on the following priority order:
// - $SCW_CONFIG_PATH
// - $XDG_CONFIG_HOME/scw/config.yaml
// - $HOME/.config/scw/config.yaml
// - $USERPROFILE/.config/scw/config.yaml
func GetConfigPath() string {
configPath := os.Getenv(ScwConfigPathEnv)
if configPath == "" {
configPath, _ = getConfigV2FilePath()
}
return filepath.Clean(configPath)
}
// getConfigV2FilePath returns the path to the v2 config file
func getConfigV2FilePath() (string, bool) {
configDir, err := GetScwConfigDir()
if err != nil {
return "", false
}
return filepath.Clean(filepath.Join(configDir, defaultConfigFileName)), true
}
// GetScwConfigDir returns the path to scw config folder
func GetScwConfigDir() (string, error) {
if xdgPath := os.Getenv(xdgConfigDirEnv); xdgPath != "" {
return filepath.Join(xdgPath, "scw"), nil
}
homeDir, err := os.UserHomeDir()
if err != nil {
return "", err
}
return filepath.Join(homeDir, ".config", "scw"), nil
}
func fileExist(name string) bool {
_, err := os.Stat(name)
return err == nil
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/request.go 0000664 0000000 0000000 00000004065 14563666056 0025076 0 ustar 00root root 0000000 0000000 package scw
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/url"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/internal/errors"
)
// ScalewayRequest contains all the contents related to performing a request on the Scaleway API.
type ScalewayRequest struct {
Method string
Path string
Headers http.Header
Query url.Values
Body io.Reader
// request options
ctx context.Context
auth auth.Auth
allPages bool
zones []Zone
regions []Region
}
// getURL constructs a URL based on the base url and the client.
func (req *ScalewayRequest) getURL(baseURL string) (*url.URL, error) {
url, err := url.Parse(baseURL + req.Path)
if err != nil {
return nil, errors.New("invalid url %s: %s", baseURL+req.Path, err)
}
url.RawQuery = req.Query.Encode()
return url, nil
}
// SetBody json marshal the given body and write the json content type
// to the request. It also catches when body is a file.
func (req *ScalewayRequest) SetBody(body interface{}) error {
var contentType string
var content io.Reader
switch b := body.(type) {
case *File:
contentType = b.ContentType
content = b.Content
case io.Reader:
contentType = "text/plain"
content = b
default:
buf, err := json.Marshal(body)
if err != nil {
return err
}
contentType = "application/json"
content = bytes.NewReader(buf)
}
if req.Headers == nil {
req.Headers = http.Header{}
}
req.Headers.Set("Content-Type", contentType)
req.Body = content
return nil
}
func (req *ScalewayRequest) apply(opts []RequestOption) {
for _, opt := range opts {
opt(req)
}
}
func (req *ScalewayRequest) validate() error {
// nothing so far
return nil
}
func (req *ScalewayRequest) clone() *ScalewayRequest {
clonedReq := &ScalewayRequest{
Method: req.Method,
Path: req.Path,
Headers: req.Headers.Clone(),
ctx: req.ctx,
auth: req.auth,
allPages: req.allPages,
zones: req.zones,
}
if req.Query != nil {
clonedReq.Query = url.Values(http.Header(req.Query).Clone())
}
return clonedReq
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/request_header.go 0000664 0000000 0000000 00000001307 14563666056 0026402 0 ustar 00root root 0000000 0000000 //go:build !wasm || !js
package scw
import (
"net/http"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
)
// getAllHeaders constructs a http.Header object and aggregates all headers into the object.
func (req *ScalewayRequest) getAllHeaders(token auth.Auth, userAgent string, anonymized bool) http.Header {
var allHeaders http.Header
if anonymized {
allHeaders = token.AnonymizedHeaders()
} else {
allHeaders = token.Headers()
}
allHeaders.Set("User-Agent", userAgent)
if req.Body != nil {
allHeaders.Set("Content-Type", "application/json")
}
for key, value := range req.Headers {
allHeaders.Del(key)
for _, v := range value {
allHeaders.Add(key, v)
}
}
return allHeaders
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/request_header_wasm.go 0000664 0000000 0000000 00000001307 14563666056 0027431 0 ustar 00root root 0000000 0000000 //go:build wasm && js
package scw
import (
"net/http"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
)
// getAllHeaders constructs a http.Header object and aggregates all headers into the object.
func (req *ScalewayRequest) getAllHeaders(token auth.Auth, userAgent string, anonymized bool) http.Header {
var allHeaders http.Header
if anonymized {
allHeaders = token.AnonymizedHeaders()
} else {
allHeaders = token.Headers()
}
allHeaders.Set("X-User-Agent", userAgent)
if req.Body != nil {
allHeaders.Set("Content-Type", "application/json")
}
for key, value := range req.Headers {
allHeaders.Del(key)
for _, v := range value {
allHeaders.Add(key, v)
}
}
return allHeaders
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/request_option.go 0000664 0000000 0000000 00000003020 14563666056 0026454 0 ustar 00root root 0000000 0000000 package scw
import (
"context"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
)
// RequestOption is a function that applies options to a ScalewayRequest.
type RequestOption func(*ScalewayRequest)
// WithContext request option sets the context of a ScalewayRequest
func WithContext(ctx context.Context) RequestOption {
return func(s *ScalewayRequest) {
s.ctx = ctx
}
}
// WithAllPages aggregate all pages in the response of a List request.
// Will error when pagination is not supported on the request.
func WithAllPages() RequestOption {
return func(s *ScalewayRequest) {
s.allPages = true
}
}
// WithAuthRequest overwrites the client access key and secret key used in the request.
func WithAuthRequest(accessKey, secretKey string) RequestOption {
return func(s *ScalewayRequest) {
s.auth = auth.NewToken(accessKey, secretKey)
}
}
// WithZones aggregate results from requested zones in the response of a List request.
// response rows are sorted by zone using order of given zones
// Will error when pagination is not supported on the request.
func WithZones(zones ...Zone) RequestOption {
return func(s *ScalewayRequest) {
s.zones = append(s.zones, zones...)
}
}
// WithRegions aggregate results from requested regions in the response of a List request.
// response rows are sorted by region using order of given regions
// Will error when pagination is not supported on the request.
func WithRegions(regions ...Region) RequestOption {
return func(s *ScalewayRequest) {
s.regions = append(s.regions, regions...)
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/request_test.go 0000664 0000000 0000000 00000006626 14563666056 0026142 0 ustar 00root root 0000000 0000000 package scw
import (
"bytes"
"fmt"
"net/http"
"net/url"
"testing"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
const (
testBaseURL = "http://example.com"
testPath = "/some/path/"
testKey = "some_key"
testValue = "some_value"
testBody = "some body"
testUserAgent = "user/agent"
testHeaderKey = "Some-Header-Key"
testHeaderVal = "some_header_val"
testTokenKey = "some_secret_key"
)
func TestGetURL(t *testing.T) {
req := ScalewayRequest{
Path: testPath,
Query: url.Values{
testKey: []string{testValue},
},
}
newURL, err := req.getURL(testBaseURL)
testhelpers.AssertNoError(t, err)
expectedURL := fmt.Sprintf("%s%s?%s=%s", testBaseURL, testPath, testKey, testValue)
testhelpers.Equals(t, expectedURL, newURL.String())
}
func TestGetHeadersWithoutBody(t *testing.T) {
req := ScalewayRequest{
Headers: http.Header{
testHeaderKey: []string{testHeaderVal},
},
}
token := auth.NewToken(testAccessKey, testTokenKey)
expectedHeaders := http.Header{
testHeaderKey: []string{testHeaderVal},
"X-Auth-Token": []string{testTokenKey},
"User-Agent": []string{testUserAgent},
}
allHeaders := req.getAllHeaders(token, testUserAgent, false)
testhelpers.Equals(t, expectedHeaders, allHeaders)
}
func TestGetHeadersWithBody(t *testing.T) {
req := ScalewayRequest{
Headers: http.Header{
testHeaderKey: []string{testHeaderVal},
},
Body: bytes.NewReader([]byte(testBody)),
}
token := auth.NewToken(testSecretKey, testTokenKey)
expectedHeaders := http.Header{
testHeaderKey: []string{testHeaderVal},
"X-Auth-Token": []string{testTokenKey},
"Content-Type": []string{"application/json"},
"User-Agent": []string{testUserAgent},
}
allHeaders := req.getAllHeaders(token, testUserAgent, false)
testhelpers.Equals(t, expectedHeaders, allHeaders)
}
func TestSetBody(t *testing.T) {
body := struct {
Region Region `json:"-"`
ID string `json:"-"`
Name string `json:"name,omitempty"`
Slice []string `json:"slice,omitempty"`
Flag bool `json:"flag,omitempty"`
Timeout *time.Duration `json:"timeout,omitempty"`
}{
Region: RegionNlAms,
ID: "plop",
Name: "plop",
Slice: []string{"plop", "plop"},
Flag: true,
Timeout: TimeDurationPtr(time.Second),
}
req := ScalewayRequest{
Headers: http.Header{},
}
testhelpers.AssertNoError(t, req.SetBody(body))
r, isBytesReader := req.Body.(*bytes.Reader)
testhelpers.Assert(t, isBytesReader, "req.Body should be bytes Reader")
b := make([]byte, r.Len())
_, err := r.Read(b)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, []string{"application/json"}, req.Headers["Content-Type"])
testhelpers.Equals(t, `{"name":"plop","slice":["plop","plop"],"flag":true,"timeout":1000000000}`, string(b))
}
func TestSetFileBody(t *testing.T) {
body := &File{
Content: bytes.NewReader([]byte(testBody)),
ContentType: "plain/text",
}
req := ScalewayRequest{
Headers: http.Header{},
}
testhelpers.AssertNoError(t, req.SetBody(body))
r, isBytesReader := req.Body.(*bytes.Reader)
testhelpers.Assert(t, isBytesReader, "req.Body should be bytes Reader")
b := make([]byte, r.Len())
_, err := r.Read(b)
testhelpers.AssertNoError(t, err)
testhelpers.Equals(t, []string{"plain/text"}, req.Headers["Content-Type"])
testhelpers.Equals(t, `some body`, string(b))
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/transport.go 0000664 0000000 0000000 00000003427 14563666056 0025443 0 ustar 00root root 0000000 0000000 package scw
import (
"net/http"
"net/http/httputil"
"sync/atomic"
"github.com/scaleway/scaleway-sdk-go/internal/auth"
"github.com/scaleway/scaleway-sdk-go/logger"
)
type requestLoggerTransport struct {
rt http.RoundTripper
// requestNumber auto increments on each do().
// This allows easy distinguishing of concurrently performed requests in log.
requestNumber uint32
}
func (l *requestLoggerTransport) RoundTrip(request *http.Request) (*http.Response, error) {
currentRequestNumber := atomic.AddUint32(&l.requestNumber, 1)
// Keep original headers (before anonymization)
originalHeaders := request.Header
// Get anonymized headers
request.Header = auth.AnonymizeHeaders(request.Header.Clone())
dump, err := httputil.DumpRequestOut(request, true)
if err != nil {
logger.Warningf("cannot dump outgoing request: %s", err)
} else {
var logString string
logString += "\n--------------- Scaleway SDK REQUEST %d : ---------------\n"
logString += "%s\n"
logString += "---------------------------------------------------------"
logger.Debugf(logString, currentRequestNumber, dump)
}
// Restore original headers before sending the request
request.Header = originalHeaders
response, requestError := l.rt.RoundTrip(request)
if requestError != nil {
_, isSdkError := requestError.(SdkError)
if !isSdkError {
return response, requestError
}
}
dump, err = httputil.DumpResponse(response, true)
if err != nil {
logger.Warningf("cannot dump ingoing response: %s", err)
} else {
var logString string
logString += "\n--------------- Scaleway SDK RESPONSE %d : ---------------\n"
logString += "%s\n"
logString += "----------------------------------------------------------"
logger.Debugf(logString, currentRequestNumber, dump)
}
return response, requestError
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/scw/version.go 0000664 0000000 0000000 00000000345 14563666056 0025070 0 ustar 00root root 0000000 0000000 package scw
import (
"fmt"
"runtime"
)
// TODO: versioning process
const version = "v1.0.0-beta.7+dev"
var userAgent = fmt.Sprintf("scaleway-sdk-go/%s (%s; %s; %s)", version, runtime.Version(), runtime.GOOS, runtime.GOARCH)
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/sdk_compilation_test.go 0000664 0000000 0000000 00000001473 14563666056 0027030 0 ustar 00root root 0000000 0000000 package scalewaysdkgo
// This test file makes sure that all the auto-generated code compiles.
import (
_ "github.com/scaleway/scaleway-sdk-go/api/account/v2alpha1"
_ "github.com/scaleway/scaleway-sdk-go/api/baremetal/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/domain/v2beta1"
_ "github.com/scaleway/scaleway-sdk-go/api/instance/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/iot/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/k8s/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/lb/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/marketplace/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/registry/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/test/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/vpc/v1"
_ "github.com/scaleway/scaleway-sdk-go/api/vpcgw/v1"
)
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/ 0000775 0000000 0000000 00000000000 14563666056 0023722 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/bash_arg.go 0000664 0000000 0000000 00000003315 14563666056 0026021 0 ustar 00root root 0000000 0000000 package strcase
import "strings"
var customBashNames = map[string]string{
"aclid": "acl-id",
"ipid": "ip-id",
"lbid": "lb-id",
"dhcpid": "dhcp-id",
}
// ToBashArg returns the Bash public name of the given string.
func ToBashArg(s string) string {
s = ToPublicGoName(s)
if customBashName, exists := customBashNames[strings.ToLower(s)]; exists {
return customBashName
}
for _, initialism := range customInitialisms {
// catch this kind of pattern: ExampleIDs ==> ExampleIds ==> example-ids
s = strings.Replace(s, initialism[0], strings.Title(strings.ToLower(initialism[0])), -1)
}
return toKebab(s)
}
// toKebab converts a string to kebab-case.
func toKebab(s string) string {
return toDelimited(s, '-')
}
// toDelimited converts a string to delimited lowercase.
func toDelimited(s string, del uint8) string {
s = strings.Trim(s, " ")
n := ""
for i, v := range s {
// treat acronyms as words, eg for JSONData -> JSON is a whole word
nextCaseIsChanged := false
if i+1 < len(s) {
next := s[i+1]
if (isUpperLetter(v) && isLowerLetter(int32(next))) || (isLowerLetter(v) && isUpperLetter(int32(next))) {
nextCaseIsChanged = true
}
}
if i > 0 && n[len(n)-1] != del && nextCaseIsChanged {
// add delimiter if next letter case type is changed
if isUpperLetter(v) {
n += string(del) + string(v)
} else if isLowerLetter(v) {
n += string(v) + string(del)
}
} else if v == ' ' || v == '-' || v == '_' {
// replace spaces and dashes with delimiter
n += string(del)
} else {
n = n + string(v)
}
}
n = strings.ToLower(n)
return n
}
func isUpperLetter(c int32) bool {
return c >= 'A' && c <= 'Z'
}
func isLowerLetter(c int32) bool {
return c >= 'a' && c <= 'z'
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/bash_arg_test.go 0000664 0000000 0000000 00000001510 14563666056 0027053 0 ustar 00root root 0000000 0000000 package strcase
import (
"testing"
)
func TestToKebabCase(t *testing.T) {
cases := []struct {
in string
want string
}{
{"testCase", "test-case"},
{"TestCase", "test-case"},
{"Test Case", "test-case"},
{" Test Case", "test-case"},
{"Test Case ", "test-case"},
{" Test Case ", "test-case"},
{"test", "test"},
{"test_case", "test-case"},
{"Test", "test"},
{"", ""},
{"ManyManyWords", "many-many-words"},
{"manyManyWords", "many-many-words"},
{"AnyKind of_string", "any-kind-of-string"},
{"numbers2and55with000", "numbers2and55with000"},
{"JSONData", "json-data"},
{"userID", "user-id"},
{"AAAbbb", "aa-abbb"},
}
for _, c := range cases {
t.Run(c.in, func(t *testing.T) {
got := toKebab(c.in)
if got != c.want {
t.Errorf("toKebab(%q) == %q, want %q", c.in, got, c.want)
}
})
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/camel.go 0000664 0000000 0000000 00000000334 14563666056 0025332 0 ustar 00root root 0000000 0000000 package strcase
import "strings"
func ToCamel(s string) string {
if s == "" {
return s
}
if r := rune(s[0]); r >= 'A' && r <= 'Z' {
s = strings.ToLower(string(r)) + s[1:]
}
return toPascalInitCase(s, false)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/camel_test.go 0000664 0000000 0000000 00000000553 14563666056 0026374 0 ustar 00root root 0000000 0000000 package strcase
import (
"testing"
)
func TestToCamel(t *testing.T) {
cases := [][]string{
{"foo-bar", "fooBar"},
{"TestCase", "testCase"},
{"", ""},
{"AnyKind of_string", "anyKindOfString"},
}
for _, i := range cases {
in := i[0]
out := i[1]
result := ToCamel(in)
if result != out {
t.Error("'" + result + "' != '" + out + "'")
}
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/goname.go 0000664 0000000 0000000 00000011630 14563666056 0025520 0 ustar 00root root 0000000 0000000 package strcase
import (
"strings"
"unicode"
)
// ToPrivateGoName returns the Go public name of the given string.
func ToPublicGoName(s string) string {
return toGoName(TitleFirstWord(s))
}
// ToPrivateGoName returns the Go private name of the given string.
func ToPrivateGoName(s string) string {
return toGoName(lowerCaseFirstLetterOrAcronyms(s))
}
// toGoName returns a different name if it should be different.
func toGoName(name string) (should string) {
name = strings.Replace(name, " ", "_", -1)
name = strings.Replace(name, "-", "_", -1)
// Fast path for simple cases: "_" and all lowercase.
if name == "_" {
return name
}
allLower := true
for _, r := range name {
if !unicode.IsLower(r) {
allLower = false
break
}
}
if allLower {
return name
}
// Split camelCase at any lower->upper transition, and split on underscores.
// Check each word for common initialisms.
runes := []rune(name)
w, i := 0, 0 // index of start of word, scan
for i+1 <= len(runes) {
eow := false // whether we hit the end of a word
if i+1 == len(runes) {
eow = true
} else if runes[i+1] == '_' {
// underscore; shift the remainder forward over any run of underscores
eow = true
n := 1
for i+n+1 < len(runes) && runes[i+n+1] == '_' {
n++
}
// Leave at most one underscore if the underscore is between two digits
if i+n+1 < len(runes) && unicode.IsDigit(runes[i]) && unicode.IsDigit(runes[i+n+1]) {
n--
}
copy(runes[i+1:], runes[i+n+1:])
runes = runes[:len(runes)-n]
} else if unicode.IsLower(runes[i]) && !unicode.IsLower(runes[i+1]) {
// lower->non-lower
eow = true
}
i++
if !eow {
continue
}
// [w,i) is a word.
word := string(runes[w:i])
u := strings.ToUpper(word)
if commonInitialisms[u] {
// Keep consistent case, which is lowercase only at the start.
if w == 0 && unicode.IsLower(runes[w]) {
u = strings.ToLower(u)
}
// All the common initialisms are ASCII,
// so we can replace the bytes exactly.
copy(runes[w:], []rune(u))
} else if specialCase, exist := customInitialisms[u]; exist {
if w == 0 && unicode.IsLower(runes[w]) {
u = specialCase[1]
} else {
u = specialCase[0]
}
copy(runes[w:], []rune(u))
} else if w > 0 && strings.ToLower(word) == word {
// already all lowercase, and not the first word, so uppercase the first character.
runes[w] = unicode.ToUpper(runes[w])
}
w = i
}
return string(runes)
}
// Deprecated: this list should not be completed as it affects generation for our Go SDK only.
//
// commonInitialisms is a set of common initialisms.
// Only add entries that are highly unlikely to be non-initialisms.
// For instance, "ID" is fine (Freudian code is rare), but "AND" is not.
var commonInitialisms = map[string]bool{
"ACL": true,
"API": true,
"ASCII": true,
"CPU": true,
"CSS": true,
"DHCP": true,
"DNS": true,
"EOF": true,
"GUID": true,
"HTML": true,
"HTTP": true,
"HTTPS": true,
"ID": true,
"IP": true,
"JSON": true,
"LB": true,
"LHS": true,
"QPS": true,
"RAM": true,
"RHS": true,
"RPC": true,
"SLA": true,
"SMTP": true,
"SQL": true,
"SSD": true,
"SSH": true,
"TCP": true,
"TLS": true,
"TTL": true,
"UDP": true,
"UI": true,
"UID": true,
"UUID": true,
"URI": true,
"URL": true,
"UTF8": true,
"VM": true,
"XML": true,
"XMPP": true,
"XSRF": true,
"XSS": true,
}
// customInitialisms is a set of common initialisms we use at Scaleway.
// value[0] is the uppercase replacement
// value[1] is the lowercase replacement
var customInitialisms = map[string][2]string{
"ACLS": {"ACLs", "acls"},
"APIS": {"APIs", "apis"},
"CPUS": {"CPUs", "cpus"},
"IDS": {"IDs", "ids"},
"IPS": {"IPs", "ips"},
"IPV": {"IPv", "ipv"}, // handle IPV4 && IPV6
"LBS": {"LBs", "lbs"},
"UIDS": {"UIDs", "uids"},
"UUIDS": {"UUIDs", "uuids"},
"URIS": {"URIs", "uris"},
"URLS": {"URLs", "urls"},
}
// TitleFirstWord upper case the first letter of a string.
func TitleFirstWord(s string) string {
if s == "" {
return s
}
r := []rune(s)
r[0] = unicode.ToUpper(r[0])
return string(r)
}
// UntitleFirstWord lower case the first letter of a string.
func UntitleFirstWord(s string) string {
if s == "" {
return s
}
r := []rune(s)
firstWord := strings.Split(s, " ")[0]
_, isCommonInitialism := commonInitialisms[firstWord]
_, isCustomInitialism := customInitialisms[firstWord]
if !isCommonInitialism && !isCustomInitialism {
r[0] = unicode.ToLower(r[0])
}
return string(r)
}
// lowerCaseFirstLetterOrAcronyms lower case the first letter of a string.
func lowerCaseFirstLetterOrAcronyms(s string) string {
r := []rune(s)
if len(r) == 0 {
return ""
}
for i := 0; len(r) > i && unicode.IsUpper(r[i]); i++ {
word := string(r[:i+1])
if u := strings.ToUpper(word); commonInitialisms[u] {
copy(r[0:], []rune(strings.ToLower(u)))
break
}
}
r[0] = unicode.ToLower(r[0])
return string(r)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/goname_test.go 0000664 0000000 0000000 00000002530 14563666056 0026556 0 ustar 00root root 0000000 0000000 package strcase
import "testing"
func TestLowerCaseFirstLetterOrAcronyms(t *testing.T) {
cases := []struct {
in string
want string
}{
{"", ""},
{"t", "t"},
{"Test Case", "test Case"},
{"test Case", "test Case"},
{"TEST CASE", "tEST CASE"},
{"tEST CASE", "tEST CASE"},
{"#EST CASE", "#EST CASE"},
{"APITest", "apiTest"},
{"AVATATest", "aVATATest"},
{"TestStuff", "testStuff"},
}
for _, c := range cases {
result := lowerCaseFirstLetterOrAcronyms(c.in)
if result != c.want {
t.Errorf("lowerCaseFirstLetterOrAcronyms(%q) == %q, want %q", c.in, result, c.want)
}
}
}
func TestTitleFirstWord(t *testing.T) {
cases := [][]string{
{"", ""},
{"t", "T"},
{"Test Case", "Test Case"},
{"test Case", "Test Case"},
{"test case", "Test case"},
{"TEST CASE", "TEST CASE"},
{"tEST CASE", "TEST CASE"},
{"#EST CASE", "#EST CASE"},
}
for _, i := range cases {
in := i[0]
out := i[1]
result := TitleFirstWord(in)
if result != out {
t.Error("'" + result + "' != '" + out + "'")
}
}
}
func Test_UntitleFirstWord(t *testing.T) {
cases := [][]string{
{"", ""},
{"T", "t"},
{"UUID", "UUID"},
{"UUI", "uUI"},
{"TEST CASE", "tEST CASE"},
}
for _, i := range cases {
in := i[0]
out := i[1]
result := UntitleFirstWord(in)
if result != out {
t.Error("'" + result + "' != '" + out + "'")
}
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/kebab.go 0000664 0000000 0000000 00000000422 14563666056 0025313 0 ustar 00root root 0000000 0000000 package strcase
import "strings"
// Converts a string to kebab-case
func ToKebab(s string) string {
return strings.Replace(ToSnake(s), "_", "-", -1)
}
// Converts a string to kebab-case
func ToSpace(s string) string {
return strings.Replace(ToSnake(s), "_", " ", -1)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/kebab_test.go 0000664 0000000 0000000 00000001410 14563666056 0026350 0 ustar 00root root 0000000 0000000 package strcase
import (
"testing"
)
func TestToKebab(t *testing.T) {
cases := [][]string{
{"testCase", "test-case"},
{"TestCase", "test-case"},
{"Test Case", "test-case"},
{" Test Case", "test-case"},
{"Test Case ", "test-case"},
{" Test Case ", "test-case"},
{"test", "test"},
{"test_case", "test-case"},
{"Test", "test"},
{"", ""},
{"ManyManyWords", "many-many-words"},
{"manyManyWords", "many-many-words"},
{"AnyKind of_string", "any-kind-of-string"},
{"numbers2and55with000", "numbers2and55with000"},
{"JSONData", "json-data"},
{"userID", "user-id"},
{"AAAbbb", "aa-abbb"},
}
for _, i := range cases {
in := i[0]
out := i[1]
result := ToKebab(in)
if result != out {
t.Error("'" + result + "' != '" + out + "'")
}
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/number.go 0000664 0000000 0000000 00000000445 14563666056 0025544 0 ustar 00root root 0000000 0000000 package strcase
import (
"regexp"
)
var numberSequence = regexp.MustCompile(`([a-zA-Z])(\d+)([a-zA-Z]?)`)
var numberReplacement = []byte(`$1 $2 $3`)
func addWordBoundariesToNumbers(s string) string {
b := []byte(s)
b = numberSequence.ReplaceAll(b, numberReplacement)
return string(b)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/pascal.go 0000664 0000000 0000000 00000001174 14563666056 0025517 0 ustar 00root root 0000000 0000000 package strcase
import "strings"
// Converts a string to CamelCase
func toPascalInitCase(s string, initCase bool) string {
s = addWordBoundariesToNumbers(s)
s = strings.Trim(s, " ")
n := ""
capNext := initCase
for _, v := range s {
if v >= 'A' && v <= 'Z' {
n += string(v)
}
if v >= '0' && v <= '9' {
n += string(v)
}
if v >= 'a' && v <= 'z' {
if capNext {
n += strings.ToUpper(string(v))
} else {
n += string(v)
}
}
if v == '_' || v == ' ' || v == '-' {
capNext = true
} else {
capNext = false
}
}
return n
}
func ToPascal(s string) string {
return toPascalInitCase(s, true)
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/pascal_test.go 0000664 0000000 0000000 00000001025 14563666056 0026551 0 ustar 00root root 0000000 0000000 package strcase
import "testing"
func TestToPascal(t *testing.T) {
cases := [][]string{
{"test_case", "TestCase"},
{"test", "Test"},
{"TestCase", "TestCase"},
{" test case ", "TestCase"},
{"", ""},
{"many_many_words", "ManyManyWords"},
{"AnyKind of_string", "AnyKindOfString"},
{"odd-fix", "OddFix"},
{"numbers2And55with000", "Numbers2And55With000"},
}
for _, i := range cases {
in := i[0]
out := i[1]
result := ToPascal(in)
if result != out {
t.Error("'" + result + "' != '" + out + "'")
}
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/snake.go 0000664 0000000 0000000 00000001516 14563666056 0025355 0 ustar 00root root 0000000 0000000 package strcase
import (
"strings"
)
// Converts a string to snake_case
func ToSnake(s string) string {
s = strings.Trim(s, " ")
n := ""
for i, v := range s {
// treat acronyms as words, eg for JSONData -> JSON is a whole word
nextCaseIsChanged := false
if i+1 < len(s) {
next := s[i+1]
if (isUpperLetter(v) && isLowerLetter(int32(next))) || (isLowerLetter(v) && isUpperLetter(int32(next))) {
nextCaseIsChanged = true
}
}
if i > 0 && n[len(n)-1] != '_' && nextCaseIsChanged {
// add underscore if next letter case type is changed
if isUpperLetter(v) {
n += "_" + string(v)
} else if isLowerLetter(v) {
n += string(v) + "_"
}
} else if v == ' ' || v == '-' {
// replace spaces and dashes with underscores
n += "_"
} else {
n = n + string(v)
}
}
n = strings.ToLower(n)
return n
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/snake_test.go 0000664 0000000 0000000 00000001534 14563666056 0026414 0 ustar 00root root 0000000 0000000 package strcase
import (
"testing"
)
func TestToSnake(t *testing.T) {
cases := [][2]string{
{"testCase", "test_case"},
{"TestCase", "test_case"},
{"Test Case", "test_case"},
{" Test Case", "test_case"},
{"Test Case ", "test_case"},
{" Test Case ", "test_case"},
{"test", "test"},
{"test_case", "test_case"},
{"Test", "test"},
{"", ""},
{"ManyManyWords", "many_many_words"},
{"manyManyWords", "many_many_words"},
{"AnyKind of_string", "any_kind_of_string"},
{"numbers2and55with000", "numbers2and55with000"},
{"ip-v6", "ip_v6"},
{"ipV6", "ip_v6"},
{"IPV6", "ipv6"},
{"ipv6", "ipv6"},
{"JSONData", "json_data"},
{"userID", "user_id"},
{"AAAbbb", "aa_abbb"},
}
for _, i := range cases {
in := i[0]
out := i[1]
result := ToSnake(in)
if result != out {
t.Error("'" + result + "' != '" + out + "'")
}
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/strcase/strcase_test.go 0000664 0000000 0000000 00000005120 14563666056 0026752 0 ustar 00root root 0000000 0000000 package strcase
import (
"testing"
)
func TestAllStrCases(t *testing.T) {
tests := []struct {
name, publicGoName, privateGoName, bashArgName string
}{
{"foo_bar", "FooBar", "fooBar", "foo-bar"},
{"foo_bar_baz", "FooBarBaz", "fooBarBaz", "foo-bar-baz"},
{"Foo_bar", "FooBar", "fooBar", "foo-bar"},
{"foo_WiFi", "FooWiFi", "fooWiFi", "foo-wi-fi"},
{"id", "ID", "id", "id"},
{"Id", "ID", "id", "id"},
{"foo_id", "FooID", "fooID", "foo-id"},
{"fooId", "FooID", "fooID", "foo-id"},
{"fooUid", "FooUID", "fooUID", "foo-uid"},
{"idFoo", "IDFoo", "idFoo", "id-foo"},
{"uidFoo", "UIDFoo", "uidFoo", "uid-foo"},
{"midIdDle", "MidIDDle", "midIDDle", "mid-id-dle"},
{"APIProxy", "APIProxy", "apiProxy", "api-proxy"},
{"ApiProxy", "APIProxy", "apiProxy", "api-proxy"},
{"apiProxy", "APIProxy", "apiProxy", "api-proxy"},
{"_Leading", "_Leading", "_Leading", "-leading"},
{"___Leading", "_Leading", "_Leading", "-leading"},
{"trailing_", "Trailing", "trailing", "trailing"},
{"trailing___", "Trailing", "trailing", "trailing"},
{"a_b", "AB", "aB", "ab"},
{"a__b", "AB", "aB", "ab"},
{"a___b", "AB", "aB", "ab"},
{"Rpc1150", "RPC1150", "rpc1150", "rpc1150"},
{"case3_1", "Case3_1", "case3_1", "case3-1"},
{"case3__1", "Case3_1", "case3_1", "case3-1"},
{"IEEE802_16bit", "IEEE802_16bit", "iEEE802_16bit", "ieee802-16bit"},
{"IEEE802_16Bit", "IEEE802_16Bit", "iEEE802_16Bit", "ieee802-16-bit"},
{"IPv4", "IPv4", "ipv4", "ipv4"},
{"Ipv4", "IPv4", "ipv4", "ipv4"},
{"iPV4", "IPV4", "iPV4", "ipv4"},
{"RepeatedIpv4", "RepeatedIPv4", "repeatedIPv4", "repeated-ipv4"},
{"eSport", "ESport", "eSport", "e-sport"},
{"stopped in place", "StoppedInPlace", "stoppedInPlace", "stopped-in-place"},
{"l_ssd", "LSSD", "lSSD", "lssd"},
{"ids", "IDs", "ids", "ids"},
{"my_resource_ids", "MyResourceIDs", "myResourceIDs", "my-resource-ids"},
{"acids", "Acids", "acids", "acids"},
{"secret-key", "SecretKey", "secretKey", "secret-key"},
{"ip-id", "IPID", "ipID", "ip-id"},
{"lb-id", "LBID", "lbID", "lb-id"},
{"acl-id", "ACLID", "aclID", "acl-id"},
{"dhcp-id", "DHCPID", "dhcpID", "dhcp-id"},
}
for _, test := range tests {
got := ToPublicGoName(test.name)
if got != test.publicGoName {
t.Errorf("ToPublicGoName(%q) == %q, want %q", test.name, got, test.publicGoName)
}
got = ToPrivateGoName(test.name)
if got != test.privateGoName {
t.Errorf("ToPrivateGoName(%q) == %q, want %q", test.name, got, test.privateGoName)
}
got = ToBashArg(test.name)
if got != test.bashArgName {
t.Errorf("ToBashArg(%q) == %q, want %q", test.name, got, test.bashArgName)
}
}
}
golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/validation/ 0000775 0000000 0000000 00000000000 14563666056 0024410 5 ustar 00root root 0000000 0000000 golang-github-scaleway-scaleway-sdk-go-1.0.0~beta24/validation/is.go 0000664 0000000 0000000 00000003337 14563666056 0025360 0 ustar 00root root 0000000 0000000 // Package validation provides format validation functions.
package validation
import (
"net/url"
"regexp"
)
var (
isUUIDRegexp = regexp.MustCompile("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
isRegionRegex = regexp.MustCompile("^[a-z]{2}-[a-z]{3}$")
isZoneRegex = regexp.MustCompile("^[a-z]{2}-[a-z]{3}-[1-9]$")
isAccessKey = regexp.MustCompile("^SCW[A-Z0-9]{17}$")
isEmailRegexp = regexp.MustCompile("^.+@.+$")
)
// IsUUID returns true if the given string has a valid UUID format.
func IsUUID(s string) bool {
return isUUIDRegexp.MatchString(s)
}
// IsAccessKey returns true if the given string has a valid Scaleway access key format.
func IsAccessKey(s string) bool {
return isAccessKey.MatchString(s)
}
// IsSecretKey returns true if the given string has a valid Scaleway secret key format.
func IsSecretKey(s string) bool {
return IsUUID(s)
}
// IsOrganizationID returns true if the given string has a valid Scaleway organization ID format.
func IsOrganizationID(s string) bool {
return IsUUID(s)
}
// IsProjectID returns true if the given string has a valid Scaleway project ID format.
func IsProjectID(s string) bool {
return IsUUID(s)
}
// IsRegion returns true if the given string has a valid region format.
func IsRegion(s string) bool {
return isRegionRegex.MatchString(s)
}
// IsZone returns true if the given string has a valid zone format.
func IsZone(s string) bool {
return isZoneRegex.MatchString(s)
}
// IsURL returns true if the given string has a valid URL format.
func IsURL(s string) bool {
_, err := url.Parse(s)
return err == nil
}
// IsEmail returns true if the given string has an email format.
func IsEmail(v string) bool {
return isEmailRegexp.MatchString(v)
}
