diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 738e113e..1f60b2f7 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -22,10 +22,6 @@ "ImportPath": "github.com/gogo/protobuf/sortkeys", "Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02" }, - { - "ImportPath": "github.com/golang/glog", - "Rev": "44145f04b68cf362d9c4df2182967c2275eaefed" - }, { "ImportPath": "github.com/golang/groupcache/lru", "Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433" @@ -180,983 +176,987 @@ }, { "ImportPath": "k8s.io/api/admissionregistration/v1alpha1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/admissionregistration/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/apps/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/apps/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/apps/v1beta2", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/auditregistration/v1alpha1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/authentication/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/authentication/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/authorization/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/authorization/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/autoscaling/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/autoscaling/v2beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/autoscaling/v2beta2", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/batch/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/batch/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/batch/v2alpha1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/certificates/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/coordination/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/core/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/events/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/extensions/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/networking/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/policy/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/rbac/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/rbac/v1alpha1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/rbac/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/scheduling/v1alpha1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/scheduling/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/settings/v1alpha1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/storage/v1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/storage/v1alpha1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/api/storage/v1beta1", - "Rev": "3e3e5dc11f5f2262b7d5c1de4f491f2f7a77f3ec" + "Rev": "baccaa98b50fffff381c1c3ed97c2861768286d6" }, { "ImportPath": "k8s.io/apimachinery/pkg/api/errors", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/api/meta", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/api/resource", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/apis/meta/internalversion", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/conversion", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/fields", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/labels", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime/schema", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/selection", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/types", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/cache", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/clock", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/diff", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/errors", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/framer", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/intstr", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/json", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/naming", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/net", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/runtime", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/sets", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/validation", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/validation/field", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/wait", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/util/yaml", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/version", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/pkg/watch", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect", - "Rev": "2294379ca990315f30d7cc972571fcbec0b03c10" + "Rev": "b4d512b8cf5322ed3ae6f790fd07125415b87e2b" }, { "ImportPath": "k8s.io/client-go/discovery", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/discovery/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/admissionregistration", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/admissionregistration/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/admissionregistration/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/apps", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/apps/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/apps/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/apps/v1beta2", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/auditregistration", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/auditregistration/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/autoscaling", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/autoscaling/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/autoscaling/v2beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/autoscaling/v2beta2", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/batch", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/batch/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/batch/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/batch/v2alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/certificates", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/certificates/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/coordination", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/coordination/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/core", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/core/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/events", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/events/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/extensions", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/extensions/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/internalinterfaces", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/networking", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/networking/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/policy", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/policy/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/rbac", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/rbac/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/rbac/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/rbac/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/scheduling", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/scheduling/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/scheduling/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/settings", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/settings/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/storage", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/storage/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/storage/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/informers/storage/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/scheme", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/apps/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/apps/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/apps/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/apps/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/apps/v1beta2", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/apps/v1beta2/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authentication/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authentication/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authentication/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authentication/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authorization/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authorization/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authorization/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/authorization/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/autoscaling/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/autoscaling/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/batch/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/batch/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/batch/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/batch/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/batch/v2alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/batch/v2alpha1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/certificates/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/certificates/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/coordination/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/coordination/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/core/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/core/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/events/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/events/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/extensions/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/extensions/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/networking/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/networking/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/policy/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/policy/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/rbac/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/rbac/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/rbac/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/rbac/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/settings/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/settings/v1alpha1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/storage/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/storage/v1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/storage/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/storage/v1alpha1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/storage/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/kubernetes/typed/storage/v1beta1/fake", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/admissionregistration/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/admissionregistration/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/apps/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/apps/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/apps/v1beta2", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/auditregistration/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/autoscaling/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/autoscaling/v2beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/autoscaling/v2beta2", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/batch/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/batch/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/batch/v2alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/certificates/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/coordination/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/core/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/events/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/extensions/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/networking/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/policy/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/rbac/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/rbac/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/rbac/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/scheduling/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/scheduling/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/settings/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/storage/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/storage/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/listers/storage/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/pkg/apis/clientauthentication", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/pkg/apis/clientauthentication/v1beta1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/pkg/version", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/plugin/pkg/client/auth/exec", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/rest", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/rest/watch", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/testing", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/auth", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/cache", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/clientcmd", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/clientcmd/api", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/clientcmd/api/latest", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/clientcmd/api/v1", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/metrics", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/pager", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/record", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/tools/reference", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/transport", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/buffer", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/cert", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/connrotation", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/flowcontrol", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/homedir", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/integer", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/retry", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" }, { "ImportPath": "k8s.io/client-go/util/workqueue", - "Rev": "e46ee4cfd398a260d92b928ad0a5e87f686d3294" + "Rev": "d4d6a69313dae8ced4030d5fa22b30b49ed7d682" + }, + { + "ImportPath": "k8s.io/klog", + "Rev": "8139d8cb77af419532b33dfa7dd09fbc5f1d344f" }, { "ImportPath": "k8s.io/kube-openapi/pkg/util/proto", - "Rev": "72693cb1fadd73ae2742f6fe29af77d1aecdd8cd" + "Rev": "c59034cc13d587f5ef4e85ca0ade0c1866ae8e1d" }, { "ImportPath": "sigs.k8s.io/yaml", diff --git a/controller.go b/controller.go index ab8468a0..e9d1d838 100644 --- a/controller.go +++ b/controller.go @@ -20,7 +20,6 @@ import ( "fmt" "time" - "github.com/golang/glog" appsv1 "k8s.io/api/apps/v1" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/errors" @@ -37,6 +36,7 @@ import ( "k8s.io/client-go/tools/cache" "k8s.io/client-go/tools/record" "k8s.io/client-go/util/workqueue" + "k8s.io/klog" samplev1alpha1 "k8s.io/sample-controller/pkg/apis/samplecontroller/v1alpha1" clientset "k8s.io/sample-controller/pkg/client/clientset/versioned" @@ -96,9 +96,9 @@ func NewController( // Add sample-controller types to the default Kubernetes Scheme so Events can be // logged for sample-controller types. utilruntime.Must(samplescheme.AddToScheme(scheme.Scheme)) - glog.V(4).Info("Creating event broadcaster") + klog.V(4).Info("Creating event broadcaster") eventBroadcaster := record.NewBroadcaster() - eventBroadcaster.StartLogging(glog.Infof) + eventBroadcaster.StartLogging(klog.Infof) eventBroadcaster.StartRecordingToSink(&typedcorev1.EventSinkImpl{Interface: kubeclientset.CoreV1().Events("")}) recorder := eventBroadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: controllerAgentName}) @@ -113,7 +113,7 @@ func NewController( recorder: recorder, } - glog.Info("Setting up event handlers") + klog.Info("Setting up event handlers") // Set up an event handler for when Foo resources change fooInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{ AddFunc: controller.enqueueFoo, @@ -154,23 +154,23 @@ func (c *Controller) Run(threadiness int, stopCh <-chan struct{}) error { defer c.workqueue.ShutDown() // Start the informer factories to begin populating the informer caches - glog.Info("Starting Foo controller") + klog.Info("Starting Foo controller") // Wait for the caches to be synced before starting workers - glog.Info("Waiting for informer caches to sync") + klog.Info("Waiting for informer caches to sync") if ok := cache.WaitForCacheSync(stopCh, c.deploymentsSynced, c.foosSynced); !ok { return fmt.Errorf("failed to wait for caches to sync") } - glog.Info("Starting workers") + klog.Info("Starting workers") // Launch two workers to process Foo resources for i := 0; i < threadiness; i++ { go wait.Until(c.runWorker, time.Second, stopCh) } - glog.Info("Started workers") + klog.Info("Started workers") <-stopCh - glog.Info("Shutting down workers") + klog.Info("Shutting down workers") return nil } @@ -226,7 +226,7 @@ func (c *Controller) processNextWorkItem() bool { // Finally, if no error occurs we Forget this item so it does not // get queued again until another change happens. c.workqueue.Forget(obj) - glog.Infof("Successfully synced '%s'", key) + klog.Infof("Successfully synced '%s'", key) return nil }(obj) @@ -297,7 +297,7 @@ func (c *Controller) syncHandler(key string) error { // number does not equal the current desired replicas on the Deployment, we // should update the Deployment resource. if foo.Spec.Replicas != nil && *foo.Spec.Replicas != *deployment.Spec.Replicas { - glog.V(4).Infof("Foo %s replicas: %d, deployment replicas: %d", name, *foo.Spec.Replicas, *deployment.Spec.Replicas) + klog.V(4).Infof("Foo %s replicas: %d, deployment replicas: %d", name, *foo.Spec.Replicas, *deployment.Spec.Replicas) deployment, err = c.kubeclientset.AppsV1().Deployments(foo.Namespace).Update(newDeployment(foo)) } @@ -365,9 +365,9 @@ func (c *Controller) handleObject(obj interface{}) { runtime.HandleError(fmt.Errorf("error decoding object tombstone, invalid type")) return } - glog.V(4).Infof("Recovered deleted object '%s' from tombstone", object.GetName()) + klog.V(4).Infof("Recovered deleted object '%s' from tombstone", object.GetName()) } - glog.V(4).Infof("Processing object: %s", object.GetName()) + klog.V(4).Infof("Processing object: %s", object.GetName()) if ownerRef := metav1.GetControllerOf(object); ownerRef != nil { // If this object is not owned by a Foo, we should not do anything more // with it. @@ -377,7 +377,7 @@ func (c *Controller) handleObject(obj interface{}) { foo, err := c.foosLister.Foos(object.GetNamespace()).Get(ownerRef.Name) if err != nil { - glog.V(4).Infof("ignoring orphaned object '%s' of foo '%s'", object.GetSelfLink(), ownerRef.Name) + klog.V(4).Infof("ignoring orphaned object '%s' of foo '%s'", object.GetSelfLink(), ownerRef.Name) return } diff --git a/main.go b/main.go index c9d3193d..d8167715 100644 --- a/main.go +++ b/main.go @@ -20,10 +20,10 @@ import ( "flag" "time" - "github.com/golang/glog" kubeinformers "k8s.io/client-go/informers" "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/clientcmd" + "k8s.io/klog" // Uncomment the following line to load the gcp plugin (only required to authenticate against GKE clusters). // _ "k8s.io/client-go/plugin/pkg/client/auth/gcp" @@ -45,17 +45,17 @@ func main() { cfg, err := clientcmd.BuildConfigFromFlags(masterURL, kubeconfig) if err != nil { - glog.Fatalf("Error building kubeconfig: %s", err.Error()) + klog.Fatalf("Error building kubeconfig: %s", err.Error()) } kubeClient, err := kubernetes.NewForConfig(cfg) if err != nil { - glog.Fatalf("Error building kubernetes clientset: %s", err.Error()) + klog.Fatalf("Error building kubernetes clientset: %s", err.Error()) } exampleClient, err := clientset.NewForConfig(cfg) if err != nil { - glog.Fatalf("Error building example clientset: %s", err.Error()) + klog.Fatalf("Error building example clientset: %s", err.Error()) } kubeInformerFactory := kubeinformers.NewSharedInformerFactory(kubeClient, time.Second*30) @@ -71,7 +71,7 @@ func main() { exampleInformerFactory.Start(stopCh) if err = controller.Run(2, stopCh); err != nil { - glog.Fatalf("Error running controller: %s", err.Error()) + klog.Fatalf("Error running controller: %s", err.Error()) } } diff --git a/vendor/k8s.io/apimachinery/pkg/api/meta/meta.go b/vendor/k8s.io/apimachinery/pkg/api/meta/meta.go index 854bd30f..6fe7458f 100644 --- a/vendor/k8s.io/apimachinery/pkg/api/meta/meta.go +++ b/vendor/k8s.io/apimachinery/pkg/api/meta/meta.go @@ -20,7 +20,7 @@ import ( "fmt" "reflect" - "github.com/golang/glog" + "k8s.io/klog" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1beta1 "k8s.io/apimachinery/pkg/apis/meta/v1beta1" @@ -607,7 +607,7 @@ func (a genericAccessor) GetOwnerReferences() []metav1.OwnerReference { var ret []metav1.OwnerReference s := a.ownerReferences if s.Kind() != reflect.Ptr || s.Elem().Kind() != reflect.Slice { - glog.Errorf("expect %v to be a pointer to slice", s) + klog.Errorf("expect %v to be a pointer to slice", s) return ret } s = s.Elem() @@ -615,7 +615,7 @@ func (a genericAccessor) GetOwnerReferences() []metav1.OwnerReference { ret = make([]metav1.OwnerReference, s.Len(), s.Len()+1) for i := 0; i < s.Len(); i++ { if err := extractFromOwnerReference(s.Index(i), &ret[i]); err != nil { - glog.Errorf("extractFromOwnerReference failed: %v", err) + klog.Errorf("extractFromOwnerReference failed: %v", err) return ret } } @@ -625,13 +625,13 @@ func (a genericAccessor) GetOwnerReferences() []metav1.OwnerReference { func (a genericAccessor) SetOwnerReferences(references []metav1.OwnerReference) { s := a.ownerReferences if s.Kind() != reflect.Ptr || s.Elem().Kind() != reflect.Slice { - glog.Errorf("expect %v to be a pointer to slice", s) + klog.Errorf("expect %v to be a pointer to slice", s) } s = s.Elem() newReferences := reflect.MakeSlice(s.Type(), len(references), len(references)) for i := 0; i < len(references); i++ { if err := setOwnerReference(newReferences.Index(i), &references[i]); err != nil { - glog.Errorf("setOwnerReference failed: %v", err) + klog.Errorf("setOwnerReference failed: %v", err) return } } diff --git a/vendor/k8s.io/apimachinery/pkg/labels/selector.go b/vendor/k8s.io/apimachinery/pkg/labels/selector.go index 374d2ef1..f5a08889 100644 --- a/vendor/k8s.io/apimachinery/pkg/labels/selector.go +++ b/vendor/k8s.io/apimachinery/pkg/labels/selector.go @@ -23,10 +23,10 @@ import ( "strconv" "strings" - "github.com/golang/glog" "k8s.io/apimachinery/pkg/selection" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/validation" + "k8s.io/klog" ) // Requirements is AND of all requirements. @@ -211,13 +211,13 @@ func (r *Requirement) Matches(ls Labels) bool { } lsValue, err := strconv.ParseInt(ls.Get(r.key), 10, 64) if err != nil { - glog.V(10).Infof("ParseInt failed for value %+v in label %+v, %+v", ls.Get(r.key), ls, err) + klog.V(10).Infof("ParseInt failed for value %+v in label %+v, %+v", ls.Get(r.key), ls, err) return false } // There should be only one strValue in r.strValues, and can be converted to a integer. if len(r.strValues) != 1 { - glog.V(10).Infof("Invalid values count %+v of requirement %#v, for 'Gt', 'Lt' operators, exactly one value is required", len(r.strValues), r) + klog.V(10).Infof("Invalid values count %+v of requirement %#v, for 'Gt', 'Lt' operators, exactly one value is required", len(r.strValues), r) return false } @@ -225,7 +225,7 @@ func (r *Requirement) Matches(ls Labels) bool { for i := range r.strValues { rValue, err = strconv.ParseInt(r.strValues[i], 10, 64) if err != nil { - glog.V(10).Infof("ParseInt failed for value %+v in requirement %#v, for 'Gt', 'Lt' operators, the value must be an integer", r.strValues[i], r) + klog.V(10).Infof("ParseInt failed for value %+v in requirement %#v, for 'Gt', 'Lt' operators, the value must be an integer", r.strValues[i], r) return false } } diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go b/vendor/k8s.io/apimachinery/pkg/runtime/converter.go index 291d7a4e..dff56e03 100644 --- a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go +++ b/vendor/k8s.io/apimachinery/pkg/runtime/converter.go @@ -33,7 +33,7 @@ import ( "k8s.io/apimachinery/pkg/util/json" utilruntime "k8s.io/apimachinery/pkg/util/runtime" - "github.com/golang/glog" + "k8s.io/klog" ) // UnstructuredConverter is an interface for converting between interface{} @@ -133,10 +133,10 @@ func (c *unstructuredConverter) FromUnstructured(u map[string]interface{}, obj i newObj := reflect.New(t.Elem()).Interface() newErr := fromUnstructuredViaJSON(u, newObj) if (err != nil) != (newErr != nil) { - glog.Fatalf("FromUnstructured unexpected error for %v: error: %v", u, err) + klog.Fatalf("FromUnstructured unexpected error for %v: error: %v", u, err) } if err == nil && !c.comparison.DeepEqual(obj, newObj) { - glog.Fatalf("FromUnstructured mismatch\nobj1: %#v\nobj2: %#v", obj, newObj) + klog.Fatalf("FromUnstructured mismatch\nobj1: %#v\nobj2: %#v", obj, newObj) } } return err @@ -424,10 +424,10 @@ func (c *unstructuredConverter) ToUnstructured(obj interface{}) (map[string]inte newUnstr := map[string]interface{}{} newErr := toUnstructuredViaJSON(obj, &newUnstr) if (err != nil) != (newErr != nil) { - glog.Fatalf("ToUnstructured unexpected error for %v: error: %v; newErr: %v", obj, err, newErr) + klog.Fatalf("ToUnstructured unexpected error for %v: error: %v; newErr: %v", obj, err, newErr) } if err == nil && !c.comparison.DeepEqual(u, newUnstr) { - glog.Fatalf("ToUnstructured mismatch\nobj1: %#v\nobj2: %#v", u, newUnstr) + klog.Fatalf("ToUnstructured mismatch\nobj1: %#v\nobj2: %#v", u, newUnstr) } } if err != nil { diff --git a/vendor/k8s.io/apimachinery/pkg/util/intstr/intstr.go b/vendor/k8s.io/apimachinery/pkg/util/intstr/intstr.go index 642b83ce..5b26ed26 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/intstr/intstr.go +++ b/vendor/k8s.io/apimachinery/pkg/util/intstr/intstr.go @@ -25,8 +25,8 @@ import ( "strconv" "strings" - "github.com/golang/glog" "github.com/google/gofuzz" + "k8s.io/klog" ) // IntOrString is a type that can hold an int32 or a string. When used in @@ -58,7 +58,7 @@ const ( // TODO: convert to (val int32) func FromInt(val int) IntOrString { if val > math.MaxInt32 || val < math.MinInt32 { - glog.Errorf("value: %d overflows int32\n%s\n", val, debug.Stack()) + klog.Errorf("value: %d overflows int32\n%s\n", val, debug.Stack()) } return IntOrString{Type: Int, IntVal: int32(val)} } diff --git a/vendor/k8s.io/apimachinery/pkg/util/net/http.go b/vendor/k8s.io/apimachinery/pkg/util/net/http.go index 7c2a5e62..155667cd 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/net/http.go +++ b/vendor/k8s.io/apimachinery/pkg/util/net/http.go @@ -31,8 +31,8 @@ import ( "strconv" "strings" - "github.com/golang/glog" "golang.org/x/net/http2" + "k8s.io/klog" ) // JoinPreservingTrailingSlash does a path.Join of the specified elements, @@ -107,10 +107,10 @@ func SetTransportDefaults(t *http.Transport) *http.Transport { t = SetOldTransportDefaults(t) // Allow clients to disable http2 if needed. if s := os.Getenv("DISABLE_HTTP2"); len(s) > 0 { - glog.Infof("HTTP2 has been explicitly disabled") + klog.Infof("HTTP2 has been explicitly disabled") } else { if err := http2.ConfigureTransport(t); err != nil { - glog.Warningf("Transport failed http2 configuration: %v", err) + klog.Warningf("Transport failed http2 configuration: %v", err) } } return t @@ -368,7 +368,7 @@ redirectLoop: resp, err := http.ReadResponse(respReader, nil) if err != nil { // Unable to read the backend response; let the client handle it. - glog.Warningf("Error reading backend response: %v", err) + klog.Warningf("Error reading backend response: %v", err) break redirectLoop } diff --git a/vendor/k8s.io/apimachinery/pkg/util/net/interface.go b/vendor/k8s.io/apimachinery/pkg/util/net/interface.go index 0ab9b360..daf5d249 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/net/interface.go +++ b/vendor/k8s.io/apimachinery/pkg/util/net/interface.go @@ -26,7 +26,7 @@ import ( "strings" - "github.com/golang/glog" + "k8s.io/klog" ) type AddressFamily uint @@ -193,7 +193,7 @@ func isInterfaceUp(intf *net.Interface) bool { return false } if intf.Flags&net.FlagUp != 0 { - glog.V(4).Infof("Interface %v is up", intf.Name) + klog.V(4).Infof("Interface %v is up", intf.Name) return true } return false @@ -208,20 +208,20 @@ func isLoopbackOrPointToPoint(intf *net.Interface) bool { func getMatchingGlobalIP(addrs []net.Addr, family AddressFamily) (net.IP, error) { if len(addrs) > 0 { for i := range addrs { - glog.V(4).Infof("Checking addr %s.", addrs[i].String()) + klog.V(4).Infof("Checking addr %s.", addrs[i].String()) ip, _, err := net.ParseCIDR(addrs[i].String()) if err != nil { return nil, err } if memberOf(ip, family) { if ip.IsGlobalUnicast() { - glog.V(4).Infof("IP found %v", ip) + klog.V(4).Infof("IP found %v", ip) return ip, nil } else { - glog.V(4).Infof("Non-global unicast address found %v", ip) + klog.V(4).Infof("Non-global unicast address found %v", ip) } } else { - glog.V(4).Infof("%v is not an IPv%d address", ip, int(family)) + klog.V(4).Infof("%v is not an IPv%d address", ip, int(family)) } } @@ -241,13 +241,13 @@ func getIPFromInterface(intfName string, forFamily AddressFamily, nw networkInte if err != nil { return nil, err } - glog.V(4).Infof("Interface %q has %d addresses :%v.", intfName, len(addrs), addrs) + klog.V(4).Infof("Interface %q has %d addresses :%v.", intfName, len(addrs), addrs) matchingIP, err := getMatchingGlobalIP(addrs, forFamily) if err != nil { return nil, err } if matchingIP != nil { - glog.V(4).Infof("Found valid IPv%d address %v for interface %q.", int(forFamily), matchingIP, intfName) + klog.V(4).Infof("Found valid IPv%d address %v for interface %q.", int(forFamily), matchingIP, intfName) return matchingIP, nil } } @@ -275,14 +275,14 @@ func chooseIPFromHostInterfaces(nw networkInterfacer) (net.IP, error) { return nil, fmt.Errorf("no interfaces found on host.") } for _, family := range []AddressFamily{familyIPv4, familyIPv6} { - glog.V(4).Infof("Looking for system interface with a global IPv%d address", uint(family)) + klog.V(4).Infof("Looking for system interface with a global IPv%d address", uint(family)) for _, intf := range intfs { if !isInterfaceUp(&intf) { - glog.V(4).Infof("Skipping: down interface %q", intf.Name) + klog.V(4).Infof("Skipping: down interface %q", intf.Name) continue } if isLoopbackOrPointToPoint(&intf) { - glog.V(4).Infof("Skipping: LB or P2P interface %q", intf.Name) + klog.V(4).Infof("Skipping: LB or P2P interface %q", intf.Name) continue } addrs, err := nw.Addrs(&intf) @@ -290,7 +290,7 @@ func chooseIPFromHostInterfaces(nw networkInterfacer) (net.IP, error) { return nil, err } if len(addrs) == 0 { - glog.V(4).Infof("Skipping: no addresses on interface %q", intf.Name) + klog.V(4).Infof("Skipping: no addresses on interface %q", intf.Name) continue } for _, addr := range addrs { @@ -299,15 +299,15 @@ func chooseIPFromHostInterfaces(nw networkInterfacer) (net.IP, error) { return nil, fmt.Errorf("Unable to parse CIDR for interface %q: %s", intf.Name, err) } if !memberOf(ip, family) { - glog.V(4).Infof("Skipping: no address family match for %q on interface %q.", ip, intf.Name) + klog.V(4).Infof("Skipping: no address family match for %q on interface %q.", ip, intf.Name) continue } // TODO: Decide if should open up to allow IPv6 LLAs in future. if !ip.IsGlobalUnicast() { - glog.V(4).Infof("Skipping: non-global address %q on interface %q.", ip, intf.Name) + klog.V(4).Infof("Skipping: non-global address %q on interface %q.", ip, intf.Name) continue } - glog.V(4).Infof("Found global unicast address %q on interface %q.", ip, intf.Name) + klog.V(4).Infof("Found global unicast address %q on interface %q.", ip, intf.Name) return ip, nil } } @@ -381,23 +381,23 @@ func getAllDefaultRoutes() ([]Route, error) { // an IPv4 IP, and then will look at each IPv6 route for an IPv6 IP. func chooseHostInterfaceFromRoute(routes []Route, nw networkInterfacer) (net.IP, error) { for _, family := range []AddressFamily{familyIPv4, familyIPv6} { - glog.V(4).Infof("Looking for default routes with IPv%d addresses", uint(family)) + klog.V(4).Infof("Looking for default routes with IPv%d addresses", uint(family)) for _, route := range routes { if route.Family != family { continue } - glog.V(4).Infof("Default route transits interface %q", route.Interface) + klog.V(4).Infof("Default route transits interface %q", route.Interface) finalIP, err := getIPFromInterface(route.Interface, family, nw) if err != nil { return nil, err } if finalIP != nil { - glog.V(4).Infof("Found active IP %v ", finalIP) + klog.V(4).Infof("Found active IP %v ", finalIP) return finalIP, nil } } } - glog.V(4).Infof("No active IP found by looking at default routes") + klog.V(4).Infof("No active IP found by looking at default routes") return nil, fmt.Errorf("unable to select an IP from default routes.") } diff --git a/vendor/k8s.io/apimachinery/pkg/util/runtime/runtime.go b/vendor/k8s.io/apimachinery/pkg/util/runtime/runtime.go index da32fe12..3512e68e 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/runtime/runtime.go +++ b/vendor/k8s.io/apimachinery/pkg/util/runtime/runtime.go @@ -22,7 +22,7 @@ import ( "sync" "time" - "github.com/golang/glog" + "k8s.io/klog" ) var ( @@ -63,7 +63,7 @@ func HandleCrash(additionalHandlers ...func(interface{})) { // logPanic logs the caller tree when a panic occurs. func logPanic(r interface{}) { callers := getCallers(r) - glog.Errorf("Observed a panic: %#v (%v)\n%v", r, r, callers) + klog.Errorf("Observed a panic: %#v (%v)\n%v", r, r, callers) } func getCallers(r interface{}) string { @@ -111,7 +111,7 @@ func HandleError(err error) { // logError prints an error with the call stack of the location it was reported func logError(err error) { - glog.ErrorDepth(2, err) + klog.ErrorDepth(2, err) } type rudimentaryErrorBackoff struct { diff --git a/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go b/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go index 41ad0431..63d735a8 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go +++ b/vendor/k8s.io/apimachinery/pkg/util/yaml/decoder.go @@ -26,7 +26,7 @@ import ( "strings" "unicode" - "github.com/golang/glog" + "k8s.io/klog" "sigs.k8s.io/yaml" ) @@ -217,11 +217,11 @@ func (d *YAMLOrJSONDecoder) Decode(into interface{}) error { if d.decoder == nil { buffer, origData, isJSON := GuessJSONStream(d.r, d.bufferSize) if isJSON { - glog.V(4).Infof("decoding stream as JSON") + klog.V(4).Infof("decoding stream as JSON") d.decoder = json.NewDecoder(buffer) d.rawData = origData } else { - glog.V(4).Infof("decoding stream as YAML") + klog.V(4).Infof("decoding stream as YAML") d.decoder = NewYAMLToJSONDecoder(buffer) } } @@ -230,7 +230,7 @@ func (d *YAMLOrJSONDecoder) Decode(into interface{}) error { if syntax, ok := err.(*json.SyntaxError); ok { data, readErr := ioutil.ReadAll(jsonDecoder.Buffered()) if readErr != nil { - glog.V(4).Infof("reading stream failed: %v", readErr) + klog.V(4).Infof("reading stream failed: %v", readErr) } js := string(data) diff --git a/vendor/k8s.io/apimachinery/pkg/watch/streamwatcher.go b/vendor/k8s.io/apimachinery/pkg/watch/streamwatcher.go index 93bb1cdf..d61cf5a2 100644 --- a/vendor/k8s.io/apimachinery/pkg/watch/streamwatcher.go +++ b/vendor/k8s.io/apimachinery/pkg/watch/streamwatcher.go @@ -20,10 +20,10 @@ import ( "io" "sync" - "github.com/golang/glog" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/util/net" utilruntime "k8s.io/apimachinery/pkg/util/runtime" + "k8s.io/klog" ) // Decoder allows StreamWatcher to watch any stream for which a Decoder can be written. @@ -100,13 +100,13 @@ func (sw *StreamWatcher) receive() { case io.EOF: // watch closed normally case io.ErrUnexpectedEOF: - glog.V(1).Infof("Unexpected EOF during watch stream event decoding: %v", err) + klog.V(1).Infof("Unexpected EOF during watch stream event decoding: %v", err) default: msg := "Unable to decode an event from the watch stream: %v" if net.IsProbableEOF(err) { - glog.V(5).Infof(msg, err) + klog.V(5).Infof(msg, err) } else { - glog.Errorf(msg, err) + klog.Errorf(msg, err) } } return diff --git a/vendor/k8s.io/apimachinery/pkg/watch/watch.go b/vendor/k8s.io/apimachinery/pkg/watch/watch.go index a627d1d5..be9c90c0 100644 --- a/vendor/k8s.io/apimachinery/pkg/watch/watch.go +++ b/vendor/k8s.io/apimachinery/pkg/watch/watch.go @@ -20,7 +20,7 @@ import ( "fmt" "sync" - "github.com/golang/glog" + "k8s.io/klog" "k8s.io/apimachinery/pkg/runtime" ) @@ -106,7 +106,7 @@ func (f *FakeWatcher) Stop() { f.Lock() defer f.Unlock() if !f.Stopped { - glog.V(4).Infof("Stopping fake watcher.") + klog.V(4).Infof("Stopping fake watcher.") close(f.result) f.Stopped = true } @@ -173,7 +173,7 @@ func (f *RaceFreeFakeWatcher) Stop() { f.Lock() defer f.Unlock() if !f.Stopped { - glog.V(4).Infof("Stopping fake watcher.") + klog.V(4).Infof("Stopping fake watcher.") close(f.result) f.Stopped = true } diff --git a/vendor/k8s.io/client-go/discovery/cached_discovery.go b/vendor/k8s.io/client-go/discovery/cached_discovery.go index 90cd3420..df69d6a1 100644 --- a/vendor/k8s.io/client-go/discovery/cached_discovery.go +++ b/vendor/k8s.io/client-go/discovery/cached_discovery.go @@ -25,8 +25,8 @@ import ( "sync" "time" - "github.com/golang/glog" "github.com/googleapis/gnostic/OpenAPIv2" + "k8s.io/klog" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" @@ -67,23 +67,23 @@ func (d *CachedDiscoveryClient) ServerResourcesForGroupVersion(groupVersion stri if err == nil { cachedResources := &metav1.APIResourceList{} if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedResources); err == nil { - glog.V(10).Infof("returning cached discovery info from %v", filename) + klog.V(10).Infof("returning cached discovery info from %v", filename) return cachedResources, nil } } liveResources, err := d.delegate.ServerResourcesForGroupVersion(groupVersion) if err != nil { - glog.V(3).Infof("skipped caching discovery info due to %v", err) + klog.V(3).Infof("skipped caching discovery info due to %v", err) return liveResources, err } if liveResources == nil || len(liveResources.APIResources) == 0 { - glog.V(3).Infof("skipped caching discovery info, no resources found") + klog.V(3).Infof("skipped caching discovery info, no resources found") return liveResources, err } if err := d.writeCachedFile(filename, liveResources); err != nil { - glog.V(1).Infof("failed to write cache to %v due to %v", filename, err) + klog.V(1).Infof("failed to write cache to %v due to %v", filename, err) } return liveResources, nil @@ -103,23 +103,23 @@ func (d *CachedDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) { if err == nil { cachedGroups := &metav1.APIGroupList{} if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedGroups); err == nil { - glog.V(10).Infof("returning cached discovery info from %v", filename) + klog.V(10).Infof("returning cached discovery info from %v", filename) return cachedGroups, nil } } liveGroups, err := d.delegate.ServerGroups() if err != nil { - glog.V(3).Infof("skipped caching discovery info due to %v", err) + klog.V(3).Infof("skipped caching discovery info due to %v", err) return liveGroups, err } if liveGroups == nil || len(liveGroups.Groups) == 0 { - glog.V(3).Infof("skipped caching discovery info, no groups found") + klog.V(3).Infof("skipped caching discovery info, no groups found") return liveGroups, err } if err := d.writeCachedFile(filename, liveGroups); err != nil { - glog.V(1).Infof("failed to write cache to %v due to %v", filename, err) + klog.V(1).Infof("failed to write cache to %v due to %v", filename, err) } return liveGroups, nil diff --git a/vendor/k8s.io/client-go/discovery/round_tripper.go b/vendor/k8s.io/client-go/discovery/round_tripper.go index 75b7f520..4e2bc24e 100644 --- a/vendor/k8s.io/client-go/discovery/round_tripper.go +++ b/vendor/k8s.io/client-go/discovery/round_tripper.go @@ -20,10 +20,10 @@ import ( "net/http" "path/filepath" - "github.com/golang/glog" "github.com/gregjones/httpcache" "github.com/gregjones/httpcache/diskcache" "github.com/peterbourgon/diskv" + "k8s.io/klog" ) type cacheRoundTripper struct { @@ -55,7 +55,7 @@ func (rt *cacheRoundTripper) CancelRequest(req *http.Request) { if cr, ok := rt.rt.Transport.(canceler); ok { cr.CancelRequest(req) } else { - glog.Errorf("CancelRequest not implemented by %T", rt.rt.Transport) + klog.Errorf("CancelRequest not implemented by %T", rt.rt.Transport) } } diff --git a/vendor/k8s.io/client-go/listers/policy/v1beta1/poddisruptionbudget_expansion.go b/vendor/k8s.io/client-go/listers/policy/v1beta1/poddisruptionbudget_expansion.go index c0ab9d3e..d07d11a9 100644 --- a/vendor/k8s.io/client-go/listers/policy/v1beta1/poddisruptionbudget_expansion.go +++ b/vendor/k8s.io/client-go/listers/policy/v1beta1/poddisruptionbudget_expansion.go @@ -19,11 +19,11 @@ package v1beta1 import ( "fmt" - "github.com/golang/glog" "k8s.io/api/core/v1" policy "k8s.io/api/policy/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/labels" + "k8s.io/klog" ) // PodDisruptionBudgetListerExpansion allows custom methods to be added to @@ -54,7 +54,7 @@ func (s *podDisruptionBudgetLister) GetPodPodDisruptionBudgets(pod *v1.Pod) ([]* pdb := list[i] selector, err = metav1.LabelSelectorAsSelector(pdb.Spec.Selector) if err != nil { - glog.Warningf("invalid selector: %v", err) + klog.Warningf("invalid selector: %v", err) // TODO(mml): add an event to the PDB continue } diff --git a/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go b/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go index cae9d0d6..4d725265 100644 --- a/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go +++ b/vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go @@ -31,7 +31,6 @@ import ( "sync" "time" - "github.com/golang/glog" "golang.org/x/crypto/ssh/terminal" "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" @@ -44,6 +43,7 @@ import ( "k8s.io/client-go/tools/clientcmd/api" "k8s.io/client-go/transport" "k8s.io/client-go/util/connrotation" + "k8s.io/klog" ) const execInfoEnv = "KUBERNETES_EXEC_INFO" @@ -228,7 +228,7 @@ func (r *roundTripper) RoundTrip(req *http.Request) (*http.Response, error) { Code: int32(res.StatusCode), } if err := r.a.maybeRefreshCreds(creds, resp); err != nil { - glog.Errorf("refreshing credentials: %v", err) + klog.Errorf("refreshing credentials: %v", err) } } return res, nil diff --git a/vendor/k8s.io/client-go/rest/config.go b/vendor/k8s.io/client-go/rest/config.go index d5ef8406..438eb3be 100644 --- a/vendor/k8s.io/client-go/rest/config.go +++ b/vendor/k8s.io/client-go/rest/config.go @@ -29,7 +29,6 @@ import ( "strings" "time" - "github.com/golang/glog" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" @@ -37,6 +36,7 @@ import ( clientcmdapi "k8s.io/client-go/tools/clientcmd/api" certutil "k8s.io/client-go/util/cert" "k8s.io/client-go/util/flowcontrol" + "k8s.io/klog" ) const ( @@ -331,7 +331,7 @@ func InClusterConfig() (*Config, error) { tlsClientConfig := TLSClientConfig{} if _, err := certutil.NewPool(rootCAFile); err != nil { - glog.Errorf("Expected to load root CA config from %s, but got err: %v", rootCAFile, err) + klog.Errorf("Expected to load root CA config from %s, but got err: %v", rootCAFile, err) } else { tlsClientConfig.CAFile = rootCAFile } diff --git a/vendor/k8s.io/client-go/rest/plugin.go b/vendor/k8s.io/client-go/rest/plugin.go index cf8fbabf..83ef5ae3 100644 --- a/vendor/k8s.io/client-go/rest/plugin.go +++ b/vendor/k8s.io/client-go/rest/plugin.go @@ -21,7 +21,7 @@ import ( "net/http" "sync" - "github.com/golang/glog" + "k8s.io/klog" clientcmdapi "k8s.io/client-go/tools/clientcmd/api" ) @@ -57,7 +57,7 @@ func RegisterAuthProviderPlugin(name string, plugin Factory) error { if _, found := plugins[name]; found { return fmt.Errorf("Auth Provider Plugin %q was registered twice", name) } - glog.V(4).Infof("Registered Auth Provider Plugin %q", name) + klog.V(4).Infof("Registered Auth Provider Plugin %q", name) plugins[name] = plugin return nil } diff --git a/vendor/k8s.io/client-go/rest/request.go b/vendor/k8s.io/client-go/rest/request.go index 9bb31144..64901fba 100644 --- a/vendor/k8s.io/client-go/rest/request.go +++ b/vendor/k8s.io/client-go/rest/request.go @@ -32,7 +32,6 @@ import ( "strings" "time" - "github.com/golang/glog" "golang.org/x/net/http2" "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -44,6 +43,7 @@ import ( restclientwatch "k8s.io/client-go/rest/watch" "k8s.io/client-go/tools/metrics" "k8s.io/client-go/util/flowcontrol" + "k8s.io/klog" ) var ( @@ -114,7 +114,7 @@ type Request struct { // NewRequest creates a new request helper object for accessing runtime.Objects on a server. func NewRequest(client HTTPClient, verb string, baseURL *url.URL, versionedAPIPath string, content ContentConfig, serializers Serializers, backoff BackoffManager, throttle flowcontrol.RateLimiter, timeout time.Duration) *Request { if backoff == nil { - glog.V(2).Infof("Not implementing request backoff strategy.") + klog.V(2).Infof("Not implementing request backoff strategy.") backoff = &NoBackoff{} } @@ -527,7 +527,7 @@ func (r *Request) tryThrottle() { r.throttle.Accept() } if latency := time.Since(now); latency > longThrottleLatency { - glog.V(4).Infof("Throttling request took %v, request: %s:%s", latency, r.verb, r.URL().String()) + klog.V(4).Infof("Throttling request took %v, request: %s:%s", latency, r.verb, r.URL().String()) } } @@ -683,7 +683,7 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error { }() if r.err != nil { - glog.V(4).Infof("Error in request: %v", r.err) + klog.V(4).Infof("Error in request: %v", r.err) return r.err } @@ -770,13 +770,13 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error { if seeker, ok := r.body.(io.Seeker); ok && r.body != nil { _, err := seeker.Seek(0, 0) if err != nil { - glog.V(4).Infof("Could not retry request, can't Seek() back to beginning of body for %T", r.body) + klog.V(4).Infof("Could not retry request, can't Seek() back to beginning of body for %T", r.body) fn(req, resp) return true } } - glog.V(4).Infof("Got a Retry-After %ds response for attempt %d to %v", seconds, retries, url) + klog.V(4).Infof("Got a Retry-After %ds response for attempt %d to %v", seconds, retries, url) r.backoffMgr.Sleep(time.Duration(seconds) * time.Second) return false } @@ -844,13 +844,13 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu // 2. Apiserver sends back the headers and then part of the body // 3. Apiserver closes connection. // 4. client-go should catch this and return an error. - glog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err) + klog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err) streamErr := fmt.Errorf("Stream error %#v when reading response body, may be caused by closed connection. Please retry.", err) return Result{ err: streamErr, } default: - glog.Errorf("Unexpected error when reading response body: %#v", err) + klog.Errorf("Unexpected error when reading response body: %#v", err) unexpectedErr := fmt.Errorf("Unexpected error %#v when reading response body. Please retry.", err) return Result{ err: unexpectedErr, @@ -914,11 +914,11 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu func truncateBody(body string) string { max := 0 switch { - case bool(glog.V(10)): + case bool(klog.V(10)): return body - case bool(glog.V(9)): + case bool(klog.V(9)): max = 10240 - case bool(glog.V(8)): + case bool(klog.V(8)): max = 1024 } @@ -933,13 +933,13 @@ func truncateBody(body string) string { // allocating a new string for the body output unless necessary. Uses a simple heuristic to determine // whether the body is printable. func glogBody(prefix string, body []byte) { - if glog.V(8) { + if klog.V(8) { if bytes.IndexFunc(body, func(r rune) bool { return r < 0x0a }) != -1 { - glog.Infof("%s:\n%s", prefix, truncateBody(hex.Dump(body))) + klog.Infof("%s:\n%s", prefix, truncateBody(hex.Dump(body))) } else { - glog.Infof("%s: %s", prefix, truncateBody(string(body))) + klog.Infof("%s: %s", prefix, truncateBody(string(body))) } } } @@ -1141,7 +1141,7 @@ func (r Result) Error() error { // to be backwards compatible with old servers that do not return a version, default to "v1" out, _, err := r.decoder.Decode(r.body, &schema.GroupVersionKind{Version: "v1"}, nil) if err != nil { - glog.V(5).Infof("body was not decodable (unable to check for Status): %v", err) + klog.V(5).Infof("body was not decodable (unable to check for Status): %v", err) return r.err } switch t := out.(type) { diff --git a/vendor/k8s.io/client-go/rest/token_source.go b/vendor/k8s.io/client-go/rest/token_source.go index e0a6eb7d..c251b5eb 100644 --- a/vendor/k8s.io/client-go/rest/token_source.go +++ b/vendor/k8s.io/client-go/rest/token_source.go @@ -24,8 +24,8 @@ import ( "sync" "time" - "github.com/golang/glog" "golang.org/x/oauth2" + "k8s.io/klog" ) // TokenSourceWrapTransport returns a WrapTransport that injects bearer tokens @@ -131,7 +131,7 @@ func (ts *cachingTokenSource) Token() (*oauth2.Token, error) { if ts.tok == nil { return nil, err } - glog.Errorf("Unable to rotate token: %v", err) + klog.Errorf("Unable to rotate token: %v", err) return ts.tok, nil } diff --git a/vendor/k8s.io/client-go/rest/urlbackoff.go b/vendor/k8s.io/client-go/rest/urlbackoff.go index eff848ab..d00e42f8 100644 --- a/vendor/k8s.io/client-go/rest/urlbackoff.go +++ b/vendor/k8s.io/client-go/rest/urlbackoff.go @@ -20,9 +20,9 @@ import ( "net/url" "time" - "github.com/golang/glog" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/client-go/util/flowcontrol" + "k8s.io/klog" ) // Set of resp. Codes that we backoff for. @@ -64,7 +64,7 @@ func (n *NoBackoff) Sleep(d time.Duration) { // Disable makes the backoff trivial, i.e., sets it to zero. This might be used // by tests which want to run 1000s of mock requests without slowing down. func (b *URLBackoff) Disable() { - glog.V(4).Infof("Disabling backoff strategy") + klog.V(4).Infof("Disabling backoff strategy") b.Backoff = flowcontrol.NewBackOff(0*time.Second, 0*time.Second) } @@ -76,7 +76,7 @@ func (b *URLBackoff) baseUrlKey(rawurl *url.URL) string { // in the future. host, err := url.Parse(rawurl.String()) if err != nil { - glog.V(4).Infof("Error extracting url: %v", rawurl) + klog.V(4).Infof("Error extracting url: %v", rawurl) panic("bad url!") } return host.Host @@ -89,7 +89,7 @@ func (b *URLBackoff) UpdateBackoff(actualUrl *url.URL, err error, responseCode i b.Backoff.Next(b.baseUrlKey(actualUrl), b.Backoff.Clock.Now()) return } else if responseCode >= 300 || err != nil { - glog.V(4).Infof("Client is returning errors: code %v, error %v", responseCode, err) + klog.V(4).Infof("Client is returning errors: code %v, error %v", responseCode, err) } //If we got this far, there is no backoff required for this URL anymore. diff --git a/vendor/k8s.io/client-go/tools/cache/delta_fifo.go b/vendor/k8s.io/client-go/tools/cache/delta_fifo.go index 45c3b500..ded637ac 100644 --- a/vendor/k8s.io/client-go/tools/cache/delta_fifo.go +++ b/vendor/k8s.io/client-go/tools/cache/delta_fifo.go @@ -23,7 +23,7 @@ import ( "k8s.io/apimachinery/pkg/util/sets" - "github.com/golang/glog" + "k8s.io/klog" ) // NewDeltaFIFO returns a Store which can be used process changes to items. @@ -506,10 +506,10 @@ func (f *DeltaFIFO) Replace(list []interface{}, resourceVersion string) error { deletedObj, exists, err := f.knownObjects.GetByKey(k) if err != nil { deletedObj = nil - glog.Errorf("Unexpected error %v during lookup of key %v, placing DeleteFinalStateUnknown marker without object", err, k) + klog.Errorf("Unexpected error %v during lookup of key %v, placing DeleteFinalStateUnknown marker without object", err, k) } else if !exists { deletedObj = nil - glog.Infof("Key %v does not exist in known objects store, placing DeleteFinalStateUnknown marker without object", k) + klog.Infof("Key %v does not exist in known objects store, placing DeleteFinalStateUnknown marker without object", k) } queuedDeletions++ if err := f.queueActionLocked(Deleted, DeletedFinalStateUnknown{k, deletedObj}); err != nil { @@ -553,10 +553,10 @@ func (f *DeltaFIFO) syncKey(key string) error { func (f *DeltaFIFO) syncKeyLocked(key string) error { obj, exists, err := f.knownObjects.GetByKey(key) if err != nil { - glog.Errorf("Unexpected error %v during lookup of key %v, unable to queue object for sync", err, key) + klog.Errorf("Unexpected error %v during lookup of key %v, unable to queue object for sync", err, key) return nil } else if !exists { - glog.Infof("Key %v does not exist in known objects store, unable to queue object for sync", key) + klog.Infof("Key %v does not exist in known objects store, unable to queue object for sync", key) return nil } diff --git a/vendor/k8s.io/client-go/tools/cache/expiration_cache.go b/vendor/k8s.io/client-go/tools/cache/expiration_cache.go index d284453e..b38fe70b 100644 --- a/vendor/k8s.io/client-go/tools/cache/expiration_cache.go +++ b/vendor/k8s.io/client-go/tools/cache/expiration_cache.go @@ -20,8 +20,8 @@ import ( "sync" "time" - "github.com/golang/glog" "k8s.io/apimachinery/pkg/util/clock" + "k8s.io/klog" ) // ExpirationCache implements the store interface @@ -95,7 +95,7 @@ func (c *ExpirationCache) getOrExpire(key string) (interface{}, bool) { return nil, false } if c.expirationPolicy.IsExpired(timestampedItem) { - glog.V(4).Infof("Entry %v: %+v has expired", key, timestampedItem.obj) + klog.V(4).Infof("Entry %v: %+v has expired", key, timestampedItem.obj) c.cacheStorage.Delete(key) return nil, false } diff --git a/vendor/k8s.io/client-go/tools/cache/listers.go b/vendor/k8s.io/client-go/tools/cache/listers.go index 27d51a6b..ce377329 100644 --- a/vendor/k8s.io/client-go/tools/cache/listers.go +++ b/vendor/k8s.io/client-go/tools/cache/listers.go @@ -17,7 +17,7 @@ limitations under the License. package cache import ( - "github.com/golang/glog" + "k8s.io/klog" "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" @@ -60,7 +60,7 @@ func ListAllByNamespace(indexer Indexer, namespace string, selector labels.Selec items, err := indexer.Index(NamespaceIndex, &metav1.ObjectMeta{Namespace: namespace}) if err != nil { // Ignore error; do slow search without index. - glog.Warningf("can not retrieve list of objects using index : %v", err) + klog.Warningf("can not retrieve list of objects using index : %v", err) for _, m := range indexer.List() { metadata, err := meta.Accessor(m) if err != nil { diff --git a/vendor/k8s.io/client-go/tools/cache/mutation_cache.go b/vendor/k8s.io/client-go/tools/cache/mutation_cache.go index cbb6434e..4c6686e9 100644 --- a/vendor/k8s.io/client-go/tools/cache/mutation_cache.go +++ b/vendor/k8s.io/client-go/tools/cache/mutation_cache.go @@ -22,7 +22,7 @@ import ( "sync" "time" - "github.com/golang/glog" + "k8s.io/klog" "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime" @@ -156,7 +156,7 @@ func (c *mutationCache) ByIndex(name string, indexKey string) ([]interface{}, er } elements, err := fn(updated) if err != nil { - glog.V(4).Infof("Unable to calculate an index entry for mutation cache entry %s: %v", key, err) + klog.V(4).Infof("Unable to calculate an index entry for mutation cache entry %s: %v", key, err) continue } for _, inIndex := range elements { diff --git a/vendor/k8s.io/client-go/tools/cache/mutation_detector.go b/vendor/k8s.io/client-go/tools/cache/mutation_detector.go index e2aa4484..adb5b8be 100644 --- a/vendor/k8s.io/client-go/tools/cache/mutation_detector.go +++ b/vendor/k8s.io/client-go/tools/cache/mutation_detector.go @@ -24,7 +24,7 @@ import ( "sync" "time" - "github.com/golang/glog" + "k8s.io/klog" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/util/diff" @@ -45,7 +45,7 @@ func NewCacheMutationDetector(name string) CacheMutationDetector { if !mutationDetectionEnabled { return dummyMutationDetector{} } - glog.Warningln("Mutation detector is enabled, this will result in memory leakage.") + klog.Warningln("Mutation detector is enabled, this will result in memory leakage.") return &defaultCacheMutationDetector{name: name, period: 1 * time.Second} } diff --git a/vendor/k8s.io/client-go/tools/cache/reflector.go b/vendor/k8s.io/client-go/tools/cache/reflector.go index 9ee7efcb..12e2a334 100644 --- a/vendor/k8s.io/client-go/tools/cache/reflector.go +++ b/vendor/k8s.io/client-go/tools/cache/reflector.go @@ -31,7 +31,6 @@ import ( "syscall" "time" - "github.com/golang/glog" apierrs "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -41,6 +40,7 @@ import ( utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/watch" + "k8s.io/klog" ) // Reflector watches a specified resource and causes all changes to be reflected in the given store. @@ -128,7 +128,7 @@ var internalPackages = []string{"client-go/tools/cache/"} // Run starts a watch and handles watch events. Will restart the watch if it is closed. // Run will exit when stopCh is closed. func (r *Reflector) Run(stopCh <-chan struct{}) { - glog.V(3).Infof("Starting reflector %v (%s) from %s", r.expectedType, r.resyncPeriod, r.name) + klog.V(3).Infof("Starting reflector %v (%s) from %s", r.expectedType, r.resyncPeriod, r.name) wait.Until(func() { if err := r.ListAndWatch(stopCh); err != nil { utilruntime.HandleError(err) @@ -166,7 +166,7 @@ func (r *Reflector) resyncChan() (<-chan time.Time, func() bool) { // and then use the resource version to watch. // It returns error if ListAndWatch didn't even try to initialize watch. func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { - glog.V(3).Infof("Listing and watching %v from %s", r.expectedType, r.name) + klog.V(3).Infof("Listing and watching %v from %s", r.expectedType, r.name) var resourceVersion string // Explicitly set "0" as resource version - it's fine for the List() @@ -212,7 +212,7 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { return } if r.ShouldResync == nil || r.ShouldResync() { - glog.V(4).Infof("%s: forcing resync", r.name) + klog.V(4).Infof("%s: forcing resync", r.name) if err := r.store.Resync(); err != nil { resyncerrc <- err return @@ -246,7 +246,7 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { case io.EOF: // watch closed normally case io.ErrUnexpectedEOF: - glog.V(1).Infof("%s: Watch for %v closed with unexpected EOF: %v", r.name, r.expectedType, err) + klog.V(1).Infof("%s: Watch for %v closed with unexpected EOF: %v", r.name, r.expectedType, err) default: utilruntime.HandleError(fmt.Errorf("%s: Failed to watch %v: %v", r.name, r.expectedType, err)) } @@ -267,7 +267,7 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { if err := r.watchHandler(w, &resourceVersion, resyncerrc, stopCh); err != nil { if err != errorStopRequested { - glog.Warningf("%s: watch of %v ended with: %v", r.name, r.expectedType, err) + klog.Warningf("%s: watch of %v ended with: %v", r.name, r.expectedType, err) } return nil } @@ -354,7 +354,7 @@ loop: r.metrics.numberOfShortWatches.Inc() return fmt.Errorf("very short watch: %s: Unexpected watch close - watch lasted less than a second and no items received", r.name) } - glog.V(4).Infof("%s: Watch close - %v total %v items received", r.name, r.expectedType, eventCount) + klog.V(4).Infof("%s: Watch close - %v total %v items received", r.name, r.expectedType, eventCount) return nil } diff --git a/vendor/k8s.io/client-go/tools/cache/shared_informer.go b/vendor/k8s.io/client-go/tools/cache/shared_informer.go index f29a4b33..e91fc9e9 100644 --- a/vendor/k8s.io/client-go/tools/cache/shared_informer.go +++ b/vendor/k8s.io/client-go/tools/cache/shared_informer.go @@ -28,7 +28,7 @@ import ( "k8s.io/client-go/util/buffer" "k8s.io/client-go/util/retry" - "github.com/golang/glog" + "k8s.io/klog" ) // SharedInformer has a shared data cache and is capable of distributing notifications for changes @@ -116,11 +116,11 @@ func WaitForCacheSync(stopCh <-chan struct{}, cacheSyncs ...InformerSynced) bool }, stopCh) if err != nil { - glog.V(2).Infof("stop requested") + klog.V(2).Infof("stop requested") return false } - glog.V(4).Infof("caches populated") + klog.V(4).Infof("caches populated") return true } @@ -279,11 +279,11 @@ func determineResyncPeriod(desired, check time.Duration) time.Duration { return desired } if check == 0 { - glog.Warningf("The specified resyncPeriod %v is invalid because this shared informer doesn't support resyncing", desired) + klog.Warningf("The specified resyncPeriod %v is invalid because this shared informer doesn't support resyncing", desired) return 0 } if desired < check { - glog.Warningf("The specified resyncPeriod %v is being increased to the minimum resyncCheckPeriod %v", desired, check) + klog.Warningf("The specified resyncPeriod %v is being increased to the minimum resyncCheckPeriod %v", desired, check) return check } return desired @@ -296,19 +296,19 @@ func (s *sharedIndexInformer) AddEventHandlerWithResyncPeriod(handler ResourceEv defer s.startedLock.Unlock() if s.stopped { - glog.V(2).Infof("Handler %v was not added to shared informer because it has stopped already", handler) + klog.V(2).Infof("Handler %v was not added to shared informer because it has stopped already", handler) return } if resyncPeriod > 0 { if resyncPeriod < minimumResyncPeriod { - glog.Warningf("resyncPeriod %d is too small. Changing it to the minimum allowed value of %d", resyncPeriod, minimumResyncPeriod) + klog.Warningf("resyncPeriod %d is too small. Changing it to the minimum allowed value of %d", resyncPeriod, minimumResyncPeriod) resyncPeriod = minimumResyncPeriod } if resyncPeriod < s.resyncCheckPeriod { if s.started { - glog.Warningf("resyncPeriod %d is smaller than resyncCheckPeriod %d and the informer has already started. Changing it to %d", resyncPeriod, s.resyncCheckPeriod, s.resyncCheckPeriod) + klog.Warningf("resyncPeriod %d is smaller than resyncCheckPeriod %d and the informer has already started. Changing it to %d", resyncPeriod, s.resyncCheckPeriod, s.resyncCheckPeriod) resyncPeriod = s.resyncCheckPeriod } else { // if the event handler's resyncPeriod is smaller than the current resyncCheckPeriod, update diff --git a/vendor/k8s.io/client-go/tools/clientcmd/client_config.go b/vendor/k8s.io/client-go/tools/clientcmd/client_config.go index e5dc921f..dea229c9 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/client_config.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/client_config.go @@ -24,8 +24,8 @@ import ( "os" "strings" - "github.com/golang/glog" "github.com/imdario/mergo" + "k8s.io/klog" restclient "k8s.io/client-go/rest" clientauth "k8s.io/client-go/tools/auth" @@ -545,12 +545,12 @@ func (config *inClusterClientConfig) Possible() bool { // to the default config. func BuildConfigFromFlags(masterUrl, kubeconfigPath string) (*restclient.Config, error) { if kubeconfigPath == "" && masterUrl == "" { - glog.Warningf("Neither --kubeconfig nor --master was specified. Using the inClusterConfig. This might not work.") + klog.Warningf("Neither --kubeconfig nor --master was specified. Using the inClusterConfig. This might not work.") kubeconfig, err := restclient.InClusterConfig() if err == nil { return kubeconfig, nil } - glog.Warning("error creating inClusterConfig, falling back to default config: ", err) + klog.Warning("error creating inClusterConfig, falling back to default config: ", err) } return NewNonInteractiveDeferredLoadingClientConfig( &ClientConfigLoadingRules{ExplicitPath: kubeconfigPath}, diff --git a/vendor/k8s.io/client-go/tools/clientcmd/config.go b/vendor/k8s.io/client-go/tools/clientcmd/config.go index 9495849b..b8cc3968 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/config.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/config.go @@ -24,7 +24,7 @@ import ( "reflect" "sort" - "github.com/golang/glog" + "k8s.io/klog" restclient "k8s.io/client-go/rest" clientcmdapi "k8s.io/client-go/tools/clientcmd/api" @@ -483,7 +483,7 @@ func getConfigFromFile(filename string) (*clientcmdapi.Config, error) { func GetConfigFromFileOrDie(filename string) *clientcmdapi.Config { config, err := getConfigFromFile(filename) if err != nil { - glog.FatalDepth(1, err) + klog.FatalDepth(1, err) } return config diff --git a/vendor/k8s.io/client-go/tools/clientcmd/loader.go b/vendor/k8s.io/client-go/tools/clientcmd/loader.go index 6038c8d4..7e928a91 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/loader.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/loader.go @@ -27,8 +27,8 @@ import ( goruntime "runtime" "strings" - "github.com/golang/glog" "github.com/imdario/mergo" + "k8s.io/klog" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" @@ -356,7 +356,7 @@ func LoadFromFile(filename string) (*clientcmdapi.Config, error) { if err != nil { return nil, err } - glog.V(6).Infoln("Config loaded from file", filename) + klog.V(6).Infoln("Config loaded from file", filename) // set LocationOfOrigin on every Cluster, User, and Context for key, obj := range config.AuthInfos { diff --git a/vendor/k8s.io/client-go/tools/clientcmd/merged_client_builder.go b/vendor/k8s.io/client-go/tools/clientcmd/merged_client_builder.go index 05038133..76380db8 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/merged_client_builder.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/merged_client_builder.go @@ -20,7 +20,7 @@ import ( "io" "sync" - "github.com/golang/glog" + "k8s.io/klog" restclient "k8s.io/client-go/rest" clientcmdapi "k8s.io/client-go/tools/clientcmd/api" @@ -119,7 +119,7 @@ func (config *DeferredLoadingClientConfig) ClientConfig() (*restclient.Config, e // check for in-cluster configuration and use it if config.icc.Possible() { - glog.V(4).Infof("Using in-cluster configuration") + klog.V(4).Infof("Using in-cluster configuration") return config.icc.ClientConfig() } @@ -156,7 +156,7 @@ func (config *DeferredLoadingClientConfig) Namespace() (string, bool, error) { } } - glog.V(4).Infof("Using in-cluster namespace") + klog.V(4).Infof("Using in-cluster namespace") // allow the namespace from the service account token directory to be used. return config.icc.Namespace() diff --git a/vendor/k8s.io/client-go/tools/record/event.go b/vendor/k8s.io/client-go/tools/record/event.go index 168dfa80..2ee69589 100644 --- a/vendor/k8s.io/client-go/tools/record/event.go +++ b/vendor/k8s.io/client-go/tools/record/event.go @@ -33,7 +33,7 @@ import ( "net/http" - "github.com/golang/glog" + "k8s.io/klog" ) const maxTriesPerEvent = 12 @@ -144,7 +144,7 @@ func recordToSink(sink EventSink, event *v1.Event, eventCorrelator *EventCorrela } tries++ if tries >= maxTriesPerEvent { - glog.Errorf("Unable to write event '%#v' (retry limit exceeded!)", event) + klog.Errorf("Unable to write event '%#v' (retry limit exceeded!)", event) break } // Randomize the first sleep so that various clients won't all be @@ -194,13 +194,13 @@ func recordEvent(sink EventSink, event *v1.Event, patch []byte, updateExistingEv switch err.(type) { case *restclient.RequestConstructionError: // We will construct the request the same next time, so don't keep trying. - glog.Errorf("Unable to construct event '%#v': '%v' (will not retry!)", event, err) + klog.Errorf("Unable to construct event '%#v': '%v' (will not retry!)", event, err) return true case *errors.StatusError: if errors.IsAlreadyExists(err) { - glog.V(5).Infof("Server rejected event '%#v': '%v' (will not retry!)", event, err) + klog.V(5).Infof("Server rejected event '%#v': '%v' (will not retry!)", event, err) } else { - glog.Errorf("Server rejected event '%#v': '%v' (will not retry!)", event, err) + klog.Errorf("Server rejected event '%#v': '%v' (will not retry!)", event, err) } return true case *errors.UnexpectedObjectError: @@ -209,7 +209,7 @@ func recordEvent(sink EventSink, event *v1.Event, patch []byte, updateExistingEv default: // This case includes actual http transport errors. Go ahead and retry. } - glog.Errorf("Unable to write event: '%v' (may retry after sleeping)", err) + klog.Errorf("Unable to write event: '%v' (may retry after sleeping)", err) return false } @@ -256,12 +256,12 @@ type recorderImpl struct { func (recorder *recorderImpl) generateEvent(object runtime.Object, annotations map[string]string, timestamp metav1.Time, eventtype, reason, message string) { ref, err := ref.GetReference(recorder.scheme, object) if err != nil { - glog.Errorf("Could not construct reference to: '%#v' due to: '%v'. Will not report event: '%v' '%v' '%v'", object, err, eventtype, reason, message) + klog.Errorf("Could not construct reference to: '%#v' due to: '%v'. Will not report event: '%v' '%v' '%v'", object, err, eventtype, reason, message) return } if !validateEventType(eventtype) { - glog.Errorf("Unsupported event type: '%v'", eventtype) + klog.Errorf("Unsupported event type: '%v'", eventtype) return } diff --git a/vendor/k8s.io/client-go/transport/round_trippers.go b/vendor/k8s.io/client-go/transport/round_trippers.go index 0ebcbbc8..da417cf9 100644 --- a/vendor/k8s.io/client-go/transport/round_trippers.go +++ b/vendor/k8s.io/client-go/transport/round_trippers.go @@ -22,7 +22,7 @@ import ( "strings" "time" - "github.com/golang/glog" + "k8s.io/klog" utilnet "k8s.io/apimachinery/pkg/util/net" ) @@ -62,13 +62,13 @@ func HTTPWrappersForConfig(config *Config, rt http.RoundTripper) (http.RoundTrip // DebugWrappers wraps a round tripper and logs based on the current log level. func DebugWrappers(rt http.RoundTripper) http.RoundTripper { switch { - case bool(glog.V(9)): + case bool(klog.V(9)): rt = newDebuggingRoundTripper(rt, debugCurlCommand, debugURLTiming, debugResponseHeaders) - case bool(glog.V(8)): + case bool(klog.V(8)): rt = newDebuggingRoundTripper(rt, debugJustURL, debugRequestHeaders, debugResponseStatus, debugResponseHeaders) - case bool(glog.V(7)): + case bool(klog.V(7)): rt = newDebuggingRoundTripper(rt, debugJustURL, debugRequestHeaders, debugResponseStatus) - case bool(glog.V(6)): + case bool(klog.V(6)): rt = newDebuggingRoundTripper(rt, debugURLTiming) } @@ -138,7 +138,7 @@ func (rt *authProxyRoundTripper) CancelRequest(req *http.Request) { if canceler, ok := rt.rt.(requestCanceler); ok { canceler.CancelRequest(req) } else { - glog.Errorf("CancelRequest not implemented by %T", rt.rt) + klog.Errorf("CancelRequest not implemented by %T", rt.rt) } } @@ -166,7 +166,7 @@ func (rt *userAgentRoundTripper) CancelRequest(req *http.Request) { if canceler, ok := rt.rt.(requestCanceler); ok { canceler.CancelRequest(req) } else { - glog.Errorf("CancelRequest not implemented by %T", rt.rt) + klog.Errorf("CancelRequest not implemented by %T", rt.rt) } } @@ -197,7 +197,7 @@ func (rt *basicAuthRoundTripper) CancelRequest(req *http.Request) { if canceler, ok := rt.rt.(requestCanceler); ok { canceler.CancelRequest(req) } else { - glog.Errorf("CancelRequest not implemented by %T", rt.rt) + klog.Errorf("CancelRequest not implemented by %T", rt.rt) } } @@ -257,7 +257,7 @@ func (rt *impersonatingRoundTripper) CancelRequest(req *http.Request) { if canceler, ok := rt.delegate.(requestCanceler); ok { canceler.CancelRequest(req) } else { - glog.Errorf("CancelRequest not implemented by %T", rt.delegate) + klog.Errorf("CancelRequest not implemented by %T", rt.delegate) } } @@ -288,7 +288,7 @@ func (rt *bearerAuthRoundTripper) CancelRequest(req *http.Request) { if canceler, ok := rt.rt.(requestCanceler); ok { canceler.CancelRequest(req) } else { - glog.Errorf("CancelRequest not implemented by %T", rt.rt) + klog.Errorf("CancelRequest not implemented by %T", rt.rt) } } @@ -372,7 +372,7 @@ func (rt *debuggingRoundTripper) CancelRequest(req *http.Request) { if canceler, ok := rt.delegatedRoundTripper.(requestCanceler); ok { canceler.CancelRequest(req) } else { - glog.Errorf("CancelRequest not implemented by %T", rt.delegatedRoundTripper) + klog.Errorf("CancelRequest not implemented by %T", rt.delegatedRoundTripper) } } @@ -380,17 +380,17 @@ func (rt *debuggingRoundTripper) RoundTrip(req *http.Request) (*http.Response, e reqInfo := newRequestInfo(req) if rt.levels[debugJustURL] { - glog.Infof("%s %s", reqInfo.RequestVerb, reqInfo.RequestURL) + klog.Infof("%s %s", reqInfo.RequestVerb, reqInfo.RequestURL) } if rt.levels[debugCurlCommand] { - glog.Infof("%s", reqInfo.toCurl()) + klog.Infof("%s", reqInfo.toCurl()) } if rt.levels[debugRequestHeaders] { - glog.Infof("Request Headers:") + klog.Infof("Request Headers:") for key, values := range reqInfo.RequestHeaders { for _, value := range values { - glog.Infof(" %s: %s", key, value) + klog.Infof(" %s: %s", key, value) } } } @@ -402,16 +402,16 @@ func (rt *debuggingRoundTripper) RoundTrip(req *http.Request) (*http.Response, e reqInfo.complete(response, err) if rt.levels[debugURLTiming] { - glog.Infof("%s %s %s in %d milliseconds", reqInfo.RequestVerb, reqInfo.RequestURL, reqInfo.ResponseStatus, reqInfo.Duration.Nanoseconds()/int64(time.Millisecond)) + klog.Infof("%s %s %s in %d milliseconds", reqInfo.RequestVerb, reqInfo.RequestURL, reqInfo.ResponseStatus, reqInfo.Duration.Nanoseconds()/int64(time.Millisecond)) } if rt.levels[debugResponseStatus] { - glog.Infof("Response Status: %s in %d milliseconds", reqInfo.ResponseStatus, reqInfo.Duration.Nanoseconds()/int64(time.Millisecond)) + klog.Infof("Response Status: %s in %d milliseconds", reqInfo.ResponseStatus, reqInfo.Duration.Nanoseconds()/int64(time.Millisecond)) } if rt.levels[debugResponseHeaders] { - glog.Infof("Response Headers:") + klog.Infof("Response Headers:") for key, values := range reqInfo.ResponseHeaders { for _, value := range values { - glog.Infof(" %s: %s", key, value) + klog.Infof(" %s: %s", key, value) } } } diff --git a/vendor/k8s.io/code-generator/Godeps/Godeps.json b/vendor/k8s.io/code-generator/Godeps/Godeps.json index 9f511d18..4546feed 100644 --- a/vendor/k8s.io/code-generator/Godeps/Godeps.json +++ b/vendor/k8s.io/code-generator/Godeps/Godeps.json @@ -106,10 +106,6 @@ "ImportPath": "github.com/gogo/protobuf/vanity/command", "Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02" }, - { - "ImportPath": "github.com/golang/glog", - "Rev": "44145f04b68cf362d9c4df2182967c2275eaefed" - }, { "ImportPath": "github.com/spf13/pflag", "Rev": "583c0c0531f06d5278b7d917446061adc344b5cd" @@ -124,43 +120,47 @@ }, { "ImportPath": "k8s.io/gengo/args", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/examples/deepcopy-gen/generators", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/examples/defaulter-gen/generators", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/examples/import-boss/generators", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/examples/set-gen/generators", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/examples/set-gen/sets", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/generator", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/namer", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/parser", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" }, { "ImportPath": "k8s.io/gengo/types", - "Rev": "fdcf9f9480fdd5bf2b3c3df9bf4ecd22b25b87e2" + "Rev": "51747d6e00da1fc578d5a333a93bb2abcbce7a95" + }, + { + "ImportPath": "k8s.io/klog", + "Rev": "8139d8cb77af419532b33dfa7dd09fbc5f1d344f" } ] } diff --git a/vendor/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go b/vendor/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go index bf536878..ee6ebbcf 100644 --- a/vendor/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go +++ b/vendor/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go @@ -32,7 +32,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) // NameSystems returns the name system used by the generators in this package. @@ -318,12 +318,12 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } customArgs, ok := arguments.CustomArgs.(*clientgenargs.CustomArgs) if !ok { - glog.Fatalf("cannot convert arguments.CustomArgs to clientgenargs.CustomArgs") + klog.Fatalf("cannot convert arguments.CustomArgs to clientgenargs.CustomArgs") } includedTypesOverrides := customArgs.IncludedTypesOverrides diff --git a/vendor/k8s.io/code-generator/cmd/client-gen/main.go b/vendor/k8s.io/code-generator/cmd/client-gen/main.go index 22c28e35..6e0d187f 100644 --- a/vendor/k8s.io/code-generator/cmd/client-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/client-gen/main.go @@ -21,9 +21,9 @@ import ( "flag" "path/filepath" - "github.com/golang/glog" "github.com/spf13/pflag" "k8s.io/gengo/args" + "k8s.io/klog" generatorargs "k8s.io/code-generator/cmd/client-gen/args" "k8s.io/code-generator/cmd/client-gen/generators" @@ -31,6 +31,7 @@ import ( ) func main() { + klog.InitFlags(nil) genericArgs, customArgs := generatorargs.NewDefaults() // Override defaults. @@ -52,7 +53,7 @@ func main() { } if err := generatorargs.Validate(genericArgs); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } if err := genericArgs.Execute( @@ -60,6 +61,6 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } } diff --git a/vendor/k8s.io/code-generator/cmd/conversion-gen/generators/conversion.go b/vendor/k8s.io/code-generator/cmd/conversion-gen/generators/conversion.go index 422237e1..775972d1 100644 --- a/vendor/k8s.io/code-generator/cmd/conversion-gen/generators/conversion.go +++ b/vendor/k8s.io/code-generator/cmd/conversion-gen/generators/conversion.go @@ -29,7 +29,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" conversionargs "k8s.io/code-generator/cmd/conversion-gen/args" ) @@ -124,10 +124,10 @@ type conversionFuncMap map[conversionPair]*types.Type // Returns all manually-defined conversion functions in the package. func getManualConversionFunctions(context *generator.Context, pkg *types.Package, manualMap conversionFuncMap) { if pkg == nil { - glog.Warningf("Skipping nil package passed to getManualConversionFunctions") + klog.Warningf("Skipping nil package passed to getManualConversionFunctions") return } - glog.V(5).Infof("Scanning for conversion functions in %v", pkg.Name) + klog.V(5).Infof("Scanning for conversion functions in %v", pkg.Name) scopeName := types.Ref(conversionPackagePath, "Scope").Name errorName := types.Ref("", "error").Name @@ -136,34 +136,34 @@ func getManualConversionFunctions(context *generator.Context, pkg *types.Package for _, f := range pkg.Functions { if f.Underlying == nil || f.Underlying.Kind != types.Func { - glog.Errorf("Malformed function: %#v", f) + klog.Errorf("Malformed function: %#v", f) continue } if f.Underlying.Signature == nil { - glog.Errorf("Function without signature: %#v", f) + klog.Errorf("Function without signature: %#v", f) continue } - glog.V(8).Infof("Considering function %s", f.Name) + klog.V(8).Infof("Considering function %s", f.Name) signature := f.Underlying.Signature // Check whether the function is conversion function. // Note that all of them have signature: // func Convert_inType_To_outType(inType, outType, conversion.Scope) error if signature.Receiver != nil { - glog.V(8).Infof("%s has a receiver", f.Name) + klog.V(8).Infof("%s has a receiver", f.Name) continue } if len(signature.Parameters) != 3 || signature.Parameters[2].Name != scopeName { - glog.V(8).Infof("%s has wrong parameters", f.Name) + klog.V(8).Infof("%s has wrong parameters", f.Name) continue } if len(signature.Results) != 1 || signature.Results[0].Name != errorName { - glog.V(8).Infof("%s has wrong results", f.Name) + klog.V(8).Infof("%s has wrong results", f.Name) continue } inType := signature.Parameters[0] outType := signature.Parameters[1] if inType.Kind != types.Pointer || outType.Kind != types.Pointer { - glog.V(8).Infof("%s has wrong parameter types", f.Name) + klog.V(8).Infof("%s has wrong parameter types", f.Name) continue } // Now check if the name satisfies the convention. @@ -171,7 +171,7 @@ func getManualConversionFunctions(context *generator.Context, pkg *types.Package args := argsFromType(inType.Elem, outType.Elem) sw.Do("Convert_$.inType|public$_To_$.outType|public$", args) if f.Name.Name == buffer.String() { - glog.V(4).Infof("Found conversion function %s", f.Name) + klog.V(4).Infof("Found conversion function %s", f.Name) key := conversionPair{inType.Elem, outType.Elem} // We might scan the same package twice, and that's OK. if v, ok := manualMap[key]; ok && v != nil && v.Name.Package != pkg.Path { @@ -181,9 +181,9 @@ func getManualConversionFunctions(context *generator.Context, pkg *types.Package } else { // prevent user error when they don't get the correct conversion signature if strings.HasPrefix(f.Name.Name, "Convert_") { - glog.Errorf("Rename function %s %s -> %s to match expected conversion signature", f.Name.Package, f.Name.Name, buffer.String()) + klog.Errorf("Rename function %s %s -> %s to match expected conversion signature", f.Name.Package, f.Name.Name, buffer.String()) } - glog.V(8).Infof("%s has wrong name", f.Name) + klog.V(8).Infof("%s has wrong name", f.Name) } buffer.Reset() } @@ -192,7 +192,7 @@ func getManualConversionFunctions(context *generator.Context, pkg *types.Package func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } packages := generator.Packages{} @@ -220,7 +220,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } processed[i] = true - glog.V(5).Infof("considering pkg %q", i) + klog.V(5).Infof("considering pkg %q", i) pkg := context.Universe[i] // typesPkg is where the versioned types are defined. Sometimes it is // different from pkg. For example, kubernetes core/v1 types are defined @@ -239,9 +239,9 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat // in their doc.go file. peerPkgs := extractTag(pkg.Comments) if peerPkgs != nil { - glog.V(5).Infof(" tags: %q", peerPkgs) + klog.V(5).Infof(" tags: %q", peerPkgs) } else { - glog.V(5).Infof(" no tag") + klog.V(5).Infof(" no tag") continue } skipUnsafe := false @@ -255,14 +255,14 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat externalTypesValues := extractExternalTypesTag(pkg.Comments) if externalTypesValues != nil { if len(externalTypesValues) != 1 { - glog.Fatalf(" expect only one value for %q tag, got: %q", externalTypesTagName, externalTypesValues) + klog.Fatalf(" expect only one value for %q tag, got: %q", externalTypesTagName, externalTypesValues) } externalTypes := externalTypesValues[0] - glog.V(5).Infof(" external types tags: %q", externalTypes) + klog.V(5).Infof(" external types tags: %q", externalTypes) var err error typesPkg, err = context.AddDirectory(externalTypes) if err != nil { - glog.Fatalf("cannot import package %s", externalTypes) + klog.Fatalf("cannot import package %s", externalTypes) } // update context.Order to the latest context.Universe orderer := namer.Orderer{Namer: namer.NewPublicNamer(1)} @@ -291,7 +291,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat context.AddDir(pp) p := context.Universe[pp] if nil == p { - glog.Fatalf("failed to find pkg: %s", pp) + klog.Fatalf("failed to find pkg: %s", pp) } getManualConversionFunctions(context, p, manualConversions) } @@ -335,7 +335,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat // from being a candidate for unsafe conversion for k, v := range manualConversions { if isCopyOnly(v.CommentLines) { - glog.V(5).Infof("Conversion function %s will not block memory copy because it is copy-only", v.Name) + klog.V(5).Infof("Conversion function %s will not block memory copy because it is copy-only", v.Name) continue } // this type should be excluded from all equivalence, because the converter must be called. @@ -518,9 +518,9 @@ func (g *genConversion) convertibleOnlyWithinPackage(inType, outType *types.Type tagvals := extractTag(t.CommentLines) if tagvals != nil { if tagvals[0] != "false" { - glog.Fatalf("Type %v: unsupported %s value: %q", t, tagName, tagvals[0]) + klog.Fatalf("Type %v: unsupported %s value: %q", t, tagName, tagvals[0]) } - glog.V(5).Infof("type %v requests no conversion generation, skipping", t) + klog.V(5).Infof("type %v requests no conversion generation, skipping", t) return false } // TODO: Consider generating functions for other kinds too. @@ -582,10 +582,10 @@ func (g *genConversion) preexists(inType, outType *types.Type) (*types.Type, boo } func (g *genConversion) Init(c *generator.Context, w io.Writer) error { - if glog.V(5) { + if klog.V(5) { if m, ok := g.useUnsafe.(equalMemoryTypes); ok { var result []string - glog.Infof("All objects without identical memory layout:") + klog.Infof("All objects without identical memory layout:") for k, v := range m { if v { continue @@ -594,7 +594,7 @@ func (g *genConversion) Init(c *generator.Context, w io.Writer) error { } sort.Strings(result) for _, s := range result { - glog.Infof(s) + klog.Infof(s) } } } @@ -643,7 +643,7 @@ func (g *genConversion) Init(c *generator.Context, w io.Writer) error { } func (g *genConversion) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { - glog.V(5).Infof("generating for type %v", t) + klog.V(5).Infof("generating for type %v", t) peerType := getPeerTypeFor(c, t, g.peerPackages) sw := generator.NewSnippetWriter(w, c, "$", "$") g.generateConversion(t, peerType, sw) @@ -664,10 +664,10 @@ func (g *genConversion) generateConversion(inType, outType *types.Type, sw *gene // There is a public manual Conversion method: use it. } else if skipped := g.skippedFields[inType]; len(skipped) != 0 { // The inType had some fields we could not generate. - glog.Errorf("Warning: could not find nor generate a final Conversion function for %v -> %v", inType, outType) - glog.Errorf(" the following fields need manual conversion:") + klog.Errorf("Warning: could not find nor generate a final Conversion function for %v -> %v", inType, outType) + klog.Errorf(" the following fields need manual conversion:") for _, f := range skipped { - glog.Errorf(" - %v", f) + klog.Errorf(" - %v", f) } } else { // Emit a public conversion function. @@ -682,7 +682,7 @@ func (g *genConversion) generateConversion(inType, outType *types.Type, sw *gene // at any nesting level. This makes the autogenerator easy to understand, and // the compiler shouldn't care. func (g *genConversion) generateFor(inType, outType *types.Type, sw *generator.SnippetWriter) { - glog.V(5).Infof("generating %v -> %v", inType, outType) + klog.V(5).Infof("generating %v -> %v", inType, outType) var f func(*types.Type, *types.Type, *generator.SnippetWriter) switch inType.Kind { @@ -853,7 +853,7 @@ func (g *genConversion) doStruct(inType, outType *types.Type, sw *generator.Snip sw.Do("}\n", nil) continue } - glog.V(5).Infof("Skipped function %s because it is copy-only and we can use direct assignment", function.Name) + klog.V(5).Infof("Skipped function %s because it is copy-only and we can use direct assignment", function.Name) } // If we can't auto-convert, punt before we emit any code. diff --git a/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go b/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go index f2b91cc2..698baa7d 100644 --- a/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/conversion-gen/main.go @@ -38,9 +38,9 @@ import ( "flag" "path/filepath" - "github.com/golang/glog" "github.com/spf13/pflag" "k8s.io/gengo/args" + "k8s.io/klog" generatorargs "k8s.io/code-generator/cmd/conversion-gen/args" "k8s.io/code-generator/cmd/conversion-gen/generators" @@ -48,6 +48,7 @@ import ( ) func main() { + klog.InitFlags(nil) genericArgs, customArgs := generatorargs.NewDefaults() // Override defaults. @@ -61,7 +62,7 @@ func main() { pflag.Parse() if err := generatorargs.Validate(genericArgs); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } // Run it. @@ -70,7 +71,7 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go b/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go index cce65b77..96fb2987 100644 --- a/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go @@ -46,16 +46,17 @@ import ( "flag" "path/filepath" - "github.com/golang/glog" "github.com/spf13/pflag" "k8s.io/gengo/args" "k8s.io/gengo/examples/deepcopy-gen/generators" + "k8s.io/klog" generatorargs "k8s.io/code-generator/cmd/deepcopy-gen/args" "k8s.io/code-generator/pkg/util" ) func main() { + klog.InitFlags(nil) genericArgs, customArgs := generatorargs.NewDefaults() // Override defaults. @@ -69,7 +70,7 @@ func main() { pflag.Parse() if err := generatorargs.Validate(genericArgs); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } // Run it. @@ -78,7 +79,7 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go b/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go index 9d33f700..40bb875e 100644 --- a/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/defaulter-gen/main.go @@ -45,16 +45,17 @@ import ( "flag" "path/filepath" - "github.com/golang/glog" "github.com/spf13/pflag" "k8s.io/gengo/args" "k8s.io/gengo/examples/defaulter-gen/generators" + "k8s.io/klog" generatorargs "k8s.io/code-generator/cmd/defaulter-gen/args" "k8s.io/code-generator/pkg/util" ) func main() { + klog.InitFlags(nil) genericArgs, customArgs := generatorargs.NewDefaults() // Override defaults. @@ -68,7 +69,7 @@ func main() { pflag.Parse() if err := generatorargs.Validate(genericArgs); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } // Run it. @@ -77,7 +78,7 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go index 49e8297d..1a9803dc 100644 --- a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go +++ b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/generator.go @@ -25,7 +25,7 @@ import ( "strconv" "strings" - "github.com/golang/glog" + "k8s.io/klog" "k8s.io/gengo/generator" "k8s.io/gengo/namer" @@ -85,7 +85,7 @@ func (g *genProtoIDL) Filter(c *generator.Context, t *types.Type) bool { // Type specified "true". return true } - glog.Fatalf(`Comment tag "protobuf" must be true or false, found: %q`, tagVals[0]) + klog.Fatalf(`Comment tag "protobuf" must be true or false, found: %q`, tagVals[0]) } if !g.generateAll { // We're not generating everything. diff --git a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/tags.go b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/tags.go index 2dff5b92..8e2a1917 100644 --- a/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/tags.go +++ b/vendor/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/tags.go @@ -17,8 +17,8 @@ limitations under the License. package protobuf import ( - "github.com/golang/glog" "k8s.io/gengo/types" + "k8s.io/klog" ) // extractBoolTagOrDie gets the comment-tags for the key and asserts that, if @@ -27,7 +27,7 @@ import ( func extractBoolTagOrDie(key string, lines []string) bool { val, err := types.ExtractSingleBoolCommentTag("+", key, false, lines) if err != nil { - glog.Fatal(err) + klog.Fatal(err) } return val } diff --git a/vendor/k8s.io/code-generator/cmd/import-boss/main.go b/vendor/k8s.io/code-generator/cmd/import-boss/main.go index d9989944..c0f10c3a 100644 --- a/vendor/k8s.io/code-generator/cmd/import-boss/main.go +++ b/vendor/k8s.io/code-generator/cmd/import-boss/main.go @@ -63,10 +63,11 @@ import ( "k8s.io/gengo/args" "k8s.io/gengo/examples/import-boss/generators" - "github.com/golang/glog" + "k8s.io/klog" ) func main() { + klog.InitFlags(nil) arguments := args.Default() // Override defaults. @@ -82,8 +83,8 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Errorf("Error: %v", err) + klog.Errorf("Error: %v", err) os.Exit(1) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factory.go b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factory.go index 5c557db7..62ae109a 100644 --- a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factory.go +++ b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factory.go @@ -25,7 +25,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) // factoryGenerator produces a file of listers for a given GroupVersion and @@ -65,7 +65,7 @@ func (g *factoryGenerator) Imports(c *generator.Context) (imports []string) { func (g *factoryGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { sw := generator.NewSnippetWriter(w, c, "{{", "}}") - glog.V(5).Infof("processing type %v", t) + klog.V(5).Infof("processing type %v", t) gvInterfaces := make(map[string]*types.Type) gvNewFuncs := make(map[string]*types.Type) diff --git a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factoryinterface.go b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factoryinterface.go index 92cde148..fc0668c5 100644 --- a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factoryinterface.go +++ b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/factoryinterface.go @@ -23,7 +23,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) // factoryInterfaceGenerator produces a file of interfaces used to break a dependency cycle for @@ -60,7 +60,7 @@ func (g *factoryInterfaceGenerator) Imports(c *generator.Context) (imports []str func (g *factoryInterfaceGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { sw := generator.NewSnippetWriter(w, c, "{{", "}}") - glog.V(5).Infof("processing type %v", t) + klog.V(5).Infof("processing type %v", t) m := map[string]interface{}{ "cacheSharedIndexInformer": c.Universe.Type(cacheSharedIndexInformer), diff --git a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/informer.go b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/informer.go index 88cc08df..9204d621 100644 --- a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/informer.go +++ b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/informer.go @@ -28,7 +28,7 @@ import ( "k8s.io/code-generator/cmd/client-gen/generators/util" clientgentypes "k8s.io/code-generator/cmd/client-gen/types" - "github.com/golang/glog" + "k8s.io/klog" ) // informerGenerator produces a file of listers for a given GroupVersion and @@ -66,7 +66,7 @@ func (g *informerGenerator) Imports(c *generator.Context) (imports []string) { func (g *informerGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { sw := generator.NewSnippetWriter(w, c, "$", "$") - glog.V(5).Infof("processing type %v", t) + klog.V(5).Infof("processing type %v", t) listerPackage := fmt.Sprintf("%s/%s/%s", g.listersPackage, g.groupPkgName, strings.ToLower(g.groupVersion.Version.NonEmpty())) clientSetInterface := c.Universe.Type(types.Name{Package: g.clientSetPackage, Name: "Interface"}) diff --git a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/packages.go b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/packages.go index 642f9a46..cfb91ceb 100644 --- a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/packages.go +++ b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/packages.go @@ -22,11 +22,11 @@ import ( "path/filepath" "strings" - "github.com/golang/glog" "k8s.io/gengo/args" "k8s.io/gengo/generator" "k8s.io/gengo/namer" "k8s.io/gengo/types" + "k8s.io/klog" "k8s.io/code-generator/cmd/client-gen/generators/util" clientgentypes "k8s.io/code-generator/cmd/client-gen/types" @@ -102,12 +102,12 @@ func vendorless(p string) string { func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } customArgs, ok := arguments.CustomArgs.(*informergenargs.CustomArgs) if !ok { - glog.Fatalf("Wrong CustomArgs type: %T", arguments.CustomArgs) + klog.Fatalf("Wrong CustomArgs type: %T", arguments.CustomArgs) } internalVersionPackagePath := filepath.Join(arguments.OutputPackagePath) @@ -128,7 +128,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat objectMeta, internal, err := objectMetaForPackage(p) if err != nil { - glog.Fatal(err) + klog.Fatal(err) } if objectMeta == nil { // no types in this package had genclient @@ -141,7 +141,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat if internal { lastSlash := strings.LastIndex(p.Path, "/") if lastSlash == -1 { - glog.Fatalf("error constructing internal group version for package %q", p.Path) + klog.Fatalf("error constructing internal group version for package %q", p.Path) } gv.Group = clientgentypes.Group(p.Path[lastSlash+1:]) targetGroupVersions = internalGroupVersions diff --git a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/tags.go b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/tags.go index afa28781..d25d5b63 100644 --- a/vendor/k8s.io/code-generator/cmd/informer-gen/generators/tags.go +++ b/vendor/k8s.io/code-generator/cmd/informer-gen/generators/tags.go @@ -17,8 +17,8 @@ limitations under the License. package generators import ( - "github.com/golang/glog" "k8s.io/gengo/types" + "k8s.io/klog" ) // extractBoolTagOrDie gets the comment-tags for the key and asserts that, if @@ -27,7 +27,7 @@ import ( func extractBoolTagOrDie(key string, lines []string) bool { val, err := types.ExtractSingleBoolCommentTag("+", key, false, lines) if err != nil { - glog.Fatal(err) + klog.Fatal(err) } return val } diff --git a/vendor/k8s.io/code-generator/cmd/informer-gen/main.go b/vendor/k8s.io/code-generator/cmd/informer-gen/main.go index bfe82608..14f3e923 100644 --- a/vendor/k8s.io/code-generator/cmd/informer-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/informer-gen/main.go @@ -20,16 +20,17 @@ import ( "flag" "path/filepath" - "github.com/golang/glog" "github.com/spf13/pflag" "k8s.io/code-generator/cmd/informer-gen/generators" "k8s.io/code-generator/pkg/util" "k8s.io/gengo/args" + "k8s.io/klog" generatorargs "k8s.io/code-generator/cmd/informer-gen/args" ) func main() { + klog.InitFlags(nil) genericArgs, customArgs := generatorargs.NewDefaults() // Override defaults. @@ -47,7 +48,7 @@ func main() { pflag.Parse() if err := generatorargs.Validate(genericArgs); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } // Run it. @@ -56,7 +57,7 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/cmd/lister-gen/generators/lister.go b/vendor/k8s.io/code-generator/cmd/lister-gen/generators/lister.go index cde6e2f7..c8ed5ad4 100644 --- a/vendor/k8s.io/code-generator/cmd/lister-gen/generators/lister.go +++ b/vendor/k8s.io/code-generator/cmd/lister-gen/generators/lister.go @@ -30,7 +30,7 @@ import ( "k8s.io/code-generator/cmd/client-gen/generators/util" clientgentypes "k8s.io/code-generator/cmd/client-gen/types" - "github.com/golang/glog" + "k8s.io/klog" ) // NameSystems returns the name system used by the generators in this package. @@ -66,7 +66,7 @@ func DefaultNameSystem() string { func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } var packageList generator.Packages @@ -75,7 +75,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat objectMeta, internal, err := objectMetaForPackage(p) if err != nil { - glog.Fatal(err) + klog.Fatal(err) } if objectMeta == nil { // no types in this package had genclient @@ -88,7 +88,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat if internal { lastSlash := strings.LastIndex(p.Path, "/") if lastSlash == -1 { - glog.Fatalf("error constructing internal group version for package %q", p.Path) + klog.Fatalf("error constructing internal group version for package %q", p.Path) } gv.Group = clientgentypes.Group(p.Path[lastSlash+1:]) internalGVPkg = p.Path @@ -223,7 +223,7 @@ func (g *listerGenerator) Imports(c *generator.Context) (imports []string) { func (g *listerGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { sw := generator.NewSnippetWriter(w, c, "$", "$") - glog.V(5).Infof("processing type %v", t) + klog.V(5).Infof("processing type %v", t) m := map[string]interface{}{ "Resource": c.Universe.Function(types.Name{Package: t.Name.Package, Name: "Resource"}), "type": t, diff --git a/vendor/k8s.io/code-generator/cmd/lister-gen/generators/tags.go b/vendor/k8s.io/code-generator/cmd/lister-gen/generators/tags.go index afa28781..d25d5b63 100644 --- a/vendor/k8s.io/code-generator/cmd/lister-gen/generators/tags.go +++ b/vendor/k8s.io/code-generator/cmd/lister-gen/generators/tags.go @@ -17,8 +17,8 @@ limitations under the License. package generators import ( - "github.com/golang/glog" "k8s.io/gengo/types" + "k8s.io/klog" ) // extractBoolTagOrDie gets the comment-tags for the key and asserts that, if @@ -27,7 +27,7 @@ import ( func extractBoolTagOrDie(key string, lines []string) bool { val, err := types.ExtractSingleBoolCommentTag("+", key, false, lines) if err != nil { - glog.Fatal(err) + klog.Fatal(err) } return val } diff --git a/vendor/k8s.io/code-generator/cmd/lister-gen/main.go b/vendor/k8s.io/code-generator/cmd/lister-gen/main.go index d5ff8e46..aca16b2b 100644 --- a/vendor/k8s.io/code-generator/cmd/lister-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/lister-gen/main.go @@ -20,16 +20,17 @@ import ( "flag" "path/filepath" - "github.com/golang/glog" "github.com/spf13/pflag" "k8s.io/code-generator/cmd/lister-gen/generators" "k8s.io/code-generator/pkg/util" "k8s.io/gengo/args" + "k8s.io/klog" generatorargs "k8s.io/code-generator/cmd/lister-gen/args" ) func main() { + klog.InitFlags(nil) genericArgs, customArgs := generatorargs.NewDefaults() // Override defaults. @@ -44,7 +45,7 @@ func main() { pflag.Parse() if err := generatorargs.Validate(genericArgs); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } // Run it. @@ -53,7 +54,7 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go b/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go index ca13ca85..5186e421 100644 --- a/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go +++ b/vendor/k8s.io/code-generator/cmd/register-gen/generators/packages.go @@ -22,7 +22,7 @@ import ( "path" "strings" - "github.com/golang/glog" + "k8s.io/klog" clientgentypes "k8s.io/code-generator/cmd/client-gen/types" "k8s.io/gengo/args" @@ -46,7 +46,7 @@ func DefaultNameSystem() string { func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } packages := generator.Packages{} @@ -54,27 +54,27 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat pkg := context.Universe.Package(inputDir) internal, err := isInternal(pkg) if err != nil { - glog.V(5).Infof("skipping the generation of %s file, due to err %v", arguments.OutputFileBaseName, err) + klog.V(5).Infof("skipping the generation of %s file, due to err %v", arguments.OutputFileBaseName, err) continue } if internal { - glog.V(5).Infof("skipping the generation of %s file because %s package contains internal types, note that internal types don't have \"json\" tags", arguments.OutputFileBaseName, pkg.Name) + klog.V(5).Infof("skipping the generation of %s file because %s package contains internal types, note that internal types don't have \"json\" tags", arguments.OutputFileBaseName, pkg.Name) continue } registerFileName := "register.go" searchPath := path.Join(args.DefaultSourceTree(), inputDir, registerFileName) if _, err := os.Stat(path.Join(searchPath)); err == nil { - glog.V(5).Infof("skipping the generation of %s file because %s already exists in the path %s", arguments.OutputFileBaseName, registerFileName, searchPath) + klog.V(5).Infof("skipping the generation of %s file because %s already exists in the path %s", arguments.OutputFileBaseName, registerFileName, searchPath) continue } else if err != nil && !os.IsNotExist(err) { - glog.Fatalf("an error %v has occurred while checking if %s exists", err, registerFileName) + klog.Fatalf("an error %v has occurred while checking if %s exists", err, registerFileName) } gv := clientgentypes.GroupVersion{} { pathParts := strings.Split(pkg.Path, "/") if len(pathParts) < 2 { - glog.Errorf("the path of the package must contain the group name and the version, path = %s", pkg.Path) + klog.Errorf("the path of the package must contain the group name and the version, path = %s", pkg.Path) continue } gv.Group = clientgentypes.Group(pathParts[len(pathParts)-2]) @@ -84,14 +84,14 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat // extract the fully qualified API group name from it and overwrite the group inferred from the package path if override := types.ExtractCommentTags("+", pkg.DocComments)["groupName"]; override != nil { groupName := override[0] - glog.V(5).Infof("overriding the group name with = %s", groupName) + klog.V(5).Infof("overriding the group name with = %s", groupName) gv.Group = clientgentypes.Group(groupName) } } typesToRegister := []*types.Type{} for _, t := range pkg.Types { - glog.V(5).Infof("considering type = %s", t.Name.String()) + klog.V(5).Infof("considering type = %s", t.Name.String()) for _, typeMember := range t.Members { if typeMember.Name == "TypeMeta" && typeMember.Embedded == true { typesToRegister = append(typesToRegister, t) diff --git a/vendor/k8s.io/code-generator/cmd/register-gen/main.go b/vendor/k8s.io/code-generator/cmd/register-gen/main.go index db02a4af..30a175d8 100644 --- a/vendor/k8s.io/code-generator/cmd/register-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/register-gen/main.go @@ -20,8 +20,8 @@ import ( "flag" "path/filepath" - "github.com/golang/glog" "github.com/spf13/pflag" + "k8s.io/klog" generatorargs "k8s.io/code-generator/cmd/register-gen/args" "k8s.io/code-generator/cmd/register-gen/generators" @@ -30,6 +30,7 @@ import ( ) func main() { + klog.InitFlags(nil) genericArgs := generatorargs.NewDefaults() genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), util.BoilerplatePath()) genericArgs.AddFlags(pflag.CommandLine) @@ -38,7 +39,7 @@ func main() { pflag.Parse() if err := generatorargs.Validate(genericArgs); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } if err := genericArgs.Execute( @@ -46,7 +47,7 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Fatalf("Error: %v", err) + klog.Fatalf("Error: %v", err) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/cmd/set-gen/main.go b/vendor/k8s.io/code-generator/cmd/set-gen/main.go index cf8f01d8..45694d4f 100644 --- a/vendor/k8s.io/code-generator/cmd/set-gen/main.go +++ b/vendor/k8s.io/code-generator/cmd/set-gen/main.go @@ -32,10 +32,11 @@ import ( "k8s.io/gengo/args" "k8s.io/gengo/examples/set-gen/generators" - "github.com/golang/glog" + "k8s.io/klog" ) func main() { + klog.InitFlags(nil) arguments := args.Default() // Override defaults. @@ -48,8 +49,8 @@ func main() { generators.DefaultNameSystem(), generators.Packages, ); err != nil { - glog.Errorf("Error: %v", err) + klog.Errorf("Error: %v", err) os.Exit(1) } - glog.V(2).Info("Completed successfully.") + klog.V(2).Info("Completed successfully.") } diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go index dec7dcaf..d9e5cf11 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go @@ -29,7 +29,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) // CustomArgs is used tby the go2idl framework to pass args specific to this @@ -62,7 +62,7 @@ func extractTag(comments []string) *tagValue { } // If there are multiple values, abort. if len(tagVals) > 1 { - glog.Fatalf("Found %d %s tags: %q", len(tagVals), tagName, tagVals) + klog.Fatalf("Found %d %s tags: %q", len(tagVals), tagName, tagVals) } // If we got here we are returning something. @@ -89,7 +89,7 @@ func extractTag(comments []string) *tagValue { tag.register = true } default: - glog.Fatalf("Unsupported %s param: %q", tagName, parts[i]) + klog.Fatalf("Unsupported %s param: %q", tagName, parts[i]) } } return tag @@ -123,7 +123,7 @@ func DefaultNameSystem() string { func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } inputs := sets.NewString(context.Inputs...) @@ -143,7 +143,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } for i := range inputs { - glog.V(5).Infof("Considering pkg %q", i) + klog.V(5).Infof("Considering pkg %q", i) pkg := context.Universe[i] if pkg == nil { // If the input had no Go files, for example. @@ -156,12 +156,12 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat if ptag != nil { ptagValue = ptag.value if ptagValue != tagValuePackage { - glog.Fatalf("Package %v: unsupported %s value: %q", i, tagName, ptagValue) + klog.Fatalf("Package %v: unsupported %s value: %q", i, tagName, ptagValue) } ptagRegister = ptag.register - glog.V(5).Infof(" tag.value: %q, tag.register: %t", ptagValue, ptagRegister) + klog.V(5).Infof(" tag.value: %q, tag.register: %t", ptagValue, ptagRegister) } else { - glog.V(5).Infof(" no tag") + klog.V(5).Infof(" no tag") } // If the pkg-scoped tag says to generate, we can skip scanning types. @@ -170,12 +170,12 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat // If the pkg-scoped tag did not exist, scan all types for one that // explicitly wants generation. for _, t := range pkg.Types { - glog.V(5).Infof(" considering type %q", t.Name.String()) + klog.V(5).Infof(" considering type %q", t.Name.String()) ttag := extractTag(t.CommentLines) if ttag != nil && ttag.value == "true" { - glog.V(5).Infof(" tag=true") + klog.V(5).Infof(" tag=true") if !copyableType(t) { - glog.Fatalf("Type %v requests deepcopy generation but is not copyable", t) + klog.Fatalf("Type %v requests deepcopy generation but is not copyable", t) } pkgNeedsGeneration = true break @@ -184,7 +184,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } if pkgNeedsGeneration { - glog.V(3).Infof("Package %q needs generation", i) + klog.V(3).Infof("Package %q needs generation", i) path := pkg.Path // if the source path is within a /vendor/ directory (for example, // k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1), allow @@ -263,10 +263,10 @@ func (g *genDeepCopy) Filter(c *generator.Context, t *types.Type) bool { return false } if !copyableType(t) { - glog.V(2).Infof("Type %v is not copyable", t) + klog.V(2).Infof("Type %v is not copyable", t) return false } - glog.V(4).Infof("Type %v is copyable", t) + klog.V(4).Infof("Type %v is copyable", t) g.typesForInit = append(g.typesForInit, t) return true } @@ -321,12 +321,12 @@ func deepCopyMethod(t *types.Type) (*types.Signature, error) { return f.Signature, nil } -// deepCopyMethodOrDie returns the signatrue of a DeepCopy method, nil or calls glog.Fatalf +// deepCopyMethodOrDie returns the signatrue of a DeepCopy method, nil or calls klog.Fatalf // if the type does not match. func deepCopyMethodOrDie(t *types.Type) *types.Signature { ret, err := deepCopyMethod(t) if err != nil { - glog.Fatal(err) + klog.Fatal(err) } return ret } @@ -367,12 +367,12 @@ func deepCopyIntoMethod(t *types.Type) (*types.Signature, error) { return f.Signature, nil } -// deepCopyIntoMethodOrDie returns the signature of a DeepCopyInto() method, nil or calls glog.Fatalf +// deepCopyIntoMethodOrDie returns the signature of a DeepCopyInto() method, nil or calls klog.Fatalf // if the type is wrong. func deepCopyIntoMethodOrDie(t *types.Type) *types.Signature { ret, err := deepCopyIntoMethod(t) if err != nil { - glog.Fatal(err) + klog.Fatal(err) } return ret } @@ -465,17 +465,17 @@ func (g *genDeepCopy) needsGeneration(t *types.Type) bool { if tag != nil { tv = tag.value if tv != "true" && tv != "false" { - glog.Fatalf("Type %v: unsupported %s value: %q", t, tagName, tag.value) + klog.Fatalf("Type %v: unsupported %s value: %q", t, tagName, tag.value) } } if g.allTypes && tv == "false" { // The whole package is being generated, but this type has opted out. - glog.V(5).Infof("Not generating for type %v because type opted out", t) + klog.V(5).Infof("Not generating for type %v because type opted out", t) return false } if !g.allTypes && tv != "true" { // The whole package is NOT being generated, and this type has NOT opted in. - glog.V(5).Infof("Not generating for type %v because type did not opt in", t) + klog.V(5).Infof("Not generating for type %v because type did not opt in", t) return false } return true @@ -576,7 +576,7 @@ func (g *genDeepCopy) GenerateType(c *generator.Context, t *types.Type, w io.Wri if !g.needsGeneration(t) { return nil } - glog.V(5).Infof("Generating deepcopy function for type %v", t) + klog.V(5).Infof("Generating deepcopy function for type %v", t) sw := generator.NewSnippetWriter(w, c, "$", "$") args := argsFromType(t) @@ -678,12 +678,12 @@ func (g *genDeepCopy) generateFor(t *types.Type, sw *generator.SnippetWriter) { f = g.doPointer case types.Interface: // interfaces are handled in-line in the other cases - glog.Fatalf("Hit an interface type %v. This should never happen.", t) + klog.Fatalf("Hit an interface type %v. This should never happen.", t) case types.Alias: // can never happen because we branch on the underlying type which is never an alias - glog.Fatalf("Hit an alias type %v. This should never happen.", t) + klog.Fatalf("Hit an alias type %v. This should never happen.", t) default: - glog.Fatalf("Hit an unsupported type %v.", t) + klog.Fatalf("Hit an unsupported type %v.", t) } f(t, sw) } @@ -711,7 +711,7 @@ func (g *genDeepCopy) doMap(t *types.Type, sw *generator.SnippetWriter) { } if !ut.Key.IsAssignable() { - glog.Fatalf("Hit an unsupported type %v.", uet) + klog.Fatalf("Hit an unsupported type %v.", uet) } sw.Do("*out = make($.|raw$, len(*in))\n", t) @@ -754,7 +754,7 @@ func (g *genDeepCopy) doMap(t *types.Type, sw *generator.SnippetWriter) { case uet.Kind == types.Struct: sw.Do("(*out)[key] = *val.DeepCopy()\n", uet) default: - glog.Fatalf("Hit an unsupported type %v.", uet) + klog.Fatalf("Hit an unsupported type %v.", uet) } sw.Do("}\n", nil) } @@ -795,7 +795,7 @@ func (g *genDeepCopy) doSlice(t *types.Type, sw *generator.SnippetWriter) { } else if uet.Kind == types.Struct { sw.Do("(*in)[i].DeepCopyInto(&(*out)[i])\n", nil) } else { - glog.Fatalf("Hit an unsupported type %v.", uet) + klog.Fatalf("Hit an unsupported type %v.", uet) } sw.Do("}\n", nil) } @@ -863,7 +863,7 @@ func (g *genDeepCopy) doStruct(t *types.Type, sw *generator.SnippetWriter) { sw.Do(fmt.Sprintf("out.$.name$ = in.$.name$.DeepCopy%s()\n", uft.Name.Name), args) sw.Do("}\n", nil) default: - glog.Fatalf("Hit an unsupported type %v.", uft) + klog.Fatalf("Hit an unsupported type %v.", uft) } } } @@ -900,6 +900,6 @@ func (g *genDeepCopy) doPointer(t *types.Type, sw *generator.SnippetWriter) { sw.Do("*out = new($.Elem|raw$)\n", ut) sw.Do("(*in).DeepCopyInto(*out)\n", nil) default: - glog.Fatalf("Hit an unsupported type %v.", uet) + klog.Fatalf("Hit an unsupported type %v.", uet) } } diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go index 6ab8676a..7e3bc6b4 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go @@ -29,7 +29,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) // CustomArgs is used tby the go2idl framework to pass args specific to this @@ -117,11 +117,11 @@ func getManualDefaultingFunctions(context *generator.Context, pkg *types.Package for _, f := range pkg.Functions { if f.Underlying == nil || f.Underlying.Kind != types.Func { - glog.Errorf("Malformed function: %#v", f) + klog.Errorf("Malformed function: %#v", f) continue } if f.Underlying.Signature == nil { - glog.Errorf("Function without signature: %#v", f) + klog.Errorf("Function without signature: %#v", f) continue } signature := f.Underlying.Signature @@ -156,7 +156,7 @@ func getManualDefaultingFunctions(context *generator.Context, pkg *types.Package } v.base = f manualMap[key] = v - glog.V(6).Infof("found base defaulter function for %s from %s", key.Name, f.Name) + klog.V(6).Infof("found base defaulter function for %s from %s", key.Name, f.Name) // Is one of the additional defaulters - a top level defaulter on a type that is // also invoked. case strings.HasPrefix(f.Name.Name, buffer.String()+"_"): @@ -176,7 +176,7 @@ func getManualDefaultingFunctions(context *generator.Context, pkg *types.Package } v.additional = append(v.additional, f) manualMap[key] = v - glog.V(6).Infof("found additional defaulter function for %s from %s", key.Name, f.Name) + klog.V(6).Infof("found additional defaulter function for %s from %s", key.Name, f.Name) } buffer.Reset() sw.Do("$.inType|objectdefaultfn$", args) @@ -189,7 +189,7 @@ func getManualDefaultingFunctions(context *generator.Context, pkg *types.Package } v.object = f manualMap[key] = v - glog.V(6).Infof("found object defaulter function for %s from %s", key.Name, f.Name) + klog.V(6).Infof("found object defaulter function for %s from %s", key.Name, f.Name) } buffer.Reset() } @@ -198,7 +198,7 @@ func getManualDefaultingFunctions(context *generator.Context, pkg *types.Package func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } packages := generator.Packages{} @@ -214,7 +214,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat // We are generating defaults only for packages that are explicitly // passed as InputDir. for _, i := range context.Inputs { - glog.V(5).Infof("considering pkg %q", i) + klog.V(5).Infof("considering pkg %q", i) pkg := context.Universe[i] if pkg == nil { // If the input had no Go files, for example. @@ -248,7 +248,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat shouldCreateObjectDefaulterFn := func(t *types.Type) bool { if defaults, ok := existingDefaulters[t]; ok && defaults.object != nil { // A default generator is defined - glog.V(5).Infof(" an object defaulter already exists as %s", defaults.base.Name) + klog.V(5).Infof(" an object defaulter already exists as %s", defaults.base.Name) return false } // opt-out @@ -285,7 +285,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat var err error typesPkg, err = context.AddDirectory(filepath.Join(pkg.Path, inputTags[0])) if err != nil { - glog.Fatalf("cannot import package %s", inputTags[0]) + klog.Fatalf("cannot import package %s", inputTags[0]) } // update context.Order to the latest context.Universe orderer := namer.Orderer{Namer: namer.NewPublicNamer(1)} @@ -299,7 +299,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } if namer.IsPrivateGoName(t.Name.Name) { // We won't be able to convert to a private type. - glog.V(5).Infof(" found a type %v, but it is a private name", t) + klog.V(5).Infof(" found a type %v, but it is a private name", t) continue } @@ -338,7 +338,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat // prune any types that were not used for t, d := range newDefaulters { if d.object == nil { - glog.V(6).Infof("did not generate defaulter for %s because no child defaulters were registered", t.Name) + klog.V(6).Infof("did not generate defaulter for %s because no child defaulters were registered", t.Name) delete(newDefaulters, t) } } @@ -346,7 +346,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } if len(newDefaulters) == 0 { - glog.V(5).Infof("no defaulters in package %s", pkg.Name) + klog.V(5).Infof("no defaulters in package %s", pkg.Name) } path := pkg.Path @@ -421,7 +421,7 @@ func (c *callTreeForType) build(t *types.Type, root bool) *callNode { parent.call = append(parent.call, newDefaults.object) // if we will be generating the defaulter, it by definition is a covering // defaulter, so we halt recursion - glog.V(6).Infof("the defaulter %s will be generated as an object defaulter", t.Name) + klog.V(6).Infof("the defaulter %s will be generated as an object defaulter", t.Name) return parent case defaults.object != nil: @@ -434,7 +434,7 @@ func (c *callTreeForType) build(t *types.Type, root bool) *callNode { // if the base function indicates it "covers" (it already includes defaulters) // we can halt recursion if checkTag(defaults.base.CommentLines, "covers") { - glog.V(6).Infof("the defaulter %s indicates it covers all sub generators", t.Name) + klog.V(6).Infof("the defaulter %s indicates it covers all sub generators", t.Name) return parent } } @@ -496,7 +496,7 @@ func (c *callTreeForType) build(t *types.Type, root bool) *callNode { } } if len(parent.children) == 0 && len(parent.call) == 0 { - //glog.V(6).Infof("decided type %s needs no generation", t.Name) + //klog.V(6).Infof("decided type %s needs no generation", t.Name) return nil } return parent @@ -596,11 +596,11 @@ func (g *genDefaulter) GenerateType(c *generator.Context, t *types.Type, w io.Wr return nil } - glog.V(5).Infof("generating for type %v", t) + klog.V(5).Infof("generating for type %v", t) callTree := newCallTreeForType(g.existingDefaulters, g.newDefaulters).build(t, true) if callTree == nil { - glog.V(5).Infof(" no defaulters defined") + klog.V(5).Infof(" no defaulters defined") return nil } i := 0 @@ -609,7 +609,7 @@ func (g *genDefaulter) GenerateType(c *generator.Context, t *types.Type, w io.Wr return } path := callPath(append(ancestors, current)) - glog.V(5).Infof(" %d: %s", i, path) + klog.V(5).Infof(" %d: %s", i, path) i++ }) diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go index 7ed7c33a..182f87af 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go @@ -33,7 +33,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) const ( @@ -202,19 +202,19 @@ func (importRuleFile) VerifyFile(f *generator.File, path string) error { return fmt.Errorf("regexp `%s` in file %q doesn't compile: %v", r.SelectorRegexp, actualPath, err) } for v := range f.Imports { - glog.V(4).Infof("Checking %v matches %v: %v\n", r.SelectorRegexp, v, re.MatchString(v)) + klog.V(4).Infof("Checking %v matches %v: %v\n", r.SelectorRegexp, v, re.MatchString(v)) if !re.MatchString(v) { continue } for _, forbidden := range r.ForbiddenPrefixes { - glog.V(4).Infof("Checking %v against %v\n", v, forbidden) + klog.V(4).Infof("Checking %v against %v\n", v, forbidden) if strings.HasPrefix(v, forbidden) { return fmt.Errorf("import %v has forbidden prefix %v", v, forbidden) } } found := false for _, allowed := range r.AllowedPrefixes { - glog.V(4).Infof("Checking %v against %v\n", v, allowed) + klog.V(4).Infof("Checking %v against %v\n", v, allowed) if strings.HasPrefix(v, allowed) { found = true break @@ -226,7 +226,7 @@ func (importRuleFile) VerifyFile(f *generator.File, path string) error { } } if len(rules.Rules) > 0 { - glog.V(2).Infof("%v passes rules found in %v\n", path, actualPath) + klog.V(2).Infof("%v passes rules found in %v\n", path, actualPath) } return nil diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go index 8c5b4184..d0698d33 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/sets.go @@ -25,7 +25,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) // NameSystems returns the name system used by the generators in this package. @@ -47,13 +47,13 @@ func DefaultNameSystem() string { func Packages(_ *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() if err != nil { - glog.Fatalf("Failed loading boilerplate: %v", err) + klog.Fatalf("Failed loading boilerplate: %v", err) } return generator.Packages{&generator.DefaultPackage{ PackageName: "sets", PackagePath: arguments.OutputPackagePath, - HeaderText: boilerplate, + HeaderText: boilerplate, PackageDocumentation: []byte( `// Package sets has auto-generated set types. `), diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go index 34aa7723..bb3b4d25 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/examples/set-gen/generators/tags.go @@ -17,8 +17,8 @@ limitations under the License. package generators import ( - "github.com/golang/glog" "k8s.io/gengo/types" + "k8s.io/klog" ) // extractBoolTagOrDie gets the comment-tags for the key and asserts that, if @@ -27,7 +27,7 @@ import ( func extractBoolTagOrDie(key string, lines []string) bool { val, err := types.ExtractSingleBoolCommentTag("+", key, false, lines) if err != nil { - glog.Fatalf(err.Error()) + klog.Fatalf(err.Error()) } return val } diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/execute.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/execute.go index 38dffff9..b5f5aaeb 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/execute.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/execute.go @@ -29,7 +29,7 @@ import ( "k8s.io/gengo/namer" "k8s.io/gengo/types" - "github.com/golang/glog" + "k8s.io/klog" ) func errs2strings(errors []error) []string { @@ -64,7 +64,7 @@ type DefaultFileType struct { } func (ft DefaultFileType) AssembleFile(f *File, pathname string) error { - glog.V(2).Infof("Assembling file %q", pathname) + klog.V(2).Infof("Assembling file %q", pathname) destFile, err := os.Create(pathname) if err != nil { return err @@ -91,7 +91,7 @@ func (ft DefaultFileType) AssembleFile(f *File, pathname string) error { } func (ft DefaultFileType) VerifyFile(f *File, pathname string) error { - glog.V(2).Infof("Verifying file %q", pathname) + klog.V(2).Infof("Verifying file %q", pathname) friendlyName := filepath.Join(f.PackageName, f.Name) b := &bytes.Buffer{} et := NewErrorTracker(b) @@ -214,7 +214,7 @@ func (c *Context) addNameSystems(namers namer.NameSystems) *Context { // import path already, this will be appended to 'outDir'. func (c *Context) ExecutePackage(outDir string, p Package) error { path := filepath.Join(outDir, p.Path()) - glog.V(2).Infof("Processing package %q, disk location %q", p.Name(), path) + klog.V(2).Infof("Processing package %q, disk location %q", p.Name(), path) // Filter out any types the *package* doesn't care about. packageContext := c.filteredBy(p.Filter) os.MkdirAll(path, 0755) diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/import_tracker.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/import_tracker.go index d4ba5e90..5d058410 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/import_tracker.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/generator/import_tracker.go @@ -19,7 +19,7 @@ package generator import ( "strings" - "github.com/golang/glog" + "k8s.io/klog" "k8s.io/gengo/namer" "k8s.io/gengo/types" @@ -42,7 +42,7 @@ func golangTrackerLocalName(tracker namer.ImportTracker, t types.Name) string { // Using backslashes in package names causes gengo to produce Go code which // will not compile with the gc compiler. See the comment on GoSeperator. if strings.ContainsRune(path, '\\') { - glog.Warningf("Warning: backslash used in import path '%v', this is unsupported.\n", path) + klog.Warningf("Warning: backslash used in import path '%v', this is unsupported.\n", path) } dirs := strings.Split(path, namer.GoSeperator) diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/namer/plural_namer.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/namer/plural_namer.go index 40bdcc6c..a9a198a7 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/namer/plural_namer.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/namer/plural_namer.go @@ -59,7 +59,7 @@ func (r *pluralNamer) Name(t *types.Type) string { return r.finalize(plural) } if len(singular) < 2 { - return r.finalize(plural) + return r.finalize(singular) } switch rune(singular[len(singular)-1]) { @@ -87,7 +87,7 @@ func (r *pluralNamer) Name(t *types.Type) string { plural = sPlural(singular) } case 'f': - plural = vesPlural(singular) + plural = vesPlural(singular) default: plural = sPlural(singular) } diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/parser/parse.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/parser/parse.go index 7b043d71..bf8372d9 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/parser/parse.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/parser/parse.go @@ -31,8 +31,8 @@ import ( "sort" "strings" - "github.com/golang/glog" "k8s.io/gengo/types" + "k8s.io/klog" ) // This clarifies when a pkg path has been canonicalized. @@ -89,7 +89,7 @@ func New() *Builder { // The returned string will have some/path/bin/go, so remove the last two elements. c.GOROOT = filepath.Dir(filepath.Dir(strings.Trim(string(p), "\n"))) } else { - glog.Warningf("Warning: $GOROOT not set, and unable to run `which go` to find it: %v\n", err) + klog.Warningf("Warning: $GOROOT not set, and unable to run `which go` to find it: %v\n", err) } } // Force this to off, since we don't properly parse CGo. All symbols must @@ -136,7 +136,7 @@ func (b *Builder) importBuildPackage(dir string) (*build.Package, error) { } // Remember it under the user-provided name. - glog.V(5).Infof("saving buildPackage %s", dir) + klog.V(5).Infof("saving buildPackage %s", dir) b.buildPackages[dir] = buildPkg canonicalPackage := canonicalizeImportPath(buildPkg.ImportPath) if dir != string(canonicalPackage) { @@ -145,7 +145,7 @@ func (b *Builder) importBuildPackage(dir string) (*build.Package, error) { return buildPkg, nil } // Must be new, save it under the canonical name, too. - glog.V(5).Infof("saving buildPackage %s", canonicalPackage) + klog.V(5).Infof("saving buildPackage %s", canonicalPackage) b.buildPackages[string(canonicalPackage)] = buildPkg } @@ -175,11 +175,11 @@ func (b *Builder) AddFileForTest(pkg string, path string, src []byte) error { func (b *Builder) addFile(pkgPath importPathString, path string, src []byte, userRequested bool) error { for _, p := range b.parsed[pkgPath] { if path == p.name { - glog.V(5).Infof("addFile %s %s already parsed, skipping", pkgPath, path) + klog.V(5).Infof("addFile %s %s already parsed, skipping", pkgPath, path) return nil } } - glog.V(6).Infof("addFile %s %s", pkgPath, path) + klog.V(6).Infof("addFile %s %s", pkgPath, path) p, err := parser.ParseFile(b.fset, path, src, parser.DeclarationErrors|parser.ParseComments) if err != nil { return err @@ -221,7 +221,7 @@ func (b *Builder) AddDir(dir string) error { func (b *Builder) AddDirRecursive(dir string) error { // Add the root. if _, err := b.importPackage(dir, true); err != nil { - glog.Warningf("Ignoring directory %v: %v", dir, err) + klog.Warningf("Ignoring directory %v: %v", dir, err) } // filepath.Walk includes the root dir, but we already did that, so we'll @@ -236,7 +236,7 @@ func (b *Builder) AddDirRecursive(dir string) error { // Add it. if _, err := b.importPackage(pkg, true); err != nil { - glog.Warningf("Ignoring child directory %v: %v", pkg, err) + klog.Warningf("Ignoring child directory %v: %v", pkg, err) } } } @@ -284,7 +284,7 @@ func (b *Builder) AddDirectoryTo(dir string, u *types.Universe) (*types.Package, // The implementation of AddDir. A flag indicates whether this directory was // user-requested or just from following the import graph. func (b *Builder) addDir(dir string, userRequested bool) error { - glog.V(5).Infof("addDir %s", dir) + klog.V(5).Infof("addDir %s", dir) buildPkg, err := b.importBuildPackage(dir) if err != nil { return err @@ -292,7 +292,7 @@ func (b *Builder) addDir(dir string, userRequested bool) error { canonicalPackage := canonicalizeImportPath(buildPkg.ImportPath) pkgPath := canonicalPackage if dir != string(canonicalPackage) { - glog.V(5).Infof("addDir %s, canonical path is %s", dir, pkgPath) + klog.V(5).Infof("addDir %s, canonical path is %s", dir, pkgPath) } // Sanity check the pkg dir has not changed. @@ -324,13 +324,13 @@ func (b *Builder) addDir(dir string, userRequested bool) error { // importPackage is a function that will be called by the type check package when it // needs to import a go package. 'path' is the import path. func (b *Builder) importPackage(dir string, userRequested bool) (*tc.Package, error) { - glog.V(5).Infof("importPackage %s", dir) + klog.V(5).Infof("importPackage %s", dir) var pkgPath = importPathString(dir) // Get the canonical path if we can. if buildPkg := b.buildPackages[dir]; buildPkg != nil { canonicalPackage := canonicalizeImportPath(buildPkg.ImportPath) - glog.V(5).Infof("importPackage %s, canonical path is %s", dir, canonicalPackage) + klog.V(5).Infof("importPackage %s, canonical path is %s", dir, canonicalPackage) pkgPath = canonicalPackage } @@ -349,7 +349,7 @@ func (b *Builder) importPackage(dir string, userRequested bool) (*tc.Package, er // Get the canonical path now that it has been added. if buildPkg := b.buildPackages[dir]; buildPkg != nil { canonicalPackage := canonicalizeImportPath(buildPkg.ImportPath) - glog.V(5).Infof("importPackage %s, canonical path is %s", dir, canonicalPackage) + klog.V(5).Infof("importPackage %s, canonical path is %s", dir, canonicalPackage) pkgPath = canonicalPackage } } @@ -365,9 +365,9 @@ func (b *Builder) importPackage(dir string, userRequested bool) (*tc.Package, er if err != nil { switch { case ignoreError && pkg != nil: - glog.V(2).Infof("type checking encountered some issues in %q, but ignoring.\n", pkgPath) + klog.V(2).Infof("type checking encountered some issues in %q, but ignoring.\n", pkgPath) case !ignoreError && pkg != nil: - glog.V(2).Infof("type checking encountered some errors in %q\n", pkgPath) + klog.V(2).Infof("type checking encountered some errors in %q\n", pkgPath) return nil, err default: return nil, err @@ -389,10 +389,10 @@ func (a importAdapter) Import(path string) (*tc.Package, error) { // errors, so you may check whether the package is nil or not even if you get // an error. func (b *Builder) typeCheckPackage(pkgPath importPathString) (*tc.Package, error) { - glog.V(5).Infof("typeCheckPackage %s", pkgPath) + klog.V(5).Infof("typeCheckPackage %s", pkgPath) if pkg, ok := b.typeCheckedPackages[pkgPath]; ok { if pkg != nil { - glog.V(6).Infof("typeCheckPackage %s already done", pkgPath) + klog.V(6).Infof("typeCheckPackage %s already done", pkgPath) return pkg, nil } // We store a nil right before starting work on a package. So @@ -416,7 +416,7 @@ func (b *Builder) typeCheckPackage(pkgPath importPathString) (*tc.Package, error // method. So there can't be cycles in the import graph. Importer: importAdapter{b}, Error: func(err error) { - glog.V(2).Infof("type checker: %v\n", err) + klog.V(2).Infof("type checker: %v\n", err) }, } pkg, err := c.Check(string(pkgPath), b.fset, files, nil) @@ -469,7 +469,7 @@ func (b *Builder) FindTypes() (types.Universe, error) { // findTypesIn finalizes the package import and searches through the package // for types. func (b *Builder) findTypesIn(pkgPath importPathString, u *types.Universe) error { - glog.V(5).Infof("findTypesIn %s", pkgPath) + klog.V(5).Infof("findTypesIn %s", pkgPath) pkg := b.typeCheckedPackages[pkgPath] if pkg == nil { return fmt.Errorf("findTypesIn(%s): package is not known", pkgPath) @@ -479,7 +479,7 @@ func (b *Builder) findTypesIn(pkgPath importPathString, u *types.Universe) error // packages they asked for depend on will be included. // But we don't need to include all types in all // *packages* they depend on. - glog.V(5).Infof("findTypesIn %s: package is not user requested", pkgPath) + klog.V(5).Infof("findTypesIn %s: package is not user requested", pkgPath) return nil } @@ -775,7 +775,7 @@ func (b *Builder) walkType(u types.Universe, useName *types.Name, in tc.Type) *t return out } out.Kind = types.Unsupported - glog.Warningf("Making unsupported type entry %q for: %#v\n", out, t) + klog.Warningf("Making unsupported type entry %q for: %#v\n", out, t) return out } } diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/types/types.go b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/types/types.go index aa3b7128..ec25248e 100644 --- a/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/types/types.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/gengo/types/types.go @@ -51,10 +51,10 @@ func ParseFullyQualifiedName(fqn string) Name { cs := strings.Split(fqn, ".") pkg := "" if len(cs) > 1 { - pkg = strings.Join(cs[0:len(cs) - 1], ".") + pkg = strings.Join(cs[0:len(cs)-1], ".") } return Name{ - Name: cs[len(cs) - 1], + Name: cs[len(cs)-1], Package: pkg, } } diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/klog/.travis.yml b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/.travis.yml new file mode 100644 index 00000000..fc0d2caf --- /dev/null +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/.travis.yml @@ -0,0 +1,14 @@ +language: go +dist: xenial +go: + - 1.9.x + - 1.10.x + - 1.11.x +script: + - go get -t -v ./... + - diff -u <(echo -n) <(gofmt -d .) + - diff -u <(echo -n) <(golint $(go list -e ./...)) + - go tool vet . + - go test -v -race ./... +install: + - go get golang.org/x/lint/golint diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/klog/CONTRIBUTING.md b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/CONTRIBUTING.md new file mode 100644 index 00000000..de471151 --- /dev/null +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/CONTRIBUTING.md @@ -0,0 +1,31 @@ +# Contributing Guidelines + +Welcome to Kubernetes. We are excited about the prospect of you joining our [community](https://github.com/kubernetes/community)! The Kubernetes community abides by the CNCF [code of conduct](code-of-conduct.md). Here is an excerpt: + +_As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities._ + +## Getting Started + +We have full documentation on how to get started contributing here: + + + +- [Contributor License Agreement](https://git.k8s.io/community/CLA.md) Kubernetes projects require that you sign a Contributor License Agreement (CLA) before we can accept your pull requests +- [Kubernetes Contributor Guide](http://git.k8s.io/community/contributors/guide) - Main contributor documentation, or you can just jump directly to the [contributing section](http://git.k8s.io/community/contributors/guide#contributing) +- [Contributor Cheat Sheet](https://git.k8s.io/community/contributors/guide/contributor-cheatsheet.md) - Common resources for existing developers + +## Mentorship + +- [Mentoring Initiatives](https://git.k8s.io/community/mentoring) - We have a diverse set of mentorship programs available that are always looking for volunteers! + + diff --git a/vendor/github.com/golang/glog/LICENSE b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/LICENSE similarity index 100% rename from vendor/github.com/golang/glog/LICENSE rename to vendor/k8s.io/code-generator/vendor/k8s.io/klog/LICENSE diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/klog/OWNERS b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/OWNERS new file mode 100644 index 00000000..56b0eb04 --- /dev/null +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/OWNERS @@ -0,0 +1,11 @@ +# See the OWNERS docs: https://git.k8s.io/community/contributors/guide/owners.md + +approvers: + - dims + - thockin + - justinsb + - tallclair + - piosz + - brancz + - DirectXMan12 + - lavalamp diff --git a/vendor/github.com/golang/glog/README b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/README.md similarity index 90% rename from vendor/github.com/golang/glog/README rename to vendor/k8s.io/code-generator/vendor/k8s.io/klog/README.md index 5f9c1148..a747f538 100644 --- a/vendor/github.com/golang/glog/README +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/README.md @@ -1,3 +1,10 @@ +klog +==== + +klog is a permanant fork of https://github.com/golang/glog. original README from glog is below + +---- + glog ==== @@ -5,7 +12,7 @@ Leveled execution logs for Go. This is an efficient pure Go implementation of leveled logs in the manner of the open source C++ package - http://code.google.com/p/google-glog + https://github.com/google/glog By binding methods to booleans it is possible to use the log package without paying the expense of evaluating the arguments to the log. diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/klog/RELEASE.md b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/RELEASE.md new file mode 100644 index 00000000..b53eb960 --- /dev/null +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/RELEASE.md @@ -0,0 +1,9 @@ +# Release Process + +The `klog` is released on an as-needed basis. The process is as follows: + +1. An issue is proposing a new release with a changelog since the last release +1. All [OWNERS](OWNERS) must LGTM this release +1. An OWNER runs `git tag -s $VERSION` and inserts the changelog and pushes the tag with `git push $VERSION` +1. The release issue is closed +1. An announcement email is sent to `kubernetes-dev@googlegroups.com` with the subject `[ANNOUNCE] kubernetes-template-project $VERSION is released` diff --git a/vendor/k8s.io/code-generator/vendor/k8s.io/klog/SECURITY_CONTACTS b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/SECURITY_CONTACTS new file mode 100644 index 00000000..520ddb52 --- /dev/null +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/SECURITY_CONTACTS @@ -0,0 +1,20 @@ +# Defined below are the security contacts for this repo. +# +# They are the contact point for the Product Security Team to reach out +# to for triaging and handling of incoming issues. +# +# The below names agree to abide by the +# [Embargo Policy](https://github.com/kubernetes/sig-release/blob/master/security-release-process-documentation/security-release-process.md#embargo-policy) +# and will be removed and replaced if they violate that agreement. +# +# DO NOT REPORT SECURITY VULNERABILITIES DIRECTLY TO THESE NAMES, FOLLOW THE +# INSTRUCTIONS AT https://kubernetes.io/security/ + +dims +thockin +justinsb +tallclair +piosz +brancz +DirectXMan12 +lavalamp diff --git a/vendor/k8s.io/code-generator/vendor/github.com/golang/glog/glog.go b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/klog.go similarity index 93% rename from vendor/k8s.io/code-generator/vendor/github.com/golang/glog/glog.go rename to vendor/k8s.io/code-generator/vendor/k8s.io/klog/klog.go index 3e63fffd..13bcc81a 100644 --- a/vendor/k8s.io/code-generator/vendor/github.com/golang/glog/glog.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/klog.go @@ -14,7 +14,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -// Package glog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup. +// Package klog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup. // It provides functions Info, Warning, Error, Fatal, plus formatting variants such as // Infof. It also provides V-style logging controlled by the -v and -vmodule=file=2 flags. // @@ -68,7 +68,7 @@ // -vmodule=gopher*=3 // sets the V level to 3 in all Go files whose names begin "gopher". // -package glog +package klog import ( "bufio" @@ -396,13 +396,6 @@ type flushSyncWriter interface { } func init() { - flag.BoolVar(&logging.toStderr, "logtostderr", false, "log to standard error instead of files") - flag.BoolVar(&logging.alsoToStderr, "alsologtostderr", false, "log to standard error as well as files") - flag.Var(&logging.verbosity, "v", "log level for V logs") - flag.Var(&logging.stderrThreshold, "stderrthreshold", "logs at or above this threshold go to stderr") - flag.Var(&logging.vmodule, "vmodule", "comma-separated list of pattern=N settings for file-filtered logging") - flag.Var(&logging.traceLocation, "log_backtrace_at", "when logging hits line file:N, emit a stack trace") - // Default stderrThreshold is ERROR. logging.stderrThreshold = errorLog @@ -410,6 +403,22 @@ func init() { go logging.flushDaemon() } +// InitFlags is for explicitly initializing the flags +func InitFlags(flagset *flag.FlagSet) { + if flagset == nil { + flagset = flag.CommandLine + } + flagset.StringVar(&logging.logDir, "log_dir", "", "If non-empty, write log files in this directory") + flagset.StringVar(&logging.logFile, "log_file", "", "If non-empty, use this log file") + flagset.BoolVar(&logging.toStderr, "logtostderr", false, "log to standard error instead of files") + flagset.BoolVar(&logging.alsoToStderr, "alsologtostderr", false, "log to standard error as well as files") + flagset.Var(&logging.verbosity, "v", "log level for V logs") + flagset.BoolVar(&logging.skipHeaders, "skip_headers", false, "If true, avoid header prefixes in the log messages") + flagset.Var(&logging.stderrThreshold, "stderrthreshold", "logs at or above this threshold go to stderr") + flagset.Var(&logging.vmodule, "vmodule", "comma-separated list of pattern=N settings for file-filtered logging") + flagset.Var(&logging.traceLocation, "log_backtrace_at", "when logging hits line file:N, emit a stack trace") +} + // Flush flushes all pending log I/O. func Flush() { logging.lockAndFlushAll() @@ -453,6 +462,17 @@ type loggingT struct { // safely using atomic.LoadInt32. vmodule moduleSpec // The state of the -vmodule flag. verbosity Level // V logging level, the value of the -v flag/ + + // If non-empty, overrides the choice of directory in which to write logs. + // See createLogDirs for the full list of possible destinations. + logDir string + + // If non-empty, specifies the path of the file to write logs. mutually exclusive + // with the log-dir option. + logFile string + + // If true, do not add the prefix headers, useful when used with SetOutput + skipHeaders bool } // buffer holds a byte Buffer for reuse. The zero value is ready for use. @@ -556,6 +576,9 @@ func (l *loggingT) formatHeader(s severity, file string, line int) *buffer { s = infoLog // for safety. } buf := l.getBuffer() + if l.skipHeaders { + return buf + } // Avoid Fprintf, for speed. The format is so simple that we can do it quickly by hand. // It's worth about 3X. Fprintf is hard. @@ -667,6 +690,45 @@ func (l *loggingT) printWithFileLine(s severity, file string, line int, alsoToSt l.output(s, buf, file, line, alsoToStderr) } +// redirectBuffer is used to set an alternate destination for the logs +type redirectBuffer struct { + w io.Writer +} + +func (rb *redirectBuffer) Sync() error { + return nil +} + +func (rb *redirectBuffer) Flush() error { + return nil +} + +func (rb *redirectBuffer) Write(bytes []byte) (n int, err error) { + return rb.w.Write(bytes) +} + +// SetOutput sets the output destination for all severities +func SetOutput(w io.Writer) { + for s := fatalLog; s >= infoLog; s-- { + rb := &redirectBuffer{ + w: w, + } + logging.file[s] = rb + } +} + +// SetOutputBySeverity sets the output destination for specific severity +func SetOutputBySeverity(name string, w io.Writer) { + sev, ok := severityByName(name) + if !ok { + panic(fmt.Sprintf("SetOutputBySeverity(%q): unrecognized severity name", name)) + } + rb := &redirectBuffer{ + w: w, + } + logging.file[sev] = rb +} + // output writes the data to the log files and releases the buffer. func (l *loggingT) output(s severity, buf *buffer, file string, line int, alsoToStderr bool) { l.mu.Lock() @@ -876,7 +938,7 @@ const flushInterval = 30 * time.Second // flushDaemon periodically flushes the log file buffers. func (l *loggingT) flushDaemon() { - for _ = range time.NewTicker(flushInterval).C { + for range time.NewTicker(flushInterval).C { l.lockAndFlushAll() } } diff --git a/vendor/k8s.io/code-generator/vendor/github.com/golang/glog/glog_file.go b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/klog_file.go similarity index 90% rename from vendor/k8s.io/code-generator/vendor/github.com/golang/glog/glog_file.go rename to vendor/k8s.io/code-generator/vendor/k8s.io/klog/klog_file.go index 65075d28..b76a4e10 100644 --- a/vendor/k8s.io/code-generator/vendor/github.com/golang/glog/glog_file.go +++ b/vendor/k8s.io/code-generator/vendor/k8s.io/klog/klog_file.go @@ -16,11 +16,10 @@ // File I/O for logs. -package glog +package klog import ( "errors" - "flag" "fmt" "os" "os/user" @@ -36,13 +35,9 @@ var MaxSize uint64 = 1024 * 1024 * 1800 // logDirs lists the candidate directories for new log files. var logDirs []string -// If non-empty, overrides the choice of directory in which to write logs. -// See createLogDirs for the full list of possible destinations. -var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory") - func createLogDirs() { - if *logDir != "" { - logDirs = append(logDirs, *logDir) + if logging.logDir != "" { + logDirs = append(logDirs, logging.logDir) } logDirs = append(logDirs, os.TempDir()) } @@ -103,6 +98,13 @@ var onceLogDirs sync.Once // successfully, create also attempts to update the symlink for that tag, ignoring // errors. func create(tag string, t time.Time) (f *os.File, filename string, err error) { + if logging.logFile != "" { + f, err := os.Create(logging.logFile) + if err == nil { + return f, logging.logFile, nil + } + return nil, "", fmt.Errorf("log: unable to create log: %v", err) + } onceLogDirs.Do(createLogDirs) if len(logDirs) == 0 { return nil, "", errors.New("log: no log dirs") diff --git a/vendor/k8s.io/klog/.travis.yml b/vendor/k8s.io/klog/.travis.yml new file mode 100644 index 00000000..fc0d2caf --- /dev/null +++ b/vendor/k8s.io/klog/.travis.yml @@ -0,0 +1,14 @@ +language: go +dist: xenial +go: + - 1.9.x + - 1.10.x + - 1.11.x +script: + - go get -t -v ./... + - diff -u <(echo -n) <(gofmt -d .) + - diff -u <(echo -n) <(golint $(go list -e ./...)) + - go tool vet . + - go test -v -race ./... +install: + - go get golang.org/x/lint/golint diff --git a/vendor/k8s.io/klog/CONTRIBUTING.md b/vendor/k8s.io/klog/CONTRIBUTING.md new file mode 100644 index 00000000..de471151 --- /dev/null +++ b/vendor/k8s.io/klog/CONTRIBUTING.md @@ -0,0 +1,31 @@ +# Contributing Guidelines + +Welcome to Kubernetes. We are excited about the prospect of you joining our [community](https://github.com/kubernetes/community)! The Kubernetes community abides by the CNCF [code of conduct](code-of-conduct.md). Here is an excerpt: + +_As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities._ + +## Getting Started + +We have full documentation on how to get started contributing here: + + + +- [Contributor License Agreement](https://git.k8s.io/community/CLA.md) Kubernetes projects require that you sign a Contributor License Agreement (CLA) before we can accept your pull requests +- [Kubernetes Contributor Guide](http://git.k8s.io/community/contributors/guide) - Main contributor documentation, or you can just jump directly to the [contributing section](http://git.k8s.io/community/contributors/guide#contributing) +- [Contributor Cheat Sheet](https://git.k8s.io/community/contributors/guide/contributor-cheatsheet.md) - Common resources for existing developers + +## Mentorship + +- [Mentoring Initiatives](https://git.k8s.io/community/mentoring) - We have a diverse set of mentorship programs available that are always looking for volunteers! + + diff --git a/vendor/k8s.io/code-generator/vendor/github.com/golang/glog/LICENSE b/vendor/k8s.io/klog/LICENSE similarity index 100% rename from vendor/k8s.io/code-generator/vendor/github.com/golang/glog/LICENSE rename to vendor/k8s.io/klog/LICENSE diff --git a/vendor/k8s.io/klog/OWNERS b/vendor/k8s.io/klog/OWNERS new file mode 100644 index 00000000..56b0eb04 --- /dev/null +++ b/vendor/k8s.io/klog/OWNERS @@ -0,0 +1,11 @@ +# See the OWNERS docs: https://git.k8s.io/community/contributors/guide/owners.md + +approvers: + - dims + - thockin + - justinsb + - tallclair + - piosz + - brancz + - DirectXMan12 + - lavalamp diff --git a/vendor/k8s.io/code-generator/vendor/github.com/golang/glog/README b/vendor/k8s.io/klog/README.md similarity index 90% rename from vendor/k8s.io/code-generator/vendor/github.com/golang/glog/README rename to vendor/k8s.io/klog/README.md index 5f9c1148..a747f538 100644 --- a/vendor/k8s.io/code-generator/vendor/github.com/golang/glog/README +++ b/vendor/k8s.io/klog/README.md @@ -1,3 +1,10 @@ +klog +==== + +klog is a permanant fork of https://github.com/golang/glog. original README from glog is below + +---- + glog ==== @@ -5,7 +12,7 @@ Leveled execution logs for Go. This is an efficient pure Go implementation of leveled logs in the manner of the open source C++ package - http://code.google.com/p/google-glog + https://github.com/google/glog By binding methods to booleans it is possible to use the log package without paying the expense of evaluating the arguments to the log. diff --git a/vendor/k8s.io/klog/RELEASE.md b/vendor/k8s.io/klog/RELEASE.md new file mode 100644 index 00000000..b53eb960 --- /dev/null +++ b/vendor/k8s.io/klog/RELEASE.md @@ -0,0 +1,9 @@ +# Release Process + +The `klog` is released on an as-needed basis. The process is as follows: + +1. An issue is proposing a new release with a changelog since the last release +1. All [OWNERS](OWNERS) must LGTM this release +1. An OWNER runs `git tag -s $VERSION` and inserts the changelog and pushes the tag with `git push $VERSION` +1. The release issue is closed +1. An announcement email is sent to `kubernetes-dev@googlegroups.com` with the subject `[ANNOUNCE] kubernetes-template-project $VERSION is released` diff --git a/vendor/k8s.io/klog/SECURITY_CONTACTS b/vendor/k8s.io/klog/SECURITY_CONTACTS new file mode 100644 index 00000000..520ddb52 --- /dev/null +++ b/vendor/k8s.io/klog/SECURITY_CONTACTS @@ -0,0 +1,20 @@ +# Defined below are the security contacts for this repo. +# +# They are the contact point for the Product Security Team to reach out +# to for triaging and handling of incoming issues. +# +# The below names agree to abide by the +# [Embargo Policy](https://github.com/kubernetes/sig-release/blob/master/security-release-process-documentation/security-release-process.md#embargo-policy) +# and will be removed and replaced if they violate that agreement. +# +# DO NOT REPORT SECURITY VULNERABILITIES DIRECTLY TO THESE NAMES, FOLLOW THE +# INSTRUCTIONS AT https://kubernetes.io/security/ + +dims +thockin +justinsb +tallclair +piosz +brancz +DirectXMan12 +lavalamp diff --git a/vendor/github.com/golang/glog/glog.go b/vendor/k8s.io/klog/klog.go similarity index 93% rename from vendor/github.com/golang/glog/glog.go rename to vendor/k8s.io/klog/klog.go index 3e63fffd..13bcc81a 100644 --- a/vendor/github.com/golang/glog/glog.go +++ b/vendor/k8s.io/klog/klog.go @@ -14,7 +14,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -// Package glog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup. +// Package klog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup. // It provides functions Info, Warning, Error, Fatal, plus formatting variants such as // Infof. It also provides V-style logging controlled by the -v and -vmodule=file=2 flags. // @@ -68,7 +68,7 @@ // -vmodule=gopher*=3 // sets the V level to 3 in all Go files whose names begin "gopher". // -package glog +package klog import ( "bufio" @@ -396,13 +396,6 @@ type flushSyncWriter interface { } func init() { - flag.BoolVar(&logging.toStderr, "logtostderr", false, "log to standard error instead of files") - flag.BoolVar(&logging.alsoToStderr, "alsologtostderr", false, "log to standard error as well as files") - flag.Var(&logging.verbosity, "v", "log level for V logs") - flag.Var(&logging.stderrThreshold, "stderrthreshold", "logs at or above this threshold go to stderr") - flag.Var(&logging.vmodule, "vmodule", "comma-separated list of pattern=N settings for file-filtered logging") - flag.Var(&logging.traceLocation, "log_backtrace_at", "when logging hits line file:N, emit a stack trace") - // Default stderrThreshold is ERROR. logging.stderrThreshold = errorLog @@ -410,6 +403,22 @@ func init() { go logging.flushDaemon() } +// InitFlags is for explicitly initializing the flags +func InitFlags(flagset *flag.FlagSet) { + if flagset == nil { + flagset = flag.CommandLine + } + flagset.StringVar(&logging.logDir, "log_dir", "", "If non-empty, write log files in this directory") + flagset.StringVar(&logging.logFile, "log_file", "", "If non-empty, use this log file") + flagset.BoolVar(&logging.toStderr, "logtostderr", false, "log to standard error instead of files") + flagset.BoolVar(&logging.alsoToStderr, "alsologtostderr", false, "log to standard error as well as files") + flagset.Var(&logging.verbosity, "v", "log level for V logs") + flagset.BoolVar(&logging.skipHeaders, "skip_headers", false, "If true, avoid header prefixes in the log messages") + flagset.Var(&logging.stderrThreshold, "stderrthreshold", "logs at or above this threshold go to stderr") + flagset.Var(&logging.vmodule, "vmodule", "comma-separated list of pattern=N settings for file-filtered logging") + flagset.Var(&logging.traceLocation, "log_backtrace_at", "when logging hits line file:N, emit a stack trace") +} + // Flush flushes all pending log I/O. func Flush() { logging.lockAndFlushAll() @@ -453,6 +462,17 @@ type loggingT struct { // safely using atomic.LoadInt32. vmodule moduleSpec // The state of the -vmodule flag. verbosity Level // V logging level, the value of the -v flag/ + + // If non-empty, overrides the choice of directory in which to write logs. + // See createLogDirs for the full list of possible destinations. + logDir string + + // If non-empty, specifies the path of the file to write logs. mutually exclusive + // with the log-dir option. + logFile string + + // If true, do not add the prefix headers, useful when used with SetOutput + skipHeaders bool } // buffer holds a byte Buffer for reuse. The zero value is ready for use. @@ -556,6 +576,9 @@ func (l *loggingT) formatHeader(s severity, file string, line int) *buffer { s = infoLog // for safety. } buf := l.getBuffer() + if l.skipHeaders { + return buf + } // Avoid Fprintf, for speed. The format is so simple that we can do it quickly by hand. // It's worth about 3X. Fprintf is hard. @@ -667,6 +690,45 @@ func (l *loggingT) printWithFileLine(s severity, file string, line int, alsoToSt l.output(s, buf, file, line, alsoToStderr) } +// redirectBuffer is used to set an alternate destination for the logs +type redirectBuffer struct { + w io.Writer +} + +func (rb *redirectBuffer) Sync() error { + return nil +} + +func (rb *redirectBuffer) Flush() error { + return nil +} + +func (rb *redirectBuffer) Write(bytes []byte) (n int, err error) { + return rb.w.Write(bytes) +} + +// SetOutput sets the output destination for all severities +func SetOutput(w io.Writer) { + for s := fatalLog; s >= infoLog; s-- { + rb := &redirectBuffer{ + w: w, + } + logging.file[s] = rb + } +} + +// SetOutputBySeverity sets the output destination for specific severity +func SetOutputBySeverity(name string, w io.Writer) { + sev, ok := severityByName(name) + if !ok { + panic(fmt.Sprintf("SetOutputBySeverity(%q): unrecognized severity name", name)) + } + rb := &redirectBuffer{ + w: w, + } + logging.file[sev] = rb +} + // output writes the data to the log files and releases the buffer. func (l *loggingT) output(s severity, buf *buffer, file string, line int, alsoToStderr bool) { l.mu.Lock() @@ -876,7 +938,7 @@ const flushInterval = 30 * time.Second // flushDaemon periodically flushes the log file buffers. func (l *loggingT) flushDaemon() { - for _ = range time.NewTicker(flushInterval).C { + for range time.NewTicker(flushInterval).C { l.lockAndFlushAll() } } diff --git a/vendor/github.com/golang/glog/glog_file.go b/vendor/k8s.io/klog/klog_file.go similarity index 90% rename from vendor/github.com/golang/glog/glog_file.go rename to vendor/k8s.io/klog/klog_file.go index 65075d28..b76a4e10 100644 --- a/vendor/github.com/golang/glog/glog_file.go +++ b/vendor/k8s.io/klog/klog_file.go @@ -16,11 +16,10 @@ // File I/O for logs. -package glog +package klog import ( "errors" - "flag" "fmt" "os" "os/user" @@ -36,13 +35,9 @@ var MaxSize uint64 = 1024 * 1024 * 1800 // logDirs lists the candidate directories for new log files. var logDirs []string -// If non-empty, overrides the choice of directory in which to write logs. -// See createLogDirs for the full list of possible destinations. -var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory") - func createLogDirs() { - if *logDir != "" { - logDirs = append(logDirs, *logDir) + if logging.logDir != "" { + logDirs = append(logDirs, logging.logDir) } logDirs = append(logDirs, os.TempDir()) } @@ -103,6 +98,13 @@ var onceLogDirs sync.Once // successfully, create also attempts to update the symlink for that tag, ignoring // errors. func create(tag string, t time.Time) (f *os.File, filename string, err error) { + if logging.logFile != "" { + f, err := os.Create(logging.logFile) + if err == nil { + return f, logging.logFile, nil + } + return nil, "", fmt.Errorf("log: unable to create log: %v", err) + } onceLogDirs.Do(createLogDirs) if len(logDirs) == 0 { return nil, "", errors.New("log: no log dirs")